pz-rail-astro-tools 1.0.5__tar.gz → 1.0.7__tar.gz

{pz_rail_astro_tools-1.0.5 → pz_rail_astro_tools-1.0.7}/PKG-INFO

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

{pz_rail_astro_tools-1.0.5 → pz_rail_astro_tools-1.0.7}/src/pz_rail_astro_tools.egg-info/PKG-INFO

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

{pz_rail_astro_tools-1.0.5 → pz_rail_astro_tools-1.0.7}/src/pz_rail_astro_tools.egg-info/SOURCES.txt

@@ -22,7 +22,6 @@ src/pz_rail_astro_tools.egg-info/requires.txt
 src/pz_rail_astro_tools.egg-info/top_level.txt
 src/rail/astro_tools/__init__.py
 src/rail/astro_tools/_version.py
-src/rail/creation/degraders/bl_demo.ipynb
 src/rail/creation/degraders/grid_selection.py
 src/rail/creation/degraders/observing_condition_degrader.py
 src/rail/creation/degraders/photometric_errors.py
@@ -40,6 +39,7 @@ src/rail/examples_data/testdata/rubin_dm_dc2_example2.pq
 src/rail/pipelines/degradation/apply_phot_errors.py
 src/rail/pipelines/degradation/blending.py
 src/rail/pipelines/degradation/spectroscopic_selection_pipeline.py
+src/rail/pipelines/degradation/truth_to_observed.py
 src/rail/tools/photometry_tools.py
 tests/astro_tools/test_core.py
 tests/astro_tools/test_degraders.py

{pz_rail_astro_tools-1.0.5 → pz_rail_astro_tools-1.0.7}/src/rail/astro_tools/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.0.5'
-__version_tuple__ = version_tuple = (1, 0, 5)
+__version__ = version = '1.0.7'
+__version_tuple__ = version_tuple = (1, 0, 7)

pz_rail_astro_tools-1.0.7/src/rail/creation/degraders/unrec_bl_model.py

@@ -0,0 +1,178 @@
+"""Model for Creating Unrecognized Blends"""
+
+from ceci.config import StageParameter as Param
+from rail.creation.degrader import Degrader
+from rail.core.data import PqHandle
+from rail.core.common_params import SHARED_PARAMS
+import numpy as np, pandas as pd
+import FoFCatalogMatching
+
+
+class UnrecBlModel(Degrader):
+    """Model for Creating Unrecognized Blends.
+
+    Finding objects nearby each other. Merge them into one blended
+    Use Friends of Friends for matching. May implement shape matching in the future.
+    Take avergaged Ra and Dec for blended source, and sum up fluxes in each band. May implement merged shapes in the future.
+
+    """
+    name = "UnrecBlModel"
+    config_options = Degrader.config_options.copy()
+    config_options.update(ra_label=Param(str, 'ra', msg='ra column name'),
+                          dec_label=Param(str, 'dec', msg='dec column name'),
+                          linking_lengths=Param(float, 1.0, msg='linking_lengths for FoF matching'),
+                          bands=SHARED_PARAMS,
+                          ref_band=SHARED_PARAMS,
+                          redshift_col=SHARED_PARAMS,
+                          match_size=Param(bool, False, msg='consider object size for finding blends'),
+                          match_shape=Param(bool, False, msg='consider object shape for finding blends'),
+                          obj_size=Param(str, 'obj_size', msg='object size column name'),
+                          a=Param(str, 'semi_major', msg='semi major axis column name'),
+                          b=Param(str, 'semi_minor', msg='semi minor axis column name'),
+                          theta=Param(str, 'orientation', msg='orientation angle column name'))
+
+    outputs = [("output", PqHandle), ("compInd", PqHandle)]
+
+    blend_info_cols = ['group_id', 'n_obj', 'brightest_flux', 'total_flux', 'z_brightest', 'z_weighted', 'z_mean', 'z_stdev']
+
+    def __call__(self, sample, seed: int = None):
+        """The main interface method for ``Degrader``.
+
+        Applies degradation.
+
+        This will attach the sample to this `Degrader` (for introspection and
+        provenance tracking).
+
+        Then it will call the run() and finalize() methods, which need to be
+        implemented by the sub-classes.
+
+        The run() method will need to register the data that it creates to this
+        Estimator by using ``self.add_data('output', output_data)``.
+
+        Finally, this will return a PqHandle providing access to that output
+        data.
+
+        Parameters
+        ----------
+        sample : table-like
+            The sample to be degraded
+        seed : int, default=None
+            An integer to set the numpy random seed
+
+        Returns
+        -------
+        output_data : PqHandle
+            A handle giving access to a table with degraded sample
+        """
+        if seed is not None:
+            self.config.seed = seed
+
+        self.set_data("input", sample)
+        self.run()
+        self.finalize()
+
+        return {'output':self.get_handle("output"), 'compInd':self.get_handle("compInd")}
+
+    def __match_bl__(self, data):
+
+        """Group sources with friends of friends"""
+
+        ra_label, dec_label = self.config.ra_label, self.config.dec_label
+        linking_lengths = self.config.linking_lengths
+
+        results = FoFCatalogMatching.match({'truth': data}, linking_lengths=linking_lengths, ra_label=ra_label, dec_label=dec_label)
+        results.remove_column('catalog_key')
+
+        results = results.to_pandas(index='row_index')
+        results.sort_values(by='row_index', inplace=True)
+
+        ## adding the group id as the last column to data
+        matchData = pd.merge(data, results, left_index=True, right_index=True)
+
+        return matchData, results
+
+    def __merge_bl__(self, data):
+
+        """Merge sources within a group into unrecognized blends."""
+
+        group_id = data['group_id']
+        unique_id = np.unique(group_id)
+
+        ra_label, dec_label = self.config.ra_label, self.config.dec_label
+        cols = [ra_label, dec_label] + [b for b in self.config.bands] + self.blend_info_cols
+
+        N_rows = len(unique_id)
+        N_cols = len(cols)
+
+        # compute the fluxes once for all the galaxies
+        fluxes = {b:10**(-data[b]/2.5) for b in self.config.bands}
+
+        # pull the column indices
+        idx_ra = cols.index(ra_label)
+        idx_dec = cols.index(dec_label)
+        idx_n_obj = cols.index('n_obj')
+        idx_brightest_flux = cols.index('brightest_flux')
+        idx_total_flux = cols.index('total_flux')
+        idx_z_brightest = cols.index('z_brightest')
+        idx_z_mean = cols.index('z_mean')
+        idx_z_weighted = cols.index('z_weighted')
+        idx_z_stdev = cols.index('z_stdev')
+
+        mergeData = np.zeros((N_rows, N_cols))
+        for i, id in enumerate(unique_id):
+
+            # Get the mask for this grouping
+            mask = data['group_id'] == id
+
+            # Get the data and fluxes for this grouping
+            this_group = data[mask]
+            these_fluxes = {b:fluxes[b][mask] for b in self.config.bands}
+
+            # Pull put some useful stuff
+            n_obj = len(this_group)
+            ref_fluxes = these_fluxes[self.config.ref_band]
+            these_redshifts = this_group[self.config.redshift_col]
+
+            ## take the average position for the blended source
+            mergeData[i, idx_ra] = this_group[ra_label].mean()
+            mergeData[i, idx_dec] = this_group[dec_label].mean()
+
+            ## sum up the fluxes into the blended source
+            for b in self.config.bands:
+                mergeData[i, cols.index(b)] = -2.5*np.log10(np.sum(these_fluxes[b]))
+
+            brighest_idx = np.argmax(ref_fluxes)
+
+            mergeData[i, idx_n_obj] = n_obj
+            mergeData[i, idx_brightest_flux] = ref_fluxes.max()
+            mergeData[i, idx_total_flux] = np.sum(ref_fluxes)
+            mergeData[i, idx_z_brightest] = these_redshifts.iloc[brighest_idx]
+            mergeData[i, idx_z_mean] = np.mean(these_redshifts)
+            mergeData[i, idx_z_weighted] = np.sum(these_redshifts*ref_fluxes)/np.sum(ref_fluxes)
+            if n_obj > 1:
+                mergeData[i, idx_z_stdev] = np.std(these_redshifts)
+            else:
+                mergeData[i, idx_z_stdev] = 0.
+
+        mergeData[:,cols.index('group_id')] = unique_id
+        mergeData_df = pd.DataFrame(data=mergeData, columns=cols)
+        mergeData_df['group_id'] = mergeData_df['group_id'].astype(int)
+        mergeData_df['n_obj'] = mergeData_df['n_obj'].astype(int)
+
+        return mergeData_df
+
+    def run(self):
+        """Return pandas DataFrame with blending errors."""
+
+        # Load the input catalog
+        data = self.get_data("input")
+
+        # Match for close-by objects
+        matchData, compInd = self.__match_bl__(data)
+
+        # Merge matched objects into unrec-bl
+        blData = self.__merge_bl__(matchData)
+
+        # Return the new catalog and component index in original catalog
+        self.add_data("output", blData)
+        self.add_data("compInd", compInd)

pz_rail_astro_tools-1.0.7/src/rail/pipelines/degradation/truth_to_observed.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# Prerquisites, os, and numpy
+import os
+import numpy as np
+
+# Various rail modules
+from rail.tools.photometry_tools import Dereddener, Reddener
+
+from rail.core.stage import RailStage, RailPipeline
+
+import ceci
+
+from rail.core.utils import RAILDIR
+
+from rail.creation.degraders.unrec_bl_model import UnrecBlModel
+
+from .spectroscopic_selection_pipeline import SELECTORS, CommonConfigParams
+from .apply_phot_errors import ERROR_MODELS
+
+
+if 'PZ_DUSTMAP_DIR' not in os.environ:  # pragma: no cover
+    os.environ['PZ_DUSTMAP_DIR'] = '.'
+
+dustmap_dir = os.path.expandvars("${PZ_DUSTMAP_DIR}")
+
+
+class TruthToObservedPipeline(RailPipeline):
+
+    default_input_dict = dict(input='dummy.in')
+
+    def __init__(self, error_models=None, selectors=None, blending=False):
+        RailPipeline.__init__(self)
+
+        DS = RailStage.data_store
+        DS.__class__.allow_overwrite = True
+
+        if error_models is None:
+            error_models = ERROR_MODELS.copy()
+
+        if selectors is None:
+            selectors = SELECTORS.copy()
+
+        config_pars = CommonConfigParams.copy()
+
+        self.reddener = Reddener.build(
+            dustmap_dir=dustmap_dir,
+            copy_all_cols=True,
+        )
+        previous_stage = self.reddener
+
+        if blending:
+            self.unrec_bl = UnrecBlModel.build()
+            previous_stage = self.unrec_bl
+
+        for key, val in error_models.items():
+            error_model_class = ceci.PipelineStage.get_stage(val['ErrorModel'], val['Module'])
+            the_error_model = error_model_class.make_and_connect(
+                name=f'error_model_{key}',
+                connections=dict(input=previous_stage.io.output),
+                hdf5_groupname='',
+            )
+            self.add_stage(the_error_model)
+            previous_stage = the_error_model
+
+            dereddener_errors = Dereddener.make_and_connect(
+                name=f"deredden_{key}",
+                dustmap_dir=dustmap_dir,
+                connections=dict(input=previous_stage.io.output),
+                copy_all_cols=True,
+            )
+            self.add_stage(dereddener_errors)
+            previous_stage = dereddener_errors
+            
+            for key2, val2 in selectors.items():
+                the_class = ceci.PipelineStage.get_stage(val2['Select'], val2['Module'])
+                the_selector = the_class.make_and_connect(
+                    name=f'select_{key}_{key2}',
+                    connections=dict(input=previous_stage.io.output),
+                    **config_pars,
+                )            
+                self.add_stage(the_selector)

{pz_rail_astro_tools-1.0.5 → pz_rail_astro_tools-1.0.7}/tests/astro_tools/test_degraders.py

@@ -83,16 +83,14 @@ def data_for_bl():
     DS.__class__.allow_overwrite = True
 
     # generate random normal data
-    columns=['ra', 'dec', 'redshift', 'u', 'g', 'r', 'i', 'z', 'y']
+    columns=['ra', 'dec', 'u', 'g', 'r', 'i', 'z', 'y', 'redshift']
     rng = np.random.default_rng(0)
     x = rng.normal(loc=23, scale=3, size=(1000, len(columns)))
 
     # replace positions with constrained values
     x[:, 0] = np.random.uniform(low=0, high=0.02, size=1000)
     x[:, 1] = np.random.uniform(low=0, high=0.02, size=1000)
-
-    # replace redshifts with reasonable values
-    x[:, 2] = np.linspace(0, 2, x.shape[0])
+    x[:, 8] = np.random.uniform(low=0, high=3.00, size=1000)
 
     # return data in handle wrapping a pandas DataFrame
     df = pd.DataFrame(x, columns=columns)
@@ -423,12 +421,26 @@ def test_EucliErrorModel(data):
 
 def test_BLModel(data_for_bl):
     # Setup the stage
-    degrader = UnrecBlModel.make_stage()
+
+    degrader = UnrecBlModel.make_stage(
+        name='unrec_bl_model',
+        ra_label='ra',
+        dec_label='dec',
+        linking_lengths=1.0,
+        bands='ugrizy',
+        ref_band='i',
+        seed=1234)
 
     # Apply the degrader and get the data out
-    degraded_data = degrader(data_for_bl).data
+    outputs = degrader(data_for_bl)
+    degraded_data = outputs['output'].data
+    truth_components = outputs['compInd'].data
 
     # Check output data has less rows than input data
     assert degraded_data.shape[0] < data_for_bl.data.shape[0]
 
+    # Check components has the same rows as input data
+    assert truth_components.shape[0] == data_for_bl.data.shape[0]
+
     os.remove(degrader.get_output(degrader.get_aliased_tag("output"), final_name=True))
+    os.remove(degrader.get_output(degrader.get_aliased_tag("compInd"), final_name=True))

pz_rail_astro_tools-1.0.7/tests/astro_tools/test_pipline.py

@@ -0,0 +1,17 @@
+import os
+from rail.utils.testing_utils import build_and_read_pipeline
+
+import pytest
+
+@pytest.mark.parametrize(
+    "pipeline_class, options",
+    [
+        ('rail.pipelines.degradation.apply_phot_errors.ApplyPhotErrorsPipeline', {}),
+        ('rail.pipelines.degradation.blending.BlendingPipeline', {}),
+        ('rail.pipelines.degradation.spectroscopic_selection_pipeline.SpectroscopicSelectionPipeline', {}),
+        ('rail.pipelines.degradation.truth_to_observed.TruthToObservedPipeline', {'blending':True}),
+    ]
+)
+def test_build_and_read_pipeline(pipeline_class, options):
+    build_and_read_pipeline(pipeline_class, **options)
+

pz_rail_astro_tools-1.0.5/src/rail/creation/degraders/bl_demo.ipynb

@@ -1,206 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "2610a0f0-0c71-4401-896f-734442bcd66d",
-   "metadata": {},
-   "source": [
-    "## Blending Degrader demo\n",
-    "\n",
-    "author: Shuang Liang\n",
-    "\n",
-    "This notebook demonstrate the use of `rail.creation.degradation.unrec_bl_model`, which uses Friends of Friends to finds sources close to each other and merge them into unrecognized blends"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f7a6adc3-68e8-4a1d-842f-bfb0960a1c4a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from rail.creation.degraders.unrec_bl_model import UnrecBlModel\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, numpy as np"
-   ]
-  },
-  {
-   "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,12))\n",
-    "data[:, 0] = np.random.uniform(low=0, high=0.03, size=1000)\n",
-    "data[:, 1] = np.random.uniform(low=0, high=0.03, size=1000)\n",
-    "\n",
-    "data_df = pd.DataFrame(data=data,    # values\n",
-    "            columns=['ra', 'dec', 'u', 'g', 'r', 'i', 'z', 'y', 'Y', 'J', 'H', 'F'])\n",
-    "\n",
-    "data_truth = DS.add_data('input', data_df, PqHandle)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "33c99a4d-8375-4003-9a9a-70fa85a3eb82",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "#data_df.to_parquet('bl_test.pq')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a5636721-a734-4746-bd93-8101bc558b6e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "plt.scatter(data_truth.data['ra'], data_truth.data['dec'], s=5)\n",
-    "plt.xlabel(\"Ra [Deg]\", fontsize=14)\n",
-    "plt.ylabel(\"Dec [Deg]\", fontsize=14)\n",
-    "plt.show()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "1da27deb-d167-4f38-8c59-f270184d6ab3",
-   "metadata": {},
-   "source": [
-    "### The blending model"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a07f72a0-e24c-4844-90f0-d5a49ac4362b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "## radius cut is in arcsecs\n",
-    "blModel = UnrecBlModel.make_stage(name='unrec_bl_model', ra_label='ra', dec_label='dec', linking_lengths=1.0, \\\n",
-    "                                  bands='ugrizyYJHF')\n",
-    "blModel.get_config_dict()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "e5f4862a-0621-46d4-8901-7e84b461c424",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "samples_w_bl = blModel(data_truth)\n",
-    "samples_w_bl()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "bc5158dd-f474-4731-b847-b4a7358656b9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "fig, ax = plt.subplots(figsize=(6, 5), dpi=100)\n",
-    "\n",
-    "ax.scatter(data_truth.data['ra'],   data_truth.data['dec'],   s=10, facecolors='none', edgecolors='b', label='Original')\n",
-    "ax.scatter(samples_w_bl.data['ra'], samples_w_bl.data['dec'], s=5, c='r', label='w. Unrec-BL')\n",
-    "\n",
-    "ax.legend(loc=2, fontsize=12)\n",
-    "ax.set_xlabel(\"Ra [Deg]\", fontsize=14)\n",
-    "ax.set_ylabel(\"Dec [Deg]\", fontsize=14)\n",
-    "\n",
-    "plt.show()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "268b3d37-b7fd-4ac1-8457-2104a87c9e6d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "b = 'r'\n",
-    "plt.hist(data_truth.data[b], bins=np.linspace(10, 30, 20), label='Original')\n",
-    "plt.hist(samples_w_bl.data[b], bins=np.linspace(10, 30, 20),  fill=False, label='w. Unrec-BL')\n",
-    "\n",
-    "plt.xlabel(fr'Magnitude ${b}$', fontsize=14)\n",
-    "plt.legend(fontsize=12)\n",
-    "plt.show()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a1d51c15-1e04-4b22-9abb-9b267965dbeb",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "flux = 10**(-(data_truth.data[b]-28.10)/2.5)       # r band zp for lsst is 28.10\n",
-    "flux_bl = 10**(-(samples_w_bl.data[b]-28.10)/2.5)\n",
-    "\n",
-    "plt.hist(flux, bins=np.linspace(0, 10000, 40), label='Original')\n",
-    "plt.hist(flux_bl, bins=np.linspace(0, 10000, 40), fill=False, label='w. Unrec-BL')\n",
-    "\n",
-    "plt.xlabel(fr'Flux ${b}$', fontsize=14)\n",
-    "plt.yscale('log')\n",
-    "plt.legend(fontsize=12)\n",
-    "plt.show()\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "da2b37c8-4667-4ad2-ad09-b1c68d2612b8",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "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.12.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

pz_rail_astro_tools-1.0.5/src/rail/creation/degraders/unrec_bl_model.py

@@ -1,98 +0,0 @@
-"""Model for Creating Unrecognized Blends"""
-
-from ceci.config import StageParameter as Param
-from rail.creation.degrader import Degrader
-import numpy as np, pandas as pd
-import FoFCatalogMatching
-
-
-class UnrecBlModel(Degrader):
-    """Model for Creating Unrecognized Blends.
-
-    Finding objects nearby each other. Merge them into one blended
-    Use Friends of Friends for matching. May implement shape matching in the future.
-    Take avergaged Ra and Dec for blended source, and sum up fluxes in each band. May implement merged shapes in the future.
-
-    """
-    name = "UnrecBlModel"
-    config_options = Degrader.config_options.copy()
-    config_options.update(ra_label=Param(str, 'ra', msg='ra column name'),
-                          dec_label=Param(str, 'dec', msg='dec column name'),
-                          linking_lengths=Param(float, 1.0, msg='linking_lengths for FoF matching'),
-                          bands=Param(str, 'ugrizy', msg='name of filters'),
-                          match_size=Param(bool, False, msg='consider object size for finding blends'),
-                          match_shape=Param(bool, False, msg='consider object shape for finding blends'),
-                          obj_size=Param(str, 'obj_size', msg='object size column name'),
-                          a=Param(str, 'semi_major', msg='semi major axis column name'),
-                          b=Param(str, 'semi_minor', msg='semi minor axis column name'),
-                          theta=Param(str, 'orientation', msg='orientation angle column name'))
-
-    def __match_bl__(self, data):
-
-        """Group sources with friends of friends"""
-
-        ra_label, dec_label = self.config.ra_label, self.config.dec_label
-        linking_lengths = self.config.linking_lengths
-
-        results = FoFCatalogMatching.match({'truth': data}, linking_lengths=linking_lengths, ra_label=ra_label, dec_label=dec_label)
-        results.remove_column('catalog_key')
-
-        results = results.to_pandas(index='row_index')
-        results.sort_values(by='row_index', inplace=True)
-
-        ## adding the group id as the last column to data
-        matchData = pd.merge(data, results, left_index=True, right_index=True)
-
-        return matchData
-
-    def __merge_bl__(self, data):
-
-        """Merge sources within a group into unrecognized blends."""
-        
-        group_id = data['group_id']
-        unique_id = np.unique(group_id)
-
-        ra_label, dec_label = self.config.ra_label, self.config.dec_label
-
-        cols = list(data.columns)
-        ra_ind = cols.index(ra_label)
-        dec_ind = cols.index(dec_label)
-        bands_ind = {b:cols.index(b) for b in self.config.bands}
-
-        N_rows = len(unique_id)
-        N_cols = len(cols)
-
-        mergeData = np.zeros((N_rows, N_cols))
-        
-        for i, id in enumerate(unique_id):
-
-            this_group = data.query(f'group_id=={id}')
-
-            ## take the average position for the blended source
-            mergeData[i, ra_ind] = this_group[ra_label].mean()
-            mergeData[i, dec_ind] = this_group[dec_label].mean()
-
-            ## sum up the fluxes into the blended source
-            for b in self.config.bands:
-                  mergeData[i, bands_ind[b]] = -2.5*np.log10(np.sum(10**(-this_group[b]/2.5)))
-
-        mergeData[:,-1] = unique_id
-        mergeData_df = pd.DataFrame(data=mergeData, columns=cols)
-        mergeData_df['group_id'] = mergeData_df['group_id'].astype(int)
-
-        return mergeData_df
-
-    def run(self):
-        """Return pandas DataFrame with blending errors."""
-
-        # Load the input catalog
-        data = self.get_data("input")
-
-        # Match for close-by objects
-        matchData = self.__match_bl__(data)
-
-        # Merge matched objects into unrec-bl
-        blData = self.__merge_bl__(matchData)
-
-        # Return the new catalog
-        self.add_data("output", blData)

pz_rail_astro_tools-1.0.5/tests/astro_tools/test_pipline.py

@@ -1,16 +0,0 @@
-import os
-from rail.utils.testing_utils import build_and_read_pipeline
-
-import pytest
-
-@pytest.mark.parametrize(
-    "pipeline_class",
-    [
-        'rail.pipelines.degradation.apply_phot_errors.ApplyPhotErrorsPipeline',
-        'rail.pipelines.degradation.blending.BlendingPipeline',
-        'rail.pipelines.degradation.spectroscopic_selection_pipeline.SpectroscopicSelectionPipeline',
-    ]
-)
-def test_build_and_read_pipeline(pipeline_class):
-    build_and_read_pipeline(pipeline_class)
-