sacc 1.0.2__py3-none-any.whl → 2.0.1__py3-none-any.whl

sacc/tracers/nz.py

@@ -0,0 +1,285 @@
+from .base import BaseTracer, ONE_OBJECT_PER_TABLE, ONE_OBJECT_MULTIPLE_TABLES
+from astropy.table import Table
+import numpy as np
+from ..utils import remove_dict_null_values
+
+class NZTracer(BaseTracer, type_name='NZ'):
+    """
+    A Tracer type for tomographic n(z) data.
+
+    Takes two arguments arrays of z and n(z)
+
+    Parameters
+    ----------
+    name: str
+        The name for this specific tracer, e.g. a
+        tomographic bin identifier.
+
+    z: array
+        Redshift sample values
+
+    nz: array
+        Number density n(z) at redshift sample points.
+
+    extra_columns: dict[str: array] or dict[int: array]
+        Additional estimates of the same n(z), by name
+    """
+
+    storage_type = ONE_OBJECT_PER_TABLE
+
+    def __init__(self, name, z, nz,
+                 extra_columns=None, **kwargs):
+        """
+        Create a tracer corresponding to a distribution in redshift n(z),
+        for example of galaxies.
+
+        Parameters
+        ----------
+        name: str
+            The name for this specific tracer, e.g. a
+            tomographic bin identifier.
+
+        z: array
+            Redshift sample values
+
+        nz: array
+            Number density n(z) at redshift sample points.
+
+        extra_columns: dict[str:array]
+            Optional, default=None.  Additional realizations or
+            estimates of the same n(z), by name.
+
+        Returns
+        -------
+        instance: NZTracer object
+            An instance of this class
+        """
+        super().__init__(name, **kwargs)
+        self.z = np.array(z)
+        self.nz = np.array(nz)
+        self.extra_columns = {} if extra_columns is None else extra_columns
+
+    def to_table(self):
+        """Convert a list of NZTracers to a list of astropy tables
+
+        This is used when saving data to a file.
+        One table is generated per tracer.
+
+        Parameters
+        ----------
+        instance_list: list
+            List of tracer instances
+
+        Returns
+        -------
+        tables: list
+            List of astropy tables
+        """
+        names = ['z', 'nz']
+        cols = [self.z, self.nz]
+        for nz_id, col in self.extra_columns.items():
+            names.append(str(nz_id))
+            cols.append(col)
+        table = Table(data=cols, names=names)
+        table.meta['SACCQTTY'] = self.quantity
+        # This will also get set at the higher level
+        # if the tracer is save to a file, but for
+        # testing it's useful to have it here too.
+        table.meta['SACCNAME'] = self.name
+        for key, value in self.metadata.items():
+            table.meta['META_'+key] = value
+        remove_dict_null_values(table.meta)
+        return table
+
+    @classmethod
+    def from_table(cls, table):
+        """Convert an astropy table into a an n(z) tracer
+
+        This is used when loading data from a file.
+
+        Parameters
+        ----------
+        table: astropy.table.Table
+            Must contain the appropriate data, for example as saved
+            by to_table.
+
+        Returns
+        -------
+        tracers: dict
+            Dict mapping string names to tracer objects.
+            Only contains one key/value pair for the one tracer.
+        """
+        name = table.meta['SACCNAME']
+        quantity = table.meta.get('SACCQTTY', 'generic')
+        z = table['z']
+        nz = table['nz']
+        extra_columns = {}
+        for col in table.columns.values():
+            if col.name not in ['z', 'nz']:
+                extra_columns[col.name] = col.data
+
+        metadata = {}
+        for key, value in table.meta.items():
+            if key.startswith("META_"):
+                metadata[key[5:]] = value
+        return cls(name, z, nz,
+                            quantity=quantity,
+                            extra_columns=extra_columns,
+                            metadata=metadata)
+
+
+
+class QPNZTracer(BaseTracer, type_name='QPNZ'):
+    """
+    A Tracer type for tomographic n(z) data represented as a `qp.Ensemble`
+
+    Takes a `qp.Ensemble` and optionally a redshift array.
+
+    Requires the `qp` and `tables_io` packages to be installed.
+
+    Parameters
+    ----------
+    name: str
+        The name for this specific tracer, e.g. a
+        tomographic bin identifier.
+
+    ensemble: qp.Ensemble
+        The qp.ensemble in questions
+    """
+
+    storage_type = ONE_OBJECT_MULTIPLE_TABLES
+
+    def __init__(self, name, ens, z=None, nz=None, **kwargs):
+        """
+        Create a tracer corresponding to a distribution in redshift n(z),
+        for example of galaxies.
+
+        Parameters
+        ----------
+        name: str
+            The name for this specific tracer, e.g. a
+            tomographic bin identifier.
+
+        ensemble: qp.Ensemble
+            The qp.ensemble in questions
+
+        z: array
+            Optional grid of redshift values at which to evaluate the ensemble.
+            If left as None then the ensemble metadata is checked for a grid.
+            If that is not present then no redshift grid is saved.
+        nz: array
+            Optional, default=None.  establishes a fiducial n(z) for the ensemble.
+            This can later be used to compute systematic biases in the ensemble.
+
+        Returns
+        -------
+        instance: NZTracer object
+            An instance of this class
+        """
+        super().__init__(name, **kwargs)
+        self.ensemble = ens
+        if z is None:
+            ens_meta = ens.metadata
+            if 'bins' in list(ens_meta.keys()):
+                z = ens_meta['bins'][0]
+        self.z = z
+        if z is None:
+            self.nz = None
+        else:
+            if nz is not None:
+                if len(nz) != len(z):
+                    raise ValueError("nz must have the same length as z")
+                self.nz = nz
+            else:
+                nz = np.atleast_2d(ens.pdf(z))
+                self.nz = np.mean(nz, axis=0)
+
+    def to_tables(self):
+        """Convert a list of NZTracers to a list of astropy tables
+
+        This is used when saving data to a file.
+        Two or three tables are generated per tracer.
+
+        Parameters
+        ----------
+        instance_list: list
+            List of tracer instances
+
+        Returns
+        -------
+        tables: list
+            List of astropy tables
+        """
+        from ..utils import convert_to_astropy_table
+        tables = {}
+
+        table_dict = self.ensemble.build_tables()
+
+        data_table = convert_to_astropy_table(table_dict['data'])
+        data_table.meta['SACCQTTY'] = self.quantity
+        data_table.meta['SACCNAME'] = self.name
+        tables["data"] = data_table
+
+        meta_table = convert_to_astropy_table(table_dict['meta'])
+        meta_table.meta['SACCQTTY'] = self.quantity
+        meta_table.meta['SACCNAME'] = self.name
+
+        for kk, vv in self.metadata.items():
+            meta_table.meta['META_'+kk] = vv
+
+        tables["meta"] = meta_table
+
+        if 'ancil' in table_dict:
+            ancil_table = convert_to_astropy_table(table_dict['ancil'])
+            ancil_table.meta['SACCQTTY'] = self.quantity
+            ancil_table.meta['SACCNAME'] = self.name
+            tables["ancil"] = ancil_table
+
+        if self.z is not None:
+            names = ['z', 'nz']
+            cols = [self.z, self.nz]
+            fid_table = Table(data=cols, names=names)
+            fid_table.meta['SACCQTTY'] = self.quantity
+            fid_table.meta['SACCNAME'] = self.name
+            tables["fid"] = fid_table
+
+
+        return tables
+
+    @classmethod
+    def from_tables(cls, tables):
+        """Convert a dict of astropy tables into a tracer
+
+        This is used when loading data from a file.
+        A single tracer object is read from the table.
+
+        Parameters
+        ----------
+        tables: dict[str,astropy.table.Table]
+            Must contain the appropriate data, for example as saved
+            by to_tables.
+
+        Returns
+        -------
+        tracer: QPNZTracer
+        """
+        import qp
+
+
+        meta_table = tables['meta']
+        if 'fid' in tables:
+            z = tables['fid']['z']
+            nz = tables['fid']['nz']
+        else:
+            z = None
+            nz = None
+        ensemble = qp.from_tables(tables)
+        name = meta_table.meta['SACCNAME']
+        quantity = meta_table.meta.get('SACCQTTY', 'generic')
+        metadata = {}
+        for key, value in meta_table.meta.items():
+            if key.startswith("META_"):
+                metadata[key[5:]] = value
+        return cls(name, ensemble, z=z, nz=nz,
+                            quantity=quantity,
+                            metadata=metadata)

sacc/tracers/survey.py

@@ -0,0 +1,75 @@
+from .base import BaseTracer, MULTIPLE_OBJECTS_PER_TABLE
+from astropy.table import Table
+
+
+class SurveyTracer(BaseTracer, type_name="survey"):  # type: ignore
+    """A tracer for the survey definition. It shall 
+    be used to filter data related to a given survey
+    and to provide the survey sky-area of analysis."""
+
+    storage_type = MULTIPLE_OBJECTS_PER_TABLE
+
+    def __eq__(self, other) -> bool:
+        """Test for equality. If :python:`other` is not a
+        :python:`SurveyTracer`, then it is not equal to :python:`self`.
+        Otherwise, they are equal if names and the sky-areas are equal."""
+        if not isinstance(other, SurveyTracer):
+            return False
+        return self.name == other.name and self.sky_area == other.sky_area
+
+    def __init__(self, name: str, sky_area: float, **kwargs):
+        """
+        Create a tracer corresponding to the survey definition.
+
+        :param name: The name of the tracer
+        :param sky_area: The survey's sky area in square degrees
+        """
+        super().__init__(name, **kwargs)
+        self.sky_area = sky_area
+
+    @classmethod
+    def to_table(cls, instance_list):
+        """Convert a list of SurveyTracer to a list of astropy tables
+
+        This is used when saving data to a file.
+        One table is generated with the information for all the tracers.
+
+        :param instance_list: List of tracer instances
+        :return: List of astropy tables with one table
+        """
+        names = ["name", "quantity", "sky_area"]
+
+        cols = [
+            [obj.name for obj in instance_list],
+            [obj.quantity for obj in instance_list],
+            [obj.sky_area for obj in instance_list],
+        ]
+
+        table = Table(data=cols, names=names)
+        table.meta["SACCTYPE"] = "tracer"
+        table.meta["SACCCLSS"] = cls.type_name
+        table.meta["EXTNAME"] = f"tracer:{cls.type_name}"
+        return table
+
+    @classmethod
+    def from_table(cls, table):
+        """Convert an astropy table into a dictionary of tracers
+
+        This is used when loading data from a file.
+        One tracer object is created for each "row" in each table.
+
+        :param table_list: List of astropy tables
+        :return: Dictionary of tracers
+        """
+        tracers = {}
+
+        for row in table:
+            name = row["name"]
+            quantity = row["quantity"]
+            sky_area = row["sky_area"]
+            tracers[name] = cls(
+                name,
+                quantity=quantity,
+                sky_area=sky_area,
+            )
+        return tracers

sacc/utils.py

@@ -151,8 +151,7 @@ def invert_spd_matrix(M, strict=True):
         invM, info = scipy.linalg.lapack.dpotri(L)
         if info:
             raise ValueError("Matrix is not symmetric-positive-definite")
-        else:
-            invM = np.triu(invM) + np.triu(invM, k=1).T
+        invM = np.triu(invM) + np.triu(invM, k=1).T
     # Otherwise we use the generic (and also slower) method that will
     # work if, due to numerical issues, the matrix is not quite SPD
     else:
@@ -166,3 +165,48 @@ def camel_case_split_and_lowercase(identifier):
                           '|(?<=[A-Z])(?=[A-Z][a-z])|$)',
                           identifier)
     return [m.group(0).lower() for m in matches]
+
+
+def convert_to_astropy_table(obj):
+    try:
+        from tables_io.convUtils import convertToApTables
+        version = 1
+    except ImportError:
+        try:
+            from tables_io import convert_table
+            version = 2
+        except ImportError:
+            raise ImportError("Error importing table conversion tool from tables_io. "
+                              "Maybe they changed its name again. Please open an issue, "
+                              "assuming you have tables_io installed.")
+
+    if version == 1:
+        return convertToApTables(obj)
+    if version == 2:
+        return convert_table(obj, "astropyTable")
+    raise ValueError("Unknown version of tables_io conversion tool.")
+
+
+def numpy_to_vanilla(x):
+    """
+    Convert a NumPy scalar type to its corresponding Python built-in type.
+
+    Parameters
+    ----------
+    x : numpy scalar
+        A NumPy scalar value (e.g., np.str_, np.int64, np.float64, np.bool).
+
+    Returns
+    -------
+    object
+        The equivalent Python built-in type (e.g., str, int, float, bool).
+    """
+    if type(x) == np.str_:
+        x = str(x)
+    elif type(x) == np.int64:
+        x = int(x)
+    elif type(x) == np.float64:
+        x = float(x)
+    elif type(x) == np.bool:
+        x = bool(x)
+    return x