From d49fc33e98e899641d77fdb96acda3328b88de3e Mon Sep 17 00:00:00 2001 From: Silvia Micheli <117379461+silviamich@users.noreply.github.com> Date: Wed, 30 Oct 2024 15:44:50 +0100 Subject: [PATCH] Nonlinearity module implementation (#331) * differential emission from hwp * add nonlinearity * example notebook * fix typo * documentation * add docstrings * Add non-linearity documentation * Add non-linearity documentation * Add non-linearity documentation * Add reference for nonlinearity * Add test for nonlinearity * small reworking of the modules * incorrect use of Typing fixed * documentation and tests fixed * CHANGELOG updated --------- Co-authored-by: Luca Pagano Co-authored-by: Maurizio Tomasi --- CHANGELOG.md | 3 + docs/source/index.rst | 1 + docs/source/non_linearity.rst | 173 +++++ litebird_sim/__init__.py | 4 + litebird_sim/hwp_diff_emiss.py | 118 ++++ litebird_sim/noise.py | 2 +- litebird_sim/non_linearity.py | 74 ++ litebird_sim/simulations.py | 86 ++- ...ple_of_diffemission_and_nonlinearity.ipynb | 661 ++++++++++++++++++ templates/report_2f.md | 6 + templates/report_quad_nonlin.md | 5 + test/test_hwp_diff_emiss.py | 98 +++ test/test_nonlinearity.py | 70 ++ 13 files changed, 1296 insertions(+), 5 deletions(-) create mode 100644 docs/source/non_linearity.rst create mode 100644 litebird_sim/hwp_diff_emiss.py create mode 100644 litebird_sim/non_linearity.py create mode 100644 notebooks/example_of_diffemission_and_nonlinearity.ipynb create mode 100644 templates/report_2f.md create mode 100644 templates/report_quad_nonlin.md create mode 100644 test/test_hwp_diff_emiss.py create mode 100644 test/test_nonlinearity.py diff --git a/CHANGELOG.md b/CHANGELOG.md index 34932094..6ab8eb5a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,9 @@ # HEAD +- Module for including nonlinearity in the simulations [#331](https://github.com/litebird/litebird_sim/pull/331) + - Improve the documentation of the binner and the destriper [#333](https://github.com/litebird/litebird_sim/pull/333) + - Make the code compatible with Python 3.12 [#332](https://github.com/litebird/litebird_sim/pull/332) # Version 0.13.0 diff --git a/docs/source/index.rst b/docs/source/index.rst index 27051a61..bca4dc4c 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -27,6 +27,7 @@ Welcome to litebird_sim's documentation! mpi reports gaindrifts + non_linearity external_modules profiling integrating diff --git a/docs/source/non_linearity.rst b/docs/source/non_linearity.rst new file mode 100644 index 00000000..41afc403 --- /dev/null +++ b/docs/source/non_linearity.rst @@ -0,0 +1,173 @@ +Non-linearity injection +======================= + +Non-linearity is the effect of a non-ideal TES detectors' response. This means that the responsivity :math:`S` is not constant as the optical power varies. +The LiteBIRD Simulation Framework provides a non-linearity simulation module to simulate the effect of non-linearity on TODs. + +The framework provides the simplest case, which is a quadratic non-linearity. +This case is described in `Micheli+2024 `_, where the effect of non-linearity is propagated to the estimation of the tensor-to-scalar ratio. + +Considering a first order correction of the usual linear gain, a TOD :math:`d(t)` is modified according to: + +.. math:: + d(t) = [1+g_1 d(t)] d(t) + +where :math:`g_1` is the detector non-linearity factor in units of :math:`K^{-1}`. + +To simulate a quadratic non-linearity, one can use the method of :class:`.Simulation` class :meth:`.Simulation.apply_quadratic_nonlin()`, +or any of the low level functions: :func:`.apply_quadratic_nonlin_to_observations()`, :func:`.apply_quadratic_nonlin_for_one_detector()`. +The following example shows the typical usage of the method and low level functions: + + +.. code-block:: python + + import numpy as np + import litebird_sim as lbs + from astropy.time import Time + + start_time = Time("2025-02-02T00:00:00") + mission_time_days = 1 + sampling_hz = 19 + + dets = [ + lbs.DetectorInfo( + name="det_A", sampling_rate_hz=sampling_hz + ), + lbs.DetectorInfo( + name="det_B", sampling_rate_hz=sampling_hz + ), + ] + + sim = lbs.Simulation( + base_path="nonlin_example", + start_time=start_time, + duration_s=mission_time_days * 24 * 3600.0, + random_seed=12345, + ) + + sim.create_observations( + detectors=dets, + split_list_over_processes=False, + ) + + # Creating fiducial TODs + sim.observations[0].nl_2_self = np.ones_like(sim.observations[0].tod) + sim.observations[0].nl_2_obs = np.ones_like(sim.observations[0].tod) + sim.observations[0].nl_2_det = np.ones_like(sim.observations[0].tod) + +If the non-linearity parameter is not read from the IMo, one has to specify :math:`g_1` using the ``g_one_over_k`` argument as in the following example: + +.. code-block:: python + + # Define non-linear parameters for the detectors. We choose the same value for both detectors in this example, but it is not necessary. + sim.observations[0].g_one_over_k = np.ones(len(dets)) * 1e-3 + + # Applying non-linearity using the `Simulation` class method + sim.apply_quadratic_nonlin(component = "nl_2_self",) + + # Applying non-linearity on the given TOD component of an `Observation` object + lbs.non_linearity.apply_quadratic_nonlin_to_observations( + observations=sim.observations, + component="nl_2_obs", + ) + + # Applying non-linearity on the TOD arrays of the individual detectors. + for idx, tod in enumerate(sim.observations[0].nl_2_det): + lbs.non_linearity.apply_quadratic_nonlin_for_one_detector( + tod_det=tod, + g_one_over_k=sim.observations[0].g_one_over_k[idx], + ) + +In particular, the effect of detector non-linearity needs to be included to assess its impact when coupled to other systematic effects. As described in `Micheli+2024 `_, a typical case is the coupling with HWP synchronous signal (HWPSS) appearing at twice the rotation frequency of the HWP. +This kind of signal can be produced by non-idealities of the HWP, such as its differential transmission and emission. + +In that case, the usual TOD :math:`d(t)` will contain an additional term, and can be written as: + +.. math:: + d(t) = d(t) = I + \mathrm{Re}[\epsilon_{\mathrm{pol}}e^{4i\chi}(Q+iU)]+A_2 \cos(2 \omega_{HWP} t) + N + +where :math:`A_2` is the amplitude of the HWPSS and :math:`\omega_{HWP}` is the rotation speed of the HWP. In presence of detector non-linearity, the 2f signal is up-modulated to 4f, affecting the science band. + +The framework provides an independent module to introduce this signal in the simulation, adding it to the TODs. To simulate the 2f signal from a rotating, non-ideal HWP, one can use the method of :class:`.Simulation` class :meth:`.Simulation.add_2f()`, +or any of the low level functions: :func:`.add_2f_to_observations()`, :func:`.add_2f_for_one_detector()`. + +If the 2f amplitude is not read from the IMo, one has to specify :math:`A_2` using the ``amplitude_2f_k`` argument. The argument ``optical_power_k`` allows to include the integrated nominal optical power expected for each channel as in the following example: + +.. code-block:: python + + import numpy as np + import litebird_sim as lbs + from astropy.time import Time + from litebird_sim.pointings import get_hwp_angle + + + telescope = "LFT" + channel = "L4-140" + detlist = ["000_001_017_QB_140_T", "000_001_017_QB_140_B"] + imo_version = "vPTEP" + start_time = Time("2025-02-02T00:00:00") + mission_time_days = 1 + + imo = lbs.Imo(flatfile_location=lbs.PTEP_IMO_LOCATION) + + + sim = lbs.Simulation( + base_path="nonlin_example", + start_time=start_time, + imo=imo, + duration_s=mission_time_days * 24 * 3600.0, + random_seed=12345, + ) + + # Load the definition of the instrument + sim.set_instrument( + lbs.InstrumentInfo.from_imo( + imo, + f"/releases/{imo_version}/satellite/{telescope}/instrument_info", + ) + ) + + dets = [] + for n_det in detlist: + det = lbs.DetectorInfo.from_imo( + url=f"/releases/{imo_version}/satellite/{telescope}/{channel}/{n_det}/detector_info", + imo=imo,) + det.sampling_rate_hz = 1 + dets.append(det) + + sim.create_observations( + detectors=dets, + split_list_over_processes=False, + ) + + sim.set_scanning_strategy(imo_url=f"/releases/{imo_version}/satellite/scanning_parameters/") + + sim.set_hwp( + lbs.IdealHWP(sim.instrument.hwp_rpm * 2 * np.pi / 60,), + ) + + sim.prepare_pointings() + sim.precompute_pointings() + + # Creating fiducial TODs + sim.observations[0].tod_2f = np.zeros_like(sim.observations[0].tod) + + # Define differential emission parameters for the detectors. + sim.observations[0].amplitude_2f_k = np.array([0.1, 0.1]) + sim.observations[0].optical_power_k = np.array([1.0, 1.0]) + + # Adding 2f signal from HWP differential emission using the `Simulation` class method + sim.add_2f(component="tod_2f") + + +Refer to the :ref:`gd-api-reference` for the full list of non-linearity simulation parameters. + +.. _gd-api-reference: + +API reference +------------- + +.. automodule:: litebird_sim.non_linearity + :members: + :undoc-members: + :show-inheritance: diff --git a/litebird_sim/__init__.py b/litebird_sim/__init__.py index b4a8aa6b..eb830f02 100644 --- a/litebird_sim/__init__.py +++ b/litebird_sim/__init__.py @@ -55,6 +55,7 @@ IdealHWP, read_hwp_from_hdf5, ) +from .hwp_diff_emiss import add_2f, add_2f_to_observations from .hwp_sys.hwp_sys import ( HwpSys, ) @@ -325,4 +326,7 @@ def destripe_with_toast2(*args, **kwargs): "FocalplaneCoord", "SpacecraftCoord", "PointingSys", + # hwp_diff_emiss.py + "add_2f", + "add_2f_to_observations", ] diff --git a/litebird_sim/hwp_diff_emiss.py b/litebird_sim/hwp_diff_emiss.py new file mode 100644 index 00000000..2da33407 --- /dev/null +++ b/litebird_sim/hwp_diff_emiss.py @@ -0,0 +1,118 @@ +# -*- encoding: utf-8 -*- + +import numpy as np +from numba import njit, prange + +from typing import Union, List, Optional +from numbers import Number + +from .observations import Observation +from .hwp import HWP +from .pointings import get_hwp_angle + + +"""def convert_pW_to_K(power_pW, NET, NEP): + temperature_K = power_pW * NET*1e-6/NEP*1e-18/sqrt(2) + return(temperature_K)""" # we could use this if we prefer having IMo quantities in pW + + +# We calculate the additive signal coming from hwp harmonics. +# here we calculate 2f directly. +@njit +def compute_2f_for_one_sample(angle_rad, amplitude_k, monopole_k): + return amplitude_k * np.cos(angle_rad) + monopole_k + + +@njit(parallel=True) +def add_2f_for_one_detector(tod_det, angle_det_rad, amplitude_k, monopole_k): + for i in prange(len(tod_det)): + tod_det[i] += compute_2f_for_one_sample( + angle_rad=angle_det_rad[i], amplitude_k=amplitude_k, monopole_k=monopole_k + ) + + +def add_2f( + tod, + hwp_angle, + amplitude_2f_k: float, + optical_power_k: float, +): + """Add the HWP differential emission to some time-ordered data + + This functions modifies the values in `tod` by adding the contribution of the HWP + synchronous signal coming from differential emission. The `amplitude_2f_k` argument must be + a N_dets array containing the amplitude of the HWPSS. The `optical_power_k` argument must have + the same size and contain the value of the nominal optical power for the considered frequency channel.""" + + assert len(tod.shape) == 2 + num_of_dets = tod.shape[0] + + if isinstance(amplitude_2f_k, Number): + amplitude_2f_k = np.array([amplitude_2f_k] * num_of_dets) + + if isinstance(optical_power_k, Number): + optical_power_k = np.array([optical_power_k] * num_of_dets) + + assert len(amplitude_2f_k) == num_of_dets + assert len(optical_power_k) == num_of_dets + + for detector_idx in range(tod.shape[0]): + add_2f_for_one_detector( + tod_det=tod[detector_idx], + angle_det_rad=hwp_angle, + amplitude_k=amplitude_2f_k[detector_idx], + monopole_k=optical_power_k[detector_idx], + ) + + +def add_2f_to_observations( + observations: Union[Observation, List[Observation]], + hwp: Optional[HWP] = None, + component: str = "tod", + amplitude_2f_k: Union[float, None] = None, + optical_power_k: Union[float, None] = None, +): + """Add the HWP differential emission to some time-ordered data + + This is a wrapper around the :func:`.add_2f` function that applies to the TOD + stored in `observations`, which can either be one :class:`.Observation` instance + or a list of observations. + + By default, the TOD is added to ``Observation.tod``. If you want to add it to some + other field of the :class:`.Observation` class, use `component`:: + + for cur_obs in sim.observations: + # Allocate a new TOD for the 2f alone + cur_obs.2f_tod = np.zeros_like(cur_obs.tod) + + # Ask `add_2f_to_observations` to store the 2f + # in `observations.2f_tod` + add_2f_to_observations(sim.observations, component="2f_tod") + """ + if isinstance(observations, Observation): + obs_list = [observations] + else: + obs_list = observations + + # iterate through each observation + for cur_obs in obs_list: + if amplitude_2f_k is None: + amplitude_2f_k = cur_obs.amplitude_2f_k + + if optical_power_k is None: + optical_power_k = cur_obs.optical_power_k + + if hwp is None: + if hasattr(cur_obs, "hwp_angle"): + hwp_angle = cur_obs.hwp_angle + else: + hwp_angle = None + else: + hwp_angle = get_hwp_angle(cur_obs, hwp) + + add_2f( + tod=getattr(cur_obs, component), + hwp_angle=hwp_angle, + amplitude_2f_k=amplitude_2f_k, + optical_power_k=optical_power_k, + ) diff --git a/litebird_sim/noise.py b/litebird_sim/noise.py index a43d6982..750e873f 100644 --- a/litebird_sim/noise.py +++ b/litebird_sim/noise.py @@ -235,7 +235,7 @@ def add_noise_to_observations( obs_list = observations # iterate through each observation - for i, cur_obs in enumerate(obs_list): + for cur_obs in obs_list: add_noise( tod=getattr(cur_obs, component), noise_type=noise_type, diff --git a/litebird_sim/non_linearity.py b/litebird_sim/non_linearity.py new file mode 100644 index 00000000..e045a12e --- /dev/null +++ b/litebird_sim/non_linearity.py @@ -0,0 +1,74 @@ +# -*- encoding: utf-8 -*- + +from typing import List, Union + +from numba import njit, prange + +from .observations import Observation + + +@njit +def apply_quadratic_nonlin_for_one_sample(data, g_one_over_k): + return data + g_one_over_k * data**2 + + +@njit(parallel=True) +def apply_quadratic_nonlin_for_one_detector(tod_det, g_one_over_k): + for i in prange(len(tod_det)): + tod_det[i] += g_one_over_k * tod_det[i] ** 2 + + +def apply_quadratic_nonlin(tod, g_one_over_k: float): + """Apply a quadratic nonlinearity to some time-ordered data + + This functions modifies the values in `tod` by adding a parabolic function of the TOD itself. + The `g_one_over_k` argument must be a N_dets array containing the amplitude of the nonlinear gain to be applied.""" + + assert len(tod.shape) == 2 + num_of_dets = tod.shape[0] + assert len(g_one_over_k) == num_of_dets + + for detector_idx in range(tod.shape[0]): + apply_quadratic_nonlin_for_one_detector( + tod_det=tod[detector_idx], + g_one_over_k=g_one_over_k[detector_idx], + ) + + +def apply_quadratic_nonlin_to_observations( + observations: Union[Observation, List[Observation]], + component: str = "tod", + g_one_over_k: Union[float, None] = None, +): + """Apply a quadratic nonlinearity to some time-ordered data + + This is a wrapper around the :func:`.apply_quadratic_nonlin` function that applies to the TOD + stored in `observations`, which can either be one :class:`.Observation` instance + or a list of observations. + + By default, the modified TOD is ``Observation.tod``. If you want to modify some + other field of the :class:`.Observation` class, use `component`:: + + for cur_obs in sim.observations: + # Allocate a new TOD for the nonlinear TOD alone + cur_obs.nl_tod = np.zeros_like(cur_obs.tod) + + # Ask `apply_quadratic_nonlin_to_observations` to store the nonlinear TOD + # in `observations.nl_tod` + apply_quadratic_nonlin_to_observations(sim.observations, component="nl_tod") + """ + + if isinstance(observations, Observation): + obs_list = [observations] + else: + obs_list = observations + + # iterate through each observation + for cur_obs in obs_list: + if g_one_over_k is None: + g_one_over_k = cur_obs.g_one_over_k + + apply_quadratic_nonlin( + tod=getattr(cur_obs, component), + g_one_over_k=g_one_over_k, + ) diff --git a/litebird_sim/simulations.py b/litebird_sim/simulations.py index 7a213a0a..5085cac1 100644 --- a/litebird_sim/simulations.py +++ b/litebird_sim/simulations.py @@ -32,6 +32,7 @@ from .distribute import distribute_evenly, distribute_optimally from .gaindrifts import GainDriftType, GainDriftParams, apply_gaindrift_to_observations from .healpix import write_healpix_map_to_file, npix_to_nside +from .hwp_diff_emiss import add_2f_to_observations from .imo.imo import Imo from .io import write_list_of_observations, read_list_of_observations from .mapmaking import ( @@ -46,6 +47,7 @@ ) from .mpi import MPI_ENABLED, MPI_COMM_WORLD from .noise import add_noise_to_observations +from .non_linearity import apply_quadratic_nonlin_to_observations from .observations import Observation, TodDescription from .pointings_in_obs import prepare_pointings, precompute_pointings from .profiler import TimeProfiler, profile_list_to_speedscope @@ -1427,8 +1429,8 @@ def add_dipole( self, t_cmb_k: float = constants.T_CMB_K, dipole_type: DipoleType = DipoleType.TOTAL_FROM_LIN_T, - append_to_report: bool = True, component: str = "tod", + append_to_report: bool = True, ): """Fills the tod with dipole. @@ -1467,13 +1469,89 @@ def add_dipole( dip_velocity=dip_velocity, ) + @_profile + def add_2f( + self, + component: str = "tod", + amplitude_2f_k: Union[float, None] = None, + optical_power_k: Union[float, None] = None, + append_to_report: bool = False, + ): + """Add the HWP differential emission to all the observations of this + simulation + + This method must be called after having set the scanning strategy, the + instrument, the list of detectors to simulate through calls to + :meth:`.set_instrument` and :meth:`.add_detector`, and the pointing + through :meth:`.prepare_pointings`. + """ + + add_2f_to_observations( + observations=self.observations, + hwp=self.hwp, + component=component, + amplitude_2f_k=amplitude_2f_k, + optical_power_k=optical_power_k, + ) + + if append_to_report and MPI_COMM_WORLD.rank == 0: + template_file_path = get_template_file_path("report_2f.md") + + with template_file_path.open("rt") as inpf: + markdown_template = "".join(inpf.readlines()) + + if amplitude_2f_k is None: + amp = "Amplitudes taken from IMo" + else: + amp = amplitude_2f_k + + if optical_power_k is None: + op = "Optical power taken from IMo" + else: + op = optical_power_k + + self.append_to_report( + markdown_template, + amplitude_2f=amp, + optical_power=op, + ) + + @_profile + def apply_quadratic_nonlin( + self, + component: str = "tod", + g_one_over_k: Union[float, None] = None, + append_to_report: bool = False, + ): + apply_quadratic_nonlin_to_observations( + observations=self.observations, + component=component, + g_one_over_k=g_one_over_k, + ) + + if append_to_report and MPI_COMM_WORLD.rank == 0: + template_file_path = get_template_file_path("report_quad_nonlin.md") + + with template_file_path.open("rt") as inpf: + markdown_template = "".join(inpf.readlines()) + + if g_one_over_k is None: + g = "Detector non-linearity factor taken from IMo" + else: + g = g_one_over_k + + self.append_to_report( + markdown_template, + g=g, + ) + @_profile def add_noise( self, random: np.random.Generator, noise_type: str = "one_over_f", - append_to_report: bool = True, component: str = "tod", + append_to_report: bool = True, ): """Adds noise to tods. @@ -1523,9 +1601,9 @@ def make_binned_map_splits( components: Optional[List[str]] = None, detector_splits: Union[str, List[str]] = "full", time_splits: Union[str, List[str]] = "full", - append_to_report: bool = True, write_to_disk: bool = True, include_inv_covariance: bool = False, + append_to_report: bool = True, ) -> Union[List[str], dict[str, BinnerResult]]: """ Wrapper around :meth:`.make_binned_map` that allows to obtain all the splits from the @@ -1667,11 +1745,11 @@ def make_destriped_map_splits( keep_weights: bool = False, keep_pixel_idx: bool = False, keep_pol_angle_rad: bool = False, - append_to_report: bool = True, callback: Any = destriper_log_callback, callback_kwargs: Optional[Dict[Any, Any]] = None, write_to_disk: bool = True, recycle_baselines: bool = False, + append_to_report: bool = True, ) -> Union[List[str], dict[str, DestriperResult]]: """ Wrapper around :meth:`.make_destriped_map` that allows to obtain all the splits from the diff --git a/notebooks/example_of_diffemission_and_nonlinearity.ipynb b/notebooks/example_of_diffemission_and_nonlinearity.ipynb new file mode 100644 index 00000000..12889ab3 --- /dev/null +++ b/notebooks/example_of_diffemission_and_nonlinearity.ipynb @@ -0,0 +1,661 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "8e88b1a5", + "metadata": {}, + "outputs": [], + "source": [ + "import litebird_sim as lbs\n", + "import numpy as np\n", + "import matplotlib.pylab as plt\n", + "import healpy as hp\n", + "import astropy\n", + "from scipy.signal import periodogram\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "4373f9f2", + "metadata": {}, + "source": [ + "# Parameters of the simulation\n", + "\n", + "We will simulate a pair of 140 GHz LFT detectors. Their definition will be taken from the LiteBIRD Instrument MOdel (IMO) version vPTEP (**new!**), and we will simulate 6 months of observation. See the [documentation](https://litebird-sim.readthedocs.io/en/latest/simulations.html#simulations) for more details about the input parameters.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bd3a8c68", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "telescope = \"LFT\"\n", + "channel = \"L4-140\"\n", + "detlist = [\"000_001_017_QB_140_T\", \"000_001_017_QB_140_B\"]\n", + "\n", + "start_time = astropy.time.Time(\"2025-01-01T00:00:00\")\n", + "mission_time_days = 1\n", + "\n", + "imo_version = \"vPTEP\"\n", + "\n", + "# Resolution of the output maps\n", + "nside = 64" + ] + }, + { + "cell_type": "markdown", + "id": "f4856815", + "metadata": {}, + "source": [ + "To use the IMO bundled in `litebird_sim`, one needs to do the following:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "05624b49", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# This is the folder where the final report with the results of the simulation will be saved\n", + "base_path = \".test\"\n", + "\n", + "imo = lbs.Imo(flatfile_location=lbs.PTEP_IMO_LOCATION)\n", + "\n", + "# initializing the simulation\n", + "sim = lbs.Simulation(\n", + " base_path=base_path,\n", + " imo=imo,\n", + " # mpi_comm=comm, <--- needed if parallelizing\n", + " start_time=start_time,\n", + " duration_s=mission_time_days * 24 * 3600.0,\n", + " random_seed=12345, # seed for the random number generator (MANDATORY parameter!!!)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8185f0a1", + "metadata": {}, + "source": [ + "The following instructions load from the IMO the information about the [instrument](https://litebird-sim.readthedocs.io/en/latest/detectors.html#detectors-channels-and-instruments) and the [detectors](https://litebird-sim.readthedocs.io/en/latest/detectors.html#detectors-channels-and-instruments) used in the simulation.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "84c04631", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n" + ] + } + ], + "source": [ + "# Load the definition of the instrument\n", + "sim.set_instrument(\n", + " lbs.InstrumentInfo.from_imo(\n", + " imo,\n", + " f\"/releases/{imo_version}/satellite/{telescope}/instrument_info\",\n", + " )\n", + ")\n", + "\n", + "# filling dets with info and detquats with quaternions of the detectors in detlist\n", + "dets = [] # type: List[lbs.DetectorInfo]\n", + "for n_det in detlist:\n", + " det = lbs.DetectorInfo.from_imo(\n", + " url=f\"/releases/{imo_version}/satellite/{telescope}/{channel}/{n_det}/detector_info\",\n", + " imo=imo,\n", + " )\n", + "\n", + " # we overwrite the nominal sampling rate read from IMO with a smaller one, so that\n", + " # we produce six months tod without taking too much memory\n", + " det.sampling_rate_hz = 19\n", + "\n", + " dets.append(det)" + ] + }, + { + "cell_type": "markdown", + "id": "39227859", + "metadata": {}, + "source": [ + "The following command will take some time: it needs to compute the ephemerides of the Earth with respect to the Ecliptic reference frame and derive the orientation of the LFT instrument as a function of time for the whole duration of the simulation. This step will be needed later, when we will obtain the pointings for the detectors involved in the simulation. See the [documentation](https://litebird-sim.readthedocs.io/en/latest/scanning.html#scanning-strategy) for more details about the scanning strategy.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "17384fac", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Generate the quaternions describing how the instrument moves in the Ecliptic reference frame\n", + "sim.set_scanning_strategy(\n", + " imo_url=f\"/releases/{imo_version}/satellite/scanning_parameters/\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "c041f646", + "metadata": {}, + "source": [ + "#### Making TOD with HWP emission and nonlinearity" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3ae0a32b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# creating one observation\n", + "sim.create_observations(\n", + " detectors=dets,\n", + " n_blocks_det=1,\n", + " n_blocks_time=1, # blocks different from one if parallelizing\n", + ")\n", + "\n", + "assert len(sim.observations) == 1" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4590482d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "sim.set_hwp(\n", + " lbs.IdealHWP(\n", + " sim.instrument.hwp_rpm * 2 * np.pi / 60,\n", + " ), # applies hwp rotation angle to the polarization angle\n", + ")\n", + "sim.prepare_pointings()\n", + "sim.precompute_pointings()" + ] + }, + { + "cell_type": "markdown", + "id": "6398e083-0f72-4f3f-8535-a7519d64f280", + "metadata": { + "tags": [] + }, + "source": [ + "Let's build a sky map and scan it to fill the TOD " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1c7cfa31-a7dc-4174-bc9b-17166bc01fa5", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# loading channel info\n", + "ch_info = []\n", + "ch_info.append(\n", + " lbs.FreqChannelInfo.from_imo(\n", + " url=f\"/releases/{imo_version}/satellite/{telescope}/{channel}/channel_info\",\n", + " imo=imo,\n", + " )\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d050963c-898e-46ea-919f-693593b3128e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[2024-10-29 19:30:07,626 INFO MPI#0000] generating and saving cmb simulations\n", + "[2024-10-29 19:30:07,677 INFO MPI#0000] Sigma is 0.000000 arcmin (0.000000 rad) \n", + "[2024-10-29 19:30:07,678 INFO MPI#0000] -> fwhm is 0.000000 arcmin\n", + "[2024-10-29 19:30:07,698 INFO MPI#0000] Access data from /Users/utente/Desktop/litebird_dev/notebooks/.test/cmb/0000/cmb_0000_date_241029.fits\n", + "[2024-10-29 19:30:07,700 INFO MPI#0000] NSIDE = 64\n", + "[2024-10-29 19:30:07,701 INFO MPI#0000] ORDERING = RING in fits file\n", + "[2024-10-29 19:30:07,702 INFO MPI#0000] INDXSCHM = IMPLICIT\n", + "[2024-10-29 19:30:07,727 INFO MPI#0000] generating and saving fg simulations\n", + "[2024-10-29 19:30:07,729 INFO MPI#0000] Retrieve data for pysm_2/synch_t_new.fits (if not cached already)\n", + "[2024-10-29 19:30:07,768 INFO MPI#0000] NSIDE = 512\n", + "[2024-10-29 19:30:07,769 INFO MPI#0000] ORDERING = RING in fits file\n", + "[2024-10-29 19:30:07,769 INFO MPI#0000] INDXSCHM = IMPLICIT\n", + "[2024-10-29 19:30:07,928 INFO MPI#0000] Retrieve data for pysm_2/synch_q_new.fits (if not cached already)\n", + "[2024-10-29 19:30:07,931 INFO MPI#0000] NSIDE = 512\n", + "[2024-10-29 19:30:07,932 INFO MPI#0000] ORDERING = RING in fits file\n", + "[2024-10-29 19:30:07,932 INFO MPI#0000] INDXSCHM = IMPLICIT\n", + "[2024-10-29 19:30:08,043 INFO MPI#0000] Retrieve data for pysm_2/synch_u_new.fits (if not cached already)\n", + "[2024-10-29 19:30:08,050 INFO MPI#0000] NSIDE = 512\n", + "[2024-10-29 19:30:08,050 INFO MPI#0000] ORDERING = RING in fits file\n", + "[2024-10-29 19:30:08,051 INFO MPI#0000] INDXSCHM = IMPLICIT\n", + "[2024-10-29 19:30:09,776 INFO MPI#0000] Retrieve data for pysm_2/ff_t_new.fits (if not cached already)\n", + "[2024-10-29 19:30:09,779 INFO MPI#0000] NSIDE = 512\n", + "[2024-10-29 19:30:09,779 INFO MPI#0000] ORDERING = RING in fits file\n", + "[2024-10-29 19:30:09,780 INFO MPI#0000] INDXSCHM = IMPLICIT\n", + "[2024-10-29 19:30:10,519 INFO MPI#0000] Retrieve data for pysm_2/dust_t_new.fits (if not cached already)\n", + "[2024-10-29 19:30:10,522 INFO MPI#0000] NSIDE = 512\n", + "[2024-10-29 19:30:10,522 INFO MPI#0000] ORDERING = RING in fits file\n", + "[2024-10-29 19:30:10,523 INFO MPI#0000] INDXSCHM = IMPLICIT\n", + "[2024-10-29 19:30:10,676 INFO MPI#0000] Retrieve data for pysm_2/dust_q_new.fits (if not cached already)\n", + "[2024-10-29 19:30:10,683 INFO MPI#0000] NSIDE = 512\n", + "[2024-10-29 19:30:10,684 INFO MPI#0000] ORDERING = RING in fits file\n", + "[2024-10-29 19:30:10,684 INFO MPI#0000] INDXSCHM = IMPLICIT\n", + "[2024-10-29 19:30:10,800 INFO MPI#0000] Retrieve data for pysm_2/dust_u_new.fits (if not cached already)\n", + "[2024-10-29 19:30:10,807 INFO MPI#0000] NSIDE = 512\n", + "[2024-10-29 19:30:10,807 INFO MPI#0000] ORDERING = RING in fits file\n", + "[2024-10-29 19:30:10,808 INFO MPI#0000] INDXSCHM = IMPLICIT\n" + ] + } + ], + "source": [ + "# let's make an input CMB+foreground map\n", + "\n", + "# this sets the parameters for the generation of the map\n", + "Mbsparams = lbs.MbsParameters(\n", + " make_cmb=True,\n", + " make_fg=True,\n", + " fg_models=[\n", + " \"pysm_synch_0\",\n", + " \"pysm_freefree_1\",\n", + " \"pysm_dust_0\",\n", + " ], # set the FG models you want\n", + " nside=nside,\n", + " units=\"K_CMB\",\n", + ")\n", + "\n", + "mbs = lbs.Mbs(simulation=sim, parameters=Mbsparams, channel_list=ch_info)\n", + "maps = mbs.run_all()[0] # generates the map as a dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "fbe6bb19-f4f0-4d05-9ee6-91310d018acd", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "sim.fill_tods(maps)\n", + "sim.add_dipole()\n", + "sim.add_noise(random=sim.random)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e2ea332b-5c85-4f32-9198-f43d8b088e4a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "binner_results = sim.make_binned_map(nside=nside)\n", + "binned = binner_results.binned_map" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "68e5dadd-3d3a-413a-bb15-cd798ba20611", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(15, 8))\n", + "hp.mollview(binned[0], sub=131, title=\"T\", unit=r\"[K]\")\n", + "hp.mollview(binned[1], sub=132, title=\"Q\", unit=r\"[K]\")\n", + "hp.mollview(binned[2], sub=133, title=\"U\", unit=r\"[K]\")" + ] + }, + { + "cell_type": "markdown", + "id": "acf0f0d2-a002-41b6-b20d-4aa4e2e796c8", + "metadata": {}, + "source": [ + "Now we can add the 2f signal with custom parameters. Given the structure of the functions, parameters for each band could be read from the IMo once they are added to it." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "0c9b86bc-ec65-4bfb-b3d7-2d5b3f19a1b7", + "metadata": { + "scrolled": false, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], + "source": [ + "# setting 2f parameters\n", + "sim.observations[0].amplitude_2f_k = np.array([0.1, 0.1])\n", + "sim.observations[0].optical_power_k = np.array([0.0, 0.0])\n", + "sim.add_2f()" + ] + }, + { + "cell_type": "markdown", + "id": "b68dfa70-dcbe-4019-afe6-ce7aef0d2839", + "metadata": {}, + "source": [ + "Let's check our TODs and maps after adding 2f signal" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "a9d815ba-fd9e-4aec-87a3-85e8237340a3", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(sim.observations[0].tod[0][:100])\n", + "plt.plot(sim.observations[0].tod[1][:100])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "a25bbc7b-3fa4-4fdb-8893-2f988cb83999", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "binner_results = sim.make_binned_map(nside=nside)\n", + "binned = binner_results.binned_map" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "63baaeb9-8949-4af8-a0ea-498a3b254a34", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(15, 8))\n", + "hp.mollview(binned[0], sub=131, title=\"T\", unit=r\"[K]\")\n", + "hp.mollview(binned[1], sub=132, title=\"Q\", unit=r\"[K]\")\n", + "hp.mollview(binned[2], sub=133, title=\"U\", unit=r\"[K]\")" + ] + }, + { + "cell_type": "markdown", + "id": "d7635e6e-7da5-491d-95ad-a2f0772318d3", + "metadata": { + "tags": [] + }, + "source": [ + "Last step is applying nonlinearity. We choose just one detector, to have a reference for the ideal case" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "9b7c6e79-e43a-4a15-9e3f-c8ee0608e253", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# setting nonlinearity\n", + "sim.observations[0].g_one_over_k = np.array([1e-3, 0])\n", + "sim.apply_quadratic_nonlin()" + ] + }, + { + "cell_type": "markdown", + "id": "1faf3bea-69d4-48f5-ae96-019cd4ebff9b", + "metadata": {}, + "source": [ + "Let's check our TODs and maps after applying a quadratic non-linearity" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "b758f3b7-9cd9-4d9f-81ba-9623b45f3f9e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(\n", + " sim.observations[0].tod[0][:100]\n", + ") # we chose det_0 to have 0 nonlinearity for reference\n", + "plt.plot(sim.observations[0].tod[1][:100])" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "71a446de-f7db-472e-8b41-658bbd48c3d4", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "binner_results = sim.make_binned_map(nside=nside)\n", + "binned = binner_results.binned_map" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "9cc099d9-b5e4-425e-8125-05da9f2905ca", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(15, 8))\n", + "hp.mollview(binned[0], sub=131, title=\"T\", unit=r\"[K]\")\n", + "hp.mollview(binned[1], sub=132, title=\"Q\", unit=r\"[K]\")\n", + "hp.mollview(binned[2], sub=133, title=\"U\", unit=r\"[K]\")" + ] + }, + { + "cell_type": "markdown", + "id": "37b3db88-b0fe-4e11-bb45-53a2c7710e7b", + "metadata": {}, + "source": [ + "We can see the effect on the Fourier transform as well:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "380e3dfb-847f-4760-a038-99aa797d5912", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "f_nl0, psd_nl0 = periodogram(sim.observations[0].tod[1], 19)\n", + "f_nl1e3, psd_nl1e3 = periodogram(sim.observations[0].tod[0], 19)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "7dff7fe5-b5aa-4987-976e-8ba69bda2b51", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.loglog(f_nl0, psd_nl0, alpha=0.5, label=r\"$g_1$ = 0\")\n", + "plt.loglog(f_nl1e3, psd_nl1e3, alpha=0.5, label=r\"$g_1$ = 1e-3\")\n", + "plt.grid(which=\"both\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5015c3e5-0081-446f-90f4-766762394e34", + "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.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/templates/report_2f.md b/templates/report_2f.md new file mode 100644 index 00000000..c71d1ac3 --- /dev/null +++ b/templates/report_2f.md @@ -0,0 +1,6 @@ +## Addition of differential emissivity + +A 2f term has been added to the TODs + +- Amplitude of 2f term: {{amplitude_2f}} K +- Optical power: {{optical_power}} K diff --git a/templates/report_quad_nonlin.md b/templates/report_quad_nonlin.md new file mode 100644 index 00000000..f1969628 --- /dev/null +++ b/templates/report_quad_nonlin.md @@ -0,0 +1,5 @@ +## Addition of quadratic non-lineariy + +Quadratic non-linearity has been added to the TOD + +- detector non-linearity factor : {{g}} diff --git a/test/test_hwp_diff_emiss.py b/test/test_hwp_diff_emiss.py new file mode 100644 index 00000000..5a0a4040 --- /dev/null +++ b/test/test_hwp_diff_emiss.py @@ -0,0 +1,98 @@ +import numpy as np +import litebird_sim as lbs +from astropy.time import Time +from litebird_sim.pointings import get_hwp_angle + + +def test_add_2f(): + # Test function to check consistency of wrappers and low level functions + telescope = "LFT" + channel = "L4-140" + detlist = ["000_001_017_QB_140_T", "000_001_017_QB_140_B"] + imo_version = "vPTEP" + start_time = Time("2025-02-02T00:00:00") + mission_time_days = 1 + + imo = lbs.Imo(flatfile_location=lbs.PTEP_IMO_LOCATION) + + sim = lbs.Simulation( + base_path="nonlin_example", + start_time=start_time, + imo=imo, + duration_s=mission_time_days * 24 * 3600.0, + random_seed=12345, + ) + + # Load the definition of the instrument + sim.set_instrument( + lbs.InstrumentInfo.from_imo( + imo, + f"/releases/{imo_version}/satellite/{telescope}/instrument_info", + ) + ) + + dets = [] + for n_det in detlist: + det = lbs.DetectorInfo.from_imo( + url=f"/releases/{imo_version}/satellite/{telescope}/{channel}/{n_det}/detector_info", + imo=imo, + ) + det.sampling_rate_hz = 1 + dets.append(det) + + sim.create_observations( + detectors=dets, + split_list_over_processes=False, + ) + + sim.set_scanning_strategy( + imo_url=f"/releases/{imo_version}/satellite/scanning_parameters/" + ) + + sim.set_hwp( + lbs.IdealHWP( + sim.instrument.hwp_rpm * 2 * np.pi / 60, + ), + ) + + sim.prepare_pointings() + sim.precompute_pointings() + + # Creating fiducial TODs + sim.observations[0].tod2f_2_self = np.zeros_like(sim.observations[0].tod) + sim.observations[0].tod2f_2_obs = np.zeros_like(sim.observations[0].tod) + sim.observations[0].tod2f_2_det = np.zeros_like(sim.observations[0].tod) + + # Define differential emission parameters for the detectors. + sim.observations[0].amplitude_2f_k = np.array([0.1, 0.1]) + sim.observations[0].optical_power_k = np.array([0.0, 0.0]) + + # Adding 2f signal from HWP differential emission using the `Simulation` class method + sim.add_2f( + component="tod2f_2_self", + ) + + # Adding 2f signal from HWP differential emission to the given TOD component of an `Observation` object + lbs.hwp_diff_emiss.add_2f_to_observations( + observations=sim.observations, + hwp=sim.hwp, + component="tod2f_2_obs", + ) + + # Adding 2f signal from HWP differential emission to the TOD arrays of the individual detectors. + for idx, tod in enumerate(sim.observations[0].tod2f_2_det): + lbs.hwp_diff_emiss.add_2f_for_one_detector( + tod_det=tod, + angle_det_rad=get_hwp_angle(sim.observations[0], sim.hwp), + amplitude_k=sim.observations[0].amplitude_2f_k[idx], + monopole_k=sim.observations[0].optical_power_k[idx], + ) + + # Check if the three tods are equal after adding 2f signal from HWP differential emission + + np.testing.assert_array_equal( + sim.observations[0].tod2f_2_self, sim.observations[0].tod2f_2_obs + ) + np.testing.assert_array_equal( + sim.observations[0].tod2f_2_self, sim.observations[0].tod2f_2_det + ) diff --git a/test/test_nonlinearity.py b/test/test_nonlinearity.py new file mode 100644 index 00000000..b2e19afd --- /dev/null +++ b/test/test_nonlinearity.py @@ -0,0 +1,70 @@ +import numpy as np +import litebird_sim as lbs +from astropy.time import Time + + +def test_add_quadratic_nonlinearity(): + # Test function to check consistency of wrappers and low level functions + start_time = Time("2025-02-02T00:00:00") + mission_time_days = 1 + sampling_hz = 1 + + dets = [ + lbs.DetectorInfo(name="det_A", sampling_rate_hz=sampling_hz), + lbs.DetectorInfo(name="det_B", sampling_rate_hz=sampling_hz), + ] + + sim = lbs.Simulation( + base_path="nonlin_example", + start_time=start_time, + duration_s=mission_time_days * 24 * 3600.0, + random_seed=12345, + ) + + sim.create_observations( + detectors=dets, + split_list_over_processes=False, + ) + + # Creating fiducial TODs + sim.observations[0].nl_2_self = np.ones_like(sim.observations[0].tod) + sim.observations[0].nl_2_obs = np.ones_like(sim.observations[0].tod) + sim.observations[0].nl_2_det = np.ones_like(sim.observations[0].tod) + + # Define non-linear parameters for the detectors. + sim.observations[0].g_one_over_k = np.ones(len(dets)) * 1e-3 + + # Applying non-linearity using the `Simulation` class method + sim.apply_quadratic_nonlin( + component="nl_2_self", + ) + + # Applying non-linearity on the given TOD component of an `Observation` object + lbs.non_linearity.apply_quadratic_nonlin_to_observations( + observations=sim.observations, + component="nl_2_obs", + ) + + # Applying non-linearity on the TOD arrays of the individual detectors. + for idx, tod in enumerate(sim.observations[0].nl_2_det): + lbs.non_linearity.apply_quadratic_nonlin_for_one_detector( + tod_det=tod, + g_one_over_k=sim.observations[0].g_one_over_k[idx], + ) + + # Check if the three non-linear tods are equal + + np.testing.assert_array_equal( + sim.observations[0].nl_2_self, sim.observations[0].nl_2_obs + ) + np.testing.assert_array_equal( + sim.observations[0].nl_2_self, sim.observations[0].nl_2_det + ) + + # Check if non-linearity is applied correctly + sim.observations[0].tod_origin = np.ones_like(sim.observations[0].tod) + np.testing.assert_array_equal( + sim.observations[0].nl_2_self[0], + sim.observations[0].tod_origin[0] + * (1 + sim.observations[0].g_one_over_k[0] * sim.observations[0].tod_origin[0]), + )