sotodlib 0.6.9.1__tar.gz

sotodlib-0.6.9.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018-2025 Simons Observatory, and individual contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sotodlib-0.6.9.1/MANIFEST.in

@@ -0,0 +1,4 @@
+include versioneer.py
+include sotodlib/_version.py
+include sotodlib/toast/ops/data/planet_data.h5
+include sotodlib/toast/ops/data/hwpss_per_chi.pck

sotodlib-0.6.9.1/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: sotodlib
+Version: 0.6.9.1
+Summary: Simons Observatory TOD Simulation and Processing
+Maintainer: Simons Observatory Collaboration
+Maintainer-email: so_software@simonsobservatory.org
+License-Expression: MIT
+Project-URL: Source, https://github.com/simonsobs/sotodlib
+Project-URL: Issue Tracker, https://github.com/simonsobs/sotodlib/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: <3.13,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: quaternionarray
+Requires-Dist: PyYAML
+Requires-Dist: toml
+Requires-Dist: skyfield
+Requires-Dist: so3g
+Requires-Dist: pixell>=0.23.0
+Requires-Dist: pytest
+Requires-Dist: scikit-image
+Requires-Dist: pyfftw
+Requires-Dist: numdifftools
+Requires-Dist: psycopg2-binary
+Requires-Dist: lmfit
+Requires-Dist: flacarray>=0.3
+Provides-Extra: site-pipeline
+Requires-Dist: influxdb; extra == "site-pipeline"
+Requires-Dist: venn; extra == "site-pipeline"
+Requires-Dist: let-me-scroll-it; extra == "site-pipeline"
+Requires-Dist: plotly; extra == "site-pipeline"
+Requires-Dist: pandas; extra == "site-pipeline"
+Requires-Dist: alphashape; extra == "site-pipeline"
+Provides-Extra: tests
+Requires-Dist: socs; extra == "tests"
+Dynamic: license-file
+
+
+# SO TOD Library
+
+![!Build and Test](https://github.com/simonsobs/sotodlib/workflows/Build%20and%20Test/badge.svg)
+[![Documentation Status](https://readthedocs.org/projects/sotodlib/badge/?version=latest)](https://sotodlib.readthedocs.io/en/latest/?badge=latest)
+[![PyPI - Version](https://img.shields.io/pypi/v/sotodlib.svg)](https://pypi.org/project/sotodlib)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/sotodlib.svg)](https://pypi.org/project/sotodlib)
+
+Tools for working with real and simulated time ordered data.
+
+Full documentation here:
+
+https://sotodlib.readthedocs.io/en/latest/

sotodlib-0.6.9.1/README.md

@@ -0,0 +1,13 @@
+
+# SO TOD Library
+
+![!Build and Test](https://github.com/simonsobs/sotodlib/workflows/Build%20and%20Test/badge.svg)
+[![Documentation Status](https://readthedocs.org/projects/sotodlib/badge/?version=latest)](https://sotodlib.readthedocs.io/en/latest/?badge=latest)
+[![PyPI - Version](https://img.shields.io/pypi/v/sotodlib.svg)](https://pypi.org/project/sotodlib)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/sotodlib.svg)](https://pypi.org/project/sotodlib)
+
+Tools for working with real and simulated time ordered data.
+
+Full documentation here:
+
+https://sotodlib.readthedocs.io/en/latest/

sotodlib-0.6.9.1/pyproject.toml

@@ -0,0 +1,88 @@
+[build-system]
+requires = ["setuptools", "versioneer[toml]==0.29", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sotodlib"
+readme = "README.md"
+description = "Simons Observatory TOD Simulation and Processing"
+license = "MIT"
+maintainers = [
+  {name = "Simons Observatory Collaboration"},
+  {email = "so_software@simonsobservatory.org"},
+]
+requires-python = ">=3.9, <3.13"
+dependencies = [
+  "numpy",
+  "scipy",
+  "matplotlib",
+  "quaternionarray",
+  "PyYAML",
+  "toml",
+  "skyfield",
+  "so3g",
+  "pixell>=0.23.0",
+  "pytest",
+  "scikit-image",
+  "pyfftw",
+  "numdifftools",
+  "psycopg2-binary",
+  "lmfit",
+  "flacarray>=0.3",
+]
+dynamic=["version"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Intended Audience :: Science/Research",
+  "Topic :: Scientific/Engineering :: Astronomy",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+]
+
+[project.urls]
+"Source" = "https://github.com/simonsobs/sotodlib"
+"Issue Tracker" = "https://github.com/simonsobs/sotodlib/issues"
+
+[project.optional-dependencies]
+site_pipeline = [
+  "influxdb",
+  "venn",
+  "let-me-scroll-it",
+  "plotly",
+  "pandas",
+  "alphashape",
+]
+tests = [
+  "socs",
+]
+
+[project.scripts]
+so_hardware_sim = "sotodlib.scripts.hardware_sim:main"
+so_hardware_plot = "sotodlib.scripts.hardware_plot:main"
+so_hardware_trim = "sotodlib.scripts.hardware_trim:main"
+so_hardware_info = "sotodlib.scripts.hardware_info:main"
+so_batch_control = "sotodlib.scripts.so_batch_control:main"
+so-metadata = "sotodlib.core.metadata.cli:main"
+so-site-pipeline = "sotodlib.site_pipeline.cli:main"
+so-data-package = "sotodlib.io.imprinter_cli:main"
+toast_so_sim = "sotodlib.toast.scripts.so_sim:cli"
+toast_so_map = "sotodlib.toast.scripts.so_map:cli"
+toast_so_transfer = "sotodlib.toast.scripts.so_transfer:cli"
+toast_so_convert = "sotodlib.toast.scripts.so_convert:cli"
+get_wafer_offset = "sotodlib.toast.scripts.get_wafer_offset:main"
+
+[tool.versioneer]
+VCS = "git"
+style = "pep440"
+versionfile_source = "sotodlib/_version.py"
+versionfile_build = "sotodlib/_version.py"
+tag_prefix = "v"
+parentdir_prefix = "sotodlib-"
+
+[tool.pytest.ini_options]
+addopts = [
+    "--import-mode=importlib",
+]

sotodlib-0.6.9.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

sotodlib-0.6.9.1/setup.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+import unittest
+
+from setuptools import find_packages, setup, Command
+import versioneer
+
+# The setup options
+setup_opts = dict()
+
+setup_opts["version"] = versioneer.get_version()
+setup_opts["packages"] = find_packages(where=".", exclude="tests")
+
+setup_opts["package_data"] = {
+    "sotodlib": [
+        "toast/ops/data/*"
+    ]
+}
+setup_opts["include_package_data"] = True
+
+
+# Command Class dictionary.
+# Begin with the versioneer command class dictionary.
+cmdcls = versioneer.get_cmdclass()
+
+# Class to run unit tests
+
+class SOTestCommand(Command):
+
+    def __init__(self, *args, **kwargs):
+        super(SOTestCommand, self).__init__(*args, **kwargs)
+
+    def initialize_options(self):
+        Command.initialize_options(self)
+
+    def finalize_options(self):
+        Command.finalize_options(self)
+        self.test_suite = True
+
+    def mpi_world(self):
+        # We could avoid putting this here by defining a custom TextTestRunner
+        # that checked the per-process value "under-the-hood" and returned a
+        # False value from wasSuccessful() if any process failed.
+        comm = None
+        if "MPI_DISABLE" not in os.environ:
+            try:
+                from mpi4py import MPI
+
+                comm = MPI.COMM_WORLD
+            except Exception:
+                pass
+        return comm
+
+    def run(self):
+        loader = unittest.TestLoader()
+        runner = unittest.TextTestRunner(verbosity=2)
+        suite = loader.discover("tests", pattern="test_*.py",
+                                top_level_dir=".")
+        ret = 0
+        local_ret = runner.run(suite)
+        if not local_ret.wasSuccessful():
+            ret = 1
+        comm = self.mpi_world()
+        if comm is not None:
+            ret = comm.allreduce(ret)
+        sys.exit(ret)
+
+# Add our custom test runner
+cmdcls["test"] = SOTestCommand
+
+# Add command class to setup options
+setup_opts["cmdclass"] = cmdcls
+
+# Do the setup.
+setup(**setup_opts)

sotodlib-0.6.9.1/sotodlib/__init__.py

@@ -0,0 +1,30 @@
+# Copyright (c) 2018-2021 Simons Observatory.
+# Full license can be found in the top level "LICENSE" file.
+
+"""Simons Observatory TOD Simulation and Processing.
+
+This package contains tools for simulating and analyzing data from the
+Simons Observatory.  It uses multiple external dependencies (some optional).
+See documentation of the various sub-modules for more details.
+
+Contents:
+
+    * core:  Container classes for data, metadata, etc.
+    * io:  Code for reading / writing data.
+    * utils:  General utility functions and data helper functions.
+    * scripts:  Commandline entry points.
+    * Top level packages for actual data processing.
+
+"""
+
+from . import _version
+__version__ = _version.get_versions()['version']
+
+
+import logging
+logger = logging.getLogger(__name__)
+_log_fmt = '%(levelname)s: %(name)s: %(message)s'
+_ch = logging.StreamHandler()
+_ch.setLevel(logging.INFO)
+_ch.setFormatter(logging.Formatter(_log_fmt))
+logger.addHandler(_ch)

sotodlib-0.6.9.1/sotodlib/_version.py

@@ -0,0 +1,21 @@
+
+# This file was generated by 'versioneer.py' (0.29) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+import json
+
+version_json = '''
+{
+ "date": "2025-08-20T17:31:40-0400",
+ "dirty": false,
+ "error": null,
+ "full-revisionid": "1de526e011503cc9e78ec85ac7b0e64209b7a30b",
+ "version": "0.6.9.1"
+}
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)

sotodlib-0.6.9.1/sotodlib/coords/__init__.py

@@ -0,0 +1,11 @@
+from .pmat import P
+from .helpers import (
+    get_radec, get_horiz, get_footprint, get_wcs_kernel, get_supergeom,
+    Timer, DEG, ScalarLastQuat
+)
+from . import planets
+from . import local
+from .plotting import *
+from . import demod
+from . import pointing_model
+from . import healpix_utils

sotodlib-0.6.9.1/sotodlib/coords/demod.py

@@ -0,0 +1,238 @@
+import numpy as np
+import so3g
+from pixell import enmap
+
+from .. import core, tod_ops, coords
+
+
+def make_map(tod,
+             P=None, wcs_kernel=None,
+             res=0.1 * coords.DEG,
+             dsT=None, demodQ=None, demodU=None,
+             cuts=None,
+             det_weights=None, det_weights_demod=None,
+             center_on=None, flip_gamma=True):
+    """Generates maps of temperature and polarization from demodulated HWP
+    data.  It is assumed that each detector contributes a T signal
+    (which has been low-pass filtered to avoid the modulated signal)
+    stored in dsT, as well as separate Q and U timestreams,
+    corresponding to the cosine-phase (demodQ = Q cos 4 chi) and
+    sine-phase (demodU = U sin 4 chi) response of the HWP.
+
+    The demodQ and demodU signals are assumed to have been computed
+    without regard for the polarization angle of the detector, nor the
+    on-sky parallactic angle.  The impact of these is handled by the
+    projection routines in this function.
+
+    Parameters
+    ----------
+    tod : sotodlib.core.AxisManager
+        An AxisManager object
+    P : sotodlib.coords.pmat
+        Projection Matrix to be used for mapmaking. If None, it is
+        generated from `wcs_kernel` or `center_on`.
+    wcs_kernel : enlib.wcs.WCS or None, optional
+        The WCS object used to generate the output map.
+        If None, a new WCS object with a Cartesian projection and a resolution of `res` will be created.
+    center_on: None or str
+        Name of point source. If specified, Source-centered map with a tangent projection will be made.
+        If None, wcs_kernel will be used to generate a projection matrix.
+    size: float or None
+        If specified, trim source-centored map to a local square with `size`, in radian.
+        If None, not trimming will be applied. Only valid when `centor_on` is specified.
+    res : float, optional
+        The resolution of the output map, in radian.        
+    dsT : array-like or None, optional
+        The input dsT timestream data. If None, the 'dsT' field of `tod` will be used.
+    demodQ : array-like or None, optional
+        The input demodulated Q timestream data. If None, the 'demodQ' field of `tod` will be used.
+    demodU : array-like or None, optional
+        The input demodulated U timestream data. If None, the 'demodU' field of `tod` will be used.
+    cuts : RangesMatrix or None, optional
+        A RangesMatrix that identifies samples that should be excluded from projection operations.
+        If None, no cuts will be applied.
+    det_weights : array-like or None, optional
+        The detector weights to use in the map-making for the dsT timestream.
+    det_weights_demod : array-like or None, optional
+        The detector weights to use in the map-making for the demodulated Q and U timestreams.
+        If both of `det_weights` and `det_weights_demod` are None, uniform detector weights will be used.
+        If only one of two are provided, the other weight is provided by `det_weights` = 2 * `det_weights_demod`.
+    flip_gamma : bool or None
+        Defaults to True.  When constructing the pointing matrix,
+        reflect the nominal focal plane polarization angles about zero
+        (gamma -> -gamma).  If you pass in your own P, make sure it
+        was constructed with hwp=True.
+
+    Returns
+    -------
+    A dictionary which contains:
+    'map' : enmap.ndmap
+        map of temperature and polarization
+    'weighted_map' : enmap.ndmap
+        The inverse variance weighted map of temperature and polarization
+    'weight' : enmap.ndmap
+        The map of inverse variance weights used in the map-making process.
+
+    """
+    if dsT is None:
+        dsT = tod['dsT']
+    if demodQ is None:
+        demodQ = tod['demodQ']
+    if demodU is None:
+        demodU = tod['demodU']
+
+    if flip_gamma is None:
+        flip_gamma = True
+
+    if P is None:
+        if center_on is None:
+            if wcs_kernel is None:
+                wcs_kernel = coords.get_wcs_kernel('car', 0, 0, res)
+            P = coords.P.for_tod(
+                tod=tod, wcs_kernel=wcs_kernel, cuts=cuts, comps='QU', hwp=flip_gamma)
+        else:
+            P, X = coords.planets.get_scan_P(tod, planet=center_on, res=res, hwp=flip_gamma)
+            
+
+    if det_weights is None:
+        if det_weights_demod is None:
+            det_weights_demod = np.ones(tod.dets.count, dtype='float32')
+        det_weights = det_weights_demod * 2.
+    else:
+        if det_weights_demod is None:
+            det_weights_demod = det_weights / 2.
+
+    # T map and weight
+    mT_weighted = P.to_map(
+        tod=tod, signal=dsT, comps='T', det_weights=det_weights)
+    wT = P.to_weights(tod, signal=dsT, comps='T', det_weights=det_weights)
+
+    # Q/U maps and weights
+    mQ_weighted = P.to_map(tod=tod, signal=demodQ, comps='QU',
+                             det_weights=det_weights_demod)
+    mU_weighted = P.to_map(tod=tod, signal=demodU, comps='QU',
+                             det_weights=det_weights_demod)
+
+    mQU_weighted = P.zeros()
+    mQU_weighted[0][:] = mQ_weighted[0] - mU_weighted[1]
+    mQU_weighted[1][:] = mQ_weighted[1] + mU_weighted[0]
+    del mQ_weighted, mU_weighted
+
+    wQU = P.to_weights(tod, signal=demodQ, comps='T',
+                         det_weights=det_weights_demod)
+
+    # combine mT_weighted and mQU_weighted into mTQU_weighted
+    mTQU_weighted = P.zeros(super_shape=3)
+    mTQU_weighted[0] = mT_weighted
+    mTQU_weighted[1] = mQU_weighted[0]
+    mTQU_weighted[2] = mQU_weighted[1]
+
+    # combine wT and wQU into wTQU
+    wTQU = enmap.zeros((3, 3) + P.geom.shape, wcs=P.geom.wcs)
+    wTQU[0][0] = wT
+    wTQU[1][1] = wQU
+    wTQU[2][2] = wQU
+
+    # remove weights
+    mTQU = P.remove_weights(signal_map=mTQU_weighted,
+                              weights_map=wTQU, comps='TQU')
+    
+    output = {'map': mTQU,
+             'weighted_map': mTQU_weighted,
+             'weight': wTQU}
+    return output
+
+def from_map(tod, signal_map, cuts=None, flip_gamma=True, wrap=False, modulated=False):
+    """
+    Generate simulated TOD with HWP from a given signal map.
+
+    Args:
+        tod : an axisManager object
+        signal_map: pixell.enmap.ndmap containing (Tmap, Qmap, Umap) representing the signal.
+        cuts (RangesMatrix, optional): Cuts to apply to the data. Default is None.
+        flip_gamma (bool, optional): Whether to flip detector coordinate. If you use the HWP, keep it `True`. Default is True.
+        wrap (bool, optional): Whether to wrap the simulated data. Default is False.
+        modulated (bool, optional): If True, return modulated signal. If False, return the demodulated signal 
+        (`dsT`, `demodQ`, and `demodU`). Default is False. 
+
+    Returns:
+        `modulate==False`: A tuple containing the TOD (np.array) of dsT, demodQ and demodU.
+        `modulate==True` : The modulated TOD (np.array)
+        
+    """
+    Tmap, Qmap, Umap = signal_map
+    
+    P = coords.P.for_tod(tod=tod, geom=signal_map.geometry, cuts=cuts, 
+                         comps='QU', hwp=flip_gamma)
+    dsT_sim = P.from_map(Tmap, comps='T')
+    demodQ_sim = P.from_map(enmap.enmap([Qmap, Umap]), comps='QU')
+    demodU_sim = P.from_map(enmap.enmap([Umap, -Qmap]), comps='QU')
+    
+    if modulated is False:
+        if wrap:
+            tod.wrap('dsT', dsT_sim, [(0, 'dets'), (1, 'samps')])
+            tod.wrap('demodQ', demodQ_sim, [(0, 'dets'), (1, 'samps')])
+            tod.wrap('demodU', demodU_sim, [(0, 'dets'), (1, 'samps')])
+        return dsT_sim, demodQ_sim, demodU_sim
+    else:
+        assert 'hwp_angle' in tod._fields
+        signal_sim = dsT_sim + demodQ_sim*np.cos(4*tod.hwp_angle) + demodU_sim*np.sin(4*tod.hwp_angle)
+        if wrap:
+            tod.wrap('signal', signal_sim, [(0, 'dets'), (1, 'samps')])
+        return signal_sim
+
+
+def rotate_focal_plane(tod, hwp=True):
+    """ Interpret the boresight rotation effect as a focal plane rotation and update them accordingly.
+    This applies constant rotation to focal plane. If hwp=True, rotations of gamma are reflected.
+    This updates tod.boresight.roll and tod.focal_plane, in place.
+    """
+    sign = -1. if hwp else 1.
+    avg_roll = np.average(tod.boresight.roll)
+    tod.boresight.roll -= avg_roll
+    fp = so3g.proj.quat.rotation_xieta(tod.focal_plane.xi, tod.focal_plane.eta, sign * tod.focal_plane.gamma)
+    fp = so3g.proj.quat.euler(2, avg_roll) * fp
+    xi, eta, gamma = so3g.proj.quat.decompose_xieta(fp)
+    # boresight is float64 but signal and focal_plane are float32
+    tod.focal_plane.xi = np.float32(xi)
+    tod.focal_plane.eta = np.float32(eta)
+    tod.focal_plane.gamma = sign * np.float32(gamma)
+
+
+def rotate_demodQU(tod, sign=1, offset=0, radial=False, update_focal_plane=True):
+    """
+    Apply detectors' polarization angle calibration to the HWP demodulated Q and U timestreams to
+    place all detectors' Q and U timestreams in a common telescope frame. This updates tod.demodQ
+    and tod.demodU, in place.
+    To get Qr Ur timestreams, run `rotate_demodQU(tod)` and then `rotate_demodQU(tod, radial=True)`.
+    To restore the Q U timestreams, run `rotate_demodQU(tod, sign=-1, radial=True)`.
+    
+
+    Args:
+        tod : an axisManager object
+        update_focal_plane (bool, optional): Whether to update focal_plane.gamma angles consistent with new coordinate reference. 
+            Make this True for polarization mapmaking using make_map.
+        offset : float, optional
+            The rotation angle in degrees to apply (default is 0).
+        sign : int, optional
+            A sign factor to control the direction of the rotation (default is +1).
+        radial : bool, optional
+            If True and the Q U timestreams in tod are in a common telescope flame, this function turns Q U
+            into Qr Ur. 
+            
+
+    """
+    if radial:
+        theta_fp = np.arctan2(tod.focal_plane.xi, tod.focal_plane.eta)
+        demodC = ((tod.demodQ + 1j*tod.demodU).T * np.exp( sign*(-2j*theta_fp) )).T
+        if update_focal_plane:
+            tod.focal_plane.gamma -= sign * theta_fp
+
+    else:
+        demodC = ((tod.demodQ + 1j*tod.demodU).T * np.exp( sign*(-2j*tod.focal_plane.gamma + 1j*np.deg2rad(offset)) )).T
+        if update_focal_plane:
+            tod.focal_plane.gamma *= 0
+    tod.demodQ = demodC.real
+    tod.demodU = demodC.imag
+    del demodC
+