sacc 1.0__py3-none-any.whl → 2.0__py3-none-any.whl

sacc/tracers/clusters.py

@@ -0,0 +1,332 @@
+from .base import BaseTracer, MULTIPLE_OBJECTS_PER_TABLE
+from astropy.table import Table
+
+class BinZTracer(BaseTracer, type_name="bin_z"):  # type: ignore
+    """A tracer for a single redshift bin. The tracer shall
+    be used for binned data where we want a desired quantity
+    per interval of redshift, such that we only need the data
+    for a given interval instead of at individual redshifts."""
+
+    storage_type = MULTIPLE_OBJECTS_PER_TABLE
+
+    def __init__(self, name: str, lower: float, upper: float, **kwargs):
+        """
+        Create a tracer corresponding to a single redshift bin.
+
+        :param name: The name of the tracer
+        :param lower: The lower bound of the redshift bin
+        :param upper: The upper bound of the redshift bin
+        """
+        super().__init__(name, **kwargs)
+        self.lower = lower
+        self.upper = upper
+
+    def __eq__(self, other) -> bool:
+        """Test for equality.  If :python:`other` is not a
+        :python:`BinZTracer`, then it is not equal to :python:`self`.
+        Otherwise, they are equal if names, and the z-range of the bins,
+        are equal."""
+        if not isinstance(other, BinZTracer):
+            return False
+        return (
+            self.name == other.name
+            and self.lower == other.lower
+            and self.upper == other.upper
+        )
+
+    @classmethod
+    def to_table(cls, instance_list):
+        """Convert a list of BinZTracers to a single astropy table
+
+        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 with a single astropy table
+        """
+
+        names = ["name", "quantity", "lower", "upper"]
+
+        cols = [
+            [obj.name for obj in instance_list],
+            [obj.quantity for obj in instance_list],
+            [obj.lower for obj in instance_list],
+            [obj.upper 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"]
+            lower = row["lower"]
+            upper = row["upper"]
+            tracers[name] = cls(name, quantity=quantity, lower=lower, upper=upper)
+        return tracers
+
+class BinLogMTracer(BaseTracer, type_name="bin_logM"):  # type: ignore
+    """A tracer for a single log-mass bin. The tracer shall
+    be used for binned data where we want a desired quantity
+    per interval of log(mass), such that we only need the data
+    for a given interval instead of at individual masses."""
+    storage_type = MULTIPLE_OBJECTS_PER_TABLE
+
+    def __init__(self, name: str, lower: float, upper: float, **kwargs):
+        """
+        Create a tracer corresponding to a single log-mass bin.
+
+        :param name: The name of the tracer
+        :param lower: The lower bound of the log-mass bin
+        :param upper: The upper bound of the log-mass bin
+        """
+        super().__init__(name, **kwargs)
+        self.lower = lower
+        self.upper = upper
+
+    def __eq__(self, other) -> bool:
+        """Test for equality.  If :python:`other` is not a
+        :python:`BinLogMTracer`, then it is not equal to :python:`self`.
+        Otherwise, they are equal if names, and the z-range of the bins,
+        are equal."""
+        if not isinstance(other, BinLogMTracer):
+            return False
+        return (
+            self.name == other.name
+            and self.lower == other.lower
+            and self.upper == other.upper
+        )
+
+    @classmethod
+    def to_table(cls, instance_list):
+        """Convert a list of BinLogMTracers to a single astropy table
+
+        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 with a single astropy table
+        """
+
+        names = ["name", "quantity", "lower", "upper"]
+
+        cols = [
+            [obj.name for obj in instance_list],
+            [obj.quantity for obj in instance_list],
+            [obj.lower for obj in instance_list],
+            [obj.upper 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"]
+            lower = row["lower"]
+            upper = row["upper"]
+            tracers[name] = cls(name, quantity=quantity, lower=lower, upper=upper)
+        return tracers
+
+
+class BinRichnessTracer(BaseTracer, type_name="bin_richness"):  # type: ignore
+    """A tracer for a single richness bin. The tracer shall
+    be used for binned data where we want a desired quantity
+    per interval of log(richness), such that we only need the data
+    for a given interval instead of at individual richness."""
+    storage_type = MULTIPLE_OBJECTS_PER_TABLE
+
+    def __eq__(self, other) -> bool:
+        """Test for equality. If :python:`other` is not a
+        :python:`BinRichnessTracer`, then it is not equal to :python:`self`.
+        Otherwise, they are equal if names and the richness-range of the
+        bins, are equal."""
+        if not isinstance(other, BinRichnessTracer):
+            return False
+        return (
+            self.name == other.name
+            and self.lower == other.lower
+            and self.upper == other.upper
+        )
+
+    def __init__(self, name: str, lower: float, upper: float, **kwargs):
+        """
+        Create a tracer corresponding to a single richness bin.
+
+        :param name: The name of the tracer
+        :param lower: The lower bound of the richness bin in log10.
+        :param upper: The upper bound of the richness bin in log10.
+        """
+        super().__init__(name, **kwargs)
+        self.lower = lower
+        self.upper = upper
+
+    @classmethod
+    def to_table(cls, instance_list):
+        """Convert a list of BinZTracers 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 with a single astropy table
+        """
+        names = ["name", "quantity", "lower", "upper"]
+
+        cols = [
+            [obj.name for obj in instance_list],
+            [obj.quantity for obj in instance_list],
+            [obj.lower for obj in instance_list],
+            [obj.upper 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"]
+            lower = row["lower"]
+            upper = row["upper"]
+            tracers[name] = cls(
+                name,
+                quantity=quantity,
+                lower=lower,
+                upper=upper,
+            )
+        return tracers
+
+
+class BinRadiusTracer(BaseTracer, type_name="bin_radius"):  # type: ignore
+    """A tracer for a single radial bin, e.g. when dealing with cluster shear profiles.
+    It gives the bin edges and the value of the bin "center". The latter would typically
+    be returned by CLMM and correspond to the average radius of the galaxies in that
+    radial bin. """
+
+    storage_type = MULTIPLE_OBJECTS_PER_TABLE
+
+    def __eq__(self, other) -> bool:
+        """Test for equality. If :python:`other` is not a
+        :python:`BinRadiusTracer`, then it is not equal to :python:`self`.
+        Otherwise, they are equal if names and the r-range and centers of the
+        bins, are equal."""
+        if not isinstance(other, BinRadiusTracer):
+            return False
+        return (
+            self.name == other.name
+            and self.lower == other.lower
+            and self.center == other.center
+            and self.upper == other.upper
+        )
+
+    def __init__(self, name: str, lower: float, upper: float, center: float, **kwargs):
+        """
+        Create a tracer corresponding to a single radial bin.
+
+        :param name: The name of the tracer
+        :param lower: The lower bound of the radius bin
+        :param upper: The upper bound of the radius bin
+        :param center: The value to use if a single point-estimate is needed.
+
+        Note that :python:`center` need not be the midpoint between
+        :python:`lower` and :python:`upper`'.
+        """
+        super().__init__(name, **kwargs)
+        self.lower = lower
+        self.upper = upper
+        self.center = center
+
+    @classmethod
+    def to_table(cls, instance_list):
+        """Convert a list of BinRadiusTracers to a single astropy table
+
+        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 with a single astropy table
+        """
+
+        names = ["name", "quantity", "lower", "upper", "center"]
+
+        cols = [
+            [obj.name for obj in instance_list],
+            [obj.quantity for obj in instance_list],
+            [obj.lower for obj in instance_list],
+            [obj.upper for obj in instance_list],
+            [obj.center for obj in instance_list],
+        ]
+
+        table = Table(data=cols, names=names)
+        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"]
+            lower = row["lower"]
+            upper = row["upper"]
+            center = row["center"]
+            tracers[name] = cls(
+                name,
+                quantity=quantity,
+                lower=lower,
+                upper=upper,
+                center=center,
+            )
+        return tracers

sacc/tracers/maps.py

@@ -0,0 +1,206 @@
+from .base import BaseTracer, ONE_OBJECT_PER_TABLE, ONE_OBJECT_MULTIPLE_TABLES
+from ..utils import remove_dict_null_values
+from astropy.table import Table
+import numpy as np
+
+class MapTracer(BaseTracer, type_name='Map'):
+    """
+    A Tracer type for a sky map.
+
+    Takes at least two arguments, defining the map beam.
+
+    Parameters
+    ----------
+    name: str
+        The name for this specific tracer object.
+    ell: array
+         Array of multipole values at which the beam is defined.
+    beam: array
+         Beam multipoles at each value of ell.
+    beam_extra: array
+         Other beam-related arrays
+         (e.g. uncertainties, principal components,
+         alternative measurements, whatever).
+    map_unit: str
+         Map units (e.g. 'uK_CMB'). 'none' by default.
+    """
+
+    storage_type = ONE_OBJECT_PER_TABLE
+
+    def __init__(self, name, spin, ell, beam,
+                 beam_extra=None, map_unit='none', **kwargs):
+        super().__init__(name, **kwargs)
+        self.spin = spin
+        self.map_unit = map_unit
+        self.ell = np.array(ell)
+        self.beam = np.array(beam)
+        self.beam_extra = {} if beam_extra is None else beam_extra
+
+    def to_table(self):
+        # Beams
+        names = ['ell', 'beam']
+        cols = [self.ell, self.beam]
+        for beam_id, col in self.beam_extra.items():
+            names.append(str(beam_id))
+            cols.append(col)
+        table = Table(data=cols, names=names)
+        table.meta['SACCQTTY'] = self.quantity
+        table.meta['SACCNAME'] = self.name
+        extname = f'tracer:{self.type_name}:{self.name}:beam'
+        table.meta['EXTNAME'] = extname
+        table.meta['MAP_UNIT'] = self.map_unit
+        table.meta['SPIN'] = self.spin
+        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 a single astropy table into a MapTracer instance.
+
+        This is used when loading data from a file.
+
+        Parameters
+        ----------
+        table: astropy.table.Table
+
+        Returns
+        -------
+        tracer: MapTracer
+            An instance of MapTracer created from the table.
+        """
+        name = table.meta['SACCNAME']
+        quantity = table.meta.get('SACCQTTY', 'generic')
+        map_unit = table.meta['MAP_UNIT']
+        spin = table.meta['SPIN']
+        metadata = {key[5:]: value for key, value in table.meta.items() if key.startswith("META_")}
+
+        ell = table['ell']
+        beam = table['beam']
+        beam_extra = {col.name: col.data for col in table.columns.values() if col.name not in ['ell', 'beam']}
+
+        return cls(name, spin, ell, beam, beam_extra=beam_extra, map_unit=map_unit, quantity=quantity, metadata=metadata)
+
+
+class NuMapTracer(BaseTracer, type_name='NuMap'):
+    """
+    A Tracer type for a sky map at a given frequency.
+
+    Takes at least four arguments, defining the bandpass and beam.
+
+    Parameters
+    ----------
+    name: str
+        The name for this specific tracer, e.g. a frequency band
+        identifier.
+    spin: int
+        Spin for this observable. Either 0 (e.g. intensity)
+        or 2 (e.g. polarization).
+    nu: array
+         Array of frequencies.
+    bandpass: array
+         Bandpass transmission.
+    bandpass_extra: array
+         Other bandpass-related arrays
+         (e.g. uncertainties, principal components,
+         alternative measurements, whatever).
+    ell: array
+         Array of multipole values at which the beam is defined.
+    beam: array
+         Beam.
+    beam_extra: array
+         Other beam-related arrays
+         (e.g. uncertainties, principal components,
+         alternative measurements, whatever).
+    nu_unit: str
+         Frequency units ('GHz' by default).
+    map_unit: str
+         Map units (e.g. 'uK_CMB'). 'none' by default.
+    """
+
+    storage_type = ONE_OBJECT_MULTIPLE_TABLES
+
+    def __init__(self, name, spin, nu, bandpass,
+                 ell, beam, bandpass_extra=None,
+                 beam_extra=None, nu_unit='GHz',
+                 map_unit='none', **kwargs):
+        super().__init__(name, **kwargs)
+        self.spin = spin
+        self.nu = np.array(nu)
+        self.nu_unit = nu_unit
+        self.map_unit = map_unit
+        self.bandpass = np.array(bandpass)
+        self.bandpass_extra = {} if bandpass_extra is None else bandpass_extra
+        self.ell = np.array(ell)
+        self.beam = np.array(beam)
+        self.beam_extra = {} if beam_extra is None else beam_extra
+
+    def to_tables(self):
+        # Bandpass
+        names = ['nu', 'bandpass']
+        cols = [self.nu, self.bandpass]
+        for bandpass_id, col in self.bandpass_extra.items():
+            names.append(str(bandpass_id))
+            cols.append(col)
+        bandpass_table = Table(data=cols, names=names)
+        bandpass_table.meta['SACCQTTY'] = self.quantity
+        bandpass_table.meta['NU_UNIT'] = self.nu_unit
+        bandpass_table.meta['SACCNAME'] = self.name
+        bandpass_table.meta['SPIN'] = self.spin
+        for key, value in self.metadata.items():
+            bandpass_table.meta['META_'+key] = value
+        remove_dict_null_values(bandpass_table.meta)
+
+        # Beam
+        names = ['ell', 'beam']
+        cols = [self.ell, self.beam]
+        for beam_id, col in self.beam_extra.items():
+            names.append(str(beam_id))
+            cols.append(col)
+        beam_table = Table(data=cols, names=names)
+        beam_table.meta['SACCQTTY'] = self.quantity
+        beam_table.meta['MAP_UNIT'] = self.map_unit
+        beam_table.meta['SPIN'] = self.spin
+        for key, value in self.metadata.items():
+            beam_table.meta['META_'+key] = value
+        remove_dict_null_values(beam_table.meta)
+
+        return {'bandpass': bandpass_table, 'beam': beam_table}
+
+    @classmethod
+    def from_tables(cls, table_dict):
+        """Convert a dictionary of astropy tables into a NuMapTracer instance."""
+        bandpass_table = table_dict['bandpass']
+        beam_table = table_dict['beam']
+
+        # Get the various bits of metadata out of the bandpass table
+        name = bandpass_table.meta['SACCNAME']
+        spin = bandpass_table.meta['SPIN']
+        quantity = bandpass_table.meta.get('SACCQTTY', 'generic')
+        nu_unit = bandpass_table.meta['NU_UNIT']
+
+        # Additional miscellaneous metadata
+        metadata = {key[5:]: value for key, value in bandpass_table.meta.items() if key.startswith("META_")}
+
+        # And the actual bandpass data columns themselves
+        nu = bandpass_table['nu']
+        bandpass = bandpass_table['bandpass']
+        bandpass_extra = {col.name: col.data for col in bandpass_table.columns.values() if col.name not in ['nu', 'bandpass']}
+
+        # Now the same for the beam table
+        ell = beam_table['ell']
+        beam = beam_table['beam']
+        beam_extra = {col.name: col.data for col in beam_table.columns.values() if col.name not in ['ell', 'beam']}
+        map_unit = beam_table.meta['MAP_UNIT']
+
+        return cls(name, spin, nu, bandpass,
+                   ell, beam,
+                   bandpass_extra=bandpass_extra,
+                   beam_extra=beam_extra,
+                   nu_unit=nu_unit,
+                   map_unit=map_unit,
+                   quantity=quantity,
+                   metadata=metadata)

sacc/tracers/misc.py

@@ -0,0 +1,87 @@
+from .base import BaseTracer, MULTIPLE_OBJECTS_PER_TABLE
+from astropy.table import Table
+from ..utils import hide_null_values, remove_dict_null_values
+
+class MiscTracer(BaseTracer, type_name='Misc'):
+    """A Tracer type for miscellaneous other data points.
+
+    MiscTracers do not have any attributes except for their
+    name, so can be used for tagging external data, for example.
+
+    Parameters
+    ----------
+    name: str
+        The name of the tracer
+    """
+    storage_type = MULTIPLE_OBJECTS_PER_TABLE
+
+    def __init__(self, name, **kwargs):
+        super().__init__(name, **kwargs)
+
+    @classmethod
+    def to_table(cls, instance_list):
+        """Convert a list of MiscTracer instances to a astropy tables.
+
+        This is used when saving data to file.
+
+        All the instances are converted to a single table, which is
+        returned in a list with one element so that it can be used
+        in combination with the parent.
+
+        You can use the parent class to_tables class method to convert
+        a mixed list of different tracer types.
+
+        You shouldn't generally need to call this method directly.
+
+        Parameters
+        ----------
+        instance_list: list
+            list of MiscTracer objects
+
+        Returns
+        -------
+        tables: list
+            List containing one astropy table
+        """
+        metadata_cols = set()
+        for obj in instance_list:
+            metadata_cols.update(obj.metadata.keys())
+        metadata_cols = list(metadata_cols)
+
+        cols = [[obj.name for obj in instance_list],
+                [obj.quantity for obj in instance_list]]
+        for name in metadata_cols:
+            cols.append([obj.metadata.get(name) for obj in instance_list])
+
+        table = Table(data=cols,
+                      names=['name', 'quantity'] + metadata_cols)
+        hide_null_values(table)
+        return table
+
+    @classmethod
+    def from_table(cls, table):
+        """Convert a list of astropy table into a dictionary of MiscTracer instances.
+
+        In general table_list should have a single element in, since all the
+        MiscTracers are stored in a single table during to_tables
+
+        Parameters
+        ----------
+        table_list: List[astropy.table.Table]
+
+        Returns
+        -------
+        tracers: Dict[str: MiscTracer]
+        """
+        tracers = {}
+
+        metadata_cols = [col for col in table.colnames
+                            if col not in ['name', 'quantity']]
+
+        for row in table:
+            name = row['name']
+            quantity = row['quantity']
+            metadata = {key: row[key] for key in metadata_cols}
+            remove_dict_null_values(metadata)
+            tracers[name] = cls(name, quantity=quantity, metadata=metadata)
+        return tracers