lisainstrument 2.2.1__tar.gz → 2.3.0__tar.gz

{lisainstrument-2.2.1 → lisainstrument-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lisainstrument
-Version: 2.2.1
+Version: 2.3.0
 Summary: Simulates the LISA measurement chain (noise and signals) and generates telemetry data
 Home-page: https://gitlab.in2p3.fr/lisa-simulation/instrument
 License: BSD 3-Clause

{lisainstrument-2.2.1 → lisainstrument-2.3.0}/lisainstrument/__init__.py

@@ -2,7 +2,7 @@
 
 from .glitches import glitch_file
 from .gwsource import gw_file
-from .instru import SimResultFile, sim_result_file
+from .instru import SimResultFile, sim_result_file, ttl_source_from_metadata
 from .instrument import Instrument
 from .orbiting import MosaID, SatID, orbit_file
 from .streams import SchedulerConfigParallel, SchedulerConfigSerial

{lisainstrument-2.2.1 → lisainstrument-2.3.0}/lisainstrument/instru/__init__.py

@@ -19,3 +19,7 @@ from lisainstrument.instru.instru_store import (
     SimResultsNumpyFull,
     store_instru_hdf5,
 )
+from lisainstrument.instru.instru_ttlsrc import (
+    init_ttl_source,
+    ttl_source_from_metadata,
+)

{lisainstrument-2.2.1 → lisainstrument-2.3.0}/lisainstrument/instru/instru_defaults.py

@@ -72,13 +72,13 @@ Default based on LISANode
 """
 
 
-TTL_COEFFS_LOCAL_PHIS: Final[dict[str, float]] = {
-    "12": 2.005835e-03,
-    "23": 2.105403e-04,
-    "31": -1.815399e-03,
-    "13": -2.865050e-04,
-    "32": -1.986657e-03,
-    "21": 9.368319e-04,
+TTL_COEFFS_LOCAL_PHIS: Final[dict[MosaID, float]] = {
+    MosaID.MOSA_12: 2.005835e-03,
+    MosaID.MOSA_23: 2.105403e-04,
+    MosaID.MOSA_31: -1.815399e-03,
+    MosaID.MOSA_13: -2.865050e-04,
+    MosaID.MOSA_32: -1.986657e-03,
+    MosaID.MOSA_21: 9.368319e-04,
 }
 """Value to use if  ttl_coeffs == "default"
 
@@ -86,39 +86,39 @@ Default values were drawn from the same distributions used for ttl_coeffs == "ra
 """
 
 
-TTL_COEFFS_DISTANT_PHIS: Final[dict[str, float]] = {
-    "12": 1.623910e-03,
-    "23": 1.522873e-04,
-    "31": -1.842871e-03,
-    "13": -2.091585e-03,
-    "32": 1.300866e-03,
-    "21": -8.445374e-04,
+TTL_COEFFS_DISTANT_PHIS: Final[dict[MosaID, float]] = {
+    MosaID.MOSA_12: 1.623910e-03,
+    MosaID.MOSA_23: 1.522873e-04,
+    MosaID.MOSA_31: -1.842871e-03,
+    MosaID.MOSA_13: -2.091585e-03,
+    MosaID.MOSA_32: 1.300866e-03,
+    MosaID.MOSA_21: -8.445374e-04,
 }
 """Value to use if  ttl_coeffs == "default"
 
 Default values were drawn from the same distributions used for ttl_coeffs == "random"
 """
 
-TTL_COEFFS_LOCAL_ETAS: Final[dict[str, float]] = {
-    "12": -1.670389e-03,
-    "23": 1.460681e-03,
-    "31": -1.039064e-03,
-    "13": 1.640473e-04,
-    "32": 1.205353e-03,
-    "21": -9.205764e-04,
+TTL_COEFFS_LOCAL_ETAS: Final[dict[MosaID, float]] = {
+    MosaID.MOSA_12: -1.670389e-03,
+    MosaID.MOSA_23: 1.460681e-03,
+    MosaID.MOSA_31: -1.039064e-03,
+    MosaID.MOSA_13: 1.640473e-04,
+    MosaID.MOSA_32: 1.205353e-03,
+    MosaID.MOSA_21: -9.205764e-04,
 }
 """Value to use if  ttl_coeffs == "default"
 
 Default values were drawn from the same distributions used for ttl_coeffs == "random"
 """
 
-TTL_COEFFS_DISTANT_ETAS: Final[dict[str, float]] = {
-    "12": -1.076470e-03,
-    "23": 5.228848e-04,
-    "31": -5.662766e-05,
-    "13": 1.960050e-03,
-    "32": 9.021890e-04,
-    "21": 1.908239e-03,
+TTL_COEFFS_DISTANT_ETAS: Final[dict[MosaID, float]] = {
+    MosaID.MOSA_12: -1.076470e-03,
+    MosaID.MOSA_23: 5.228848e-04,
+    MosaID.MOSA_31: -5.662766e-05,
+    MosaID.MOSA_13: 1.960050e-03,
+    MosaID.MOSA_32: 9.021890e-04,
+    MosaID.MOSA_21: 1.908239e-03,
 }
 """Value to use if  ttl_coeffs == "default"
 
@@ -165,21 +165,21 @@ Those default PPRs are based on first samples of Keplerian orbits (v2.0.dev)
 """
 
 
-def random_ttl_coeffs_local_phis(low=-2.2e-3, high=2.2e-3) -> dict[str, float]:
+def random_ttl_coeffs_local_phis(low=-2.2e-3, high=2.2e-3) -> dict[MosaID, float]:
     """Generate random value to use if ttl_coeffs == "random" """
-    return {m.value: np.random.uniform(low, high) for m in MosaID}
+    return {m: np.random.uniform(low, high) for m in MosaID}
 
 
-def random_ttl_coeffs_distant_phis(low=-2.4e-3, high=2.4e-3) -> dict[str, float]:
+def random_ttl_coeffs_distant_phis(low=-2.4e-3, high=2.4e-3) -> dict[MosaID, float]:
     """Generate random value to use if ttl_coeffs == "random" """
-    return {m.value: np.random.uniform(low, high) for m in MosaID}
+    return {m: np.random.uniform(low, high) for m in MosaID}
 
 
-def random_ttl_coeffs_local_etas(low=-2.2e-3, high=2.2e-3) -> dict[str, float]:
+def random_ttl_coeffs_local_etas(low=-2.2e-3, high=2.2e-3) -> dict[MosaID, float]:
     """Generate random value to use if ttl_coeffs == "random" """
-    return {m.value: np.random.uniform(low, high) for m in MosaID}
+    return {m: np.random.uniform(low, high) for m in MosaID}
 
 
-def random_ttl_coeffs_distant_etas(low=-2.4e-3, high=2.4e-3) -> dict[str, float]:
+def random_ttl_coeffs_distant_etas(low=-2.4e-3, high=2.4e-3) -> dict[MosaID, float]:
     """Generate random value to use if ttl_coeffs == "random" """
-    return {m.value: np.random.uniform(low, high) for m in MosaID}
+    return {m: np.random.uniform(low, high) for m in MosaID}

{lisainstrument-2.2.1 → lisainstrument-2.3.0}/lisainstrument/instru/instru_file_reader.py

@@ -17,7 +17,7 @@ file formats created by previous versions.
 import json
 import pathlib
 from collections import defaultdict
-from typing import Final, TypeVar
+from typing import Any, Final, TypeAlias, TypeVar
 
 import h5py
 import numpy as np
@@ -30,6 +30,9 @@ from lisainstrument.instru.instru_file_reader_v2_0_0 import (
 from lisainstrument.instru.instru_file_reader_v2_1_0 import (
     SimResultFile as SimResultFile_V2_1_0,
 )
+from lisainstrument.instru.instru_file_reader_v2_2_0 import (
+    SimResultFile as SimResultFile_V2_2_0,
+)
 from lisainstrument.instru.instru_store import (
     IdxSpace,
     SimFullDatasetsMOSA,
@@ -175,7 +178,7 @@ class SimResultFile:
     def format_specifier() -> SpecifierSet:
         """Version specifier set compatible with file reader"""
         v = Version(__version__)
-        return SpecifierSet(f"=={v}")
+        return SpecifierSet(f"=={v.major}.{v.minor}.*")
 
     @classmethod
     def check_file_version(cls, path: str | pathlib.Path) -> tuple[bool, Version]:
@@ -427,6 +430,41 @@ class SimResultFile:
         """
         return self._read_datasets(SimResultsNumpyCore, t_min, t_max)
 
+    def time_window_to_index_range(
+        self,
+        dsid: DatasetIdentifier,
+        t_min: float | None = None,
+        t_max: float | None = None,
+    ) -> tuple[int, int]:
+        """Return the index range contained within a given time period
+
+        For the time grid of a given dataset, the given time interval is
+        mapped to an equivalent index range. More precisely, this returns
+        indices `i0,i1` such that sample times `t_i` for indices in the range
+        `i0 <= i < i1` satisfy `t_min<=t_i<t_max`.
+
+        Beware of rounding errors for the case that `t_min` or `t_max` fall
+        onto a sample time. For application where precise control matters,
+        best use time intervals starting and ending between sample times.
+        Alternatively, one can re-use the same floating point number as
+        `t_max` in one call and `t_min` in the next. Given
+        ´i0,i1 = time_window_to_index_range(dsid, t_a, t_b)´ and
+        ´i2,i3 = time_window_to_index_range(dsid, t_b, t_c)´,
+        it is safe to assume that ´i2==i1`. Hence, the intervals
+        `i0 <= i < i1` and `i2 <= i < i3` have no overlap and cover the
+        range `i0 <= i < i3` without gap.
+
+        The default for `t_min` is such that `i0` is the first valid index
+        of the dataset. The default for `t_max` results in `i1` being the
+        last valid index + 1.
+
+        Arguments:
+            t_min: Left boundary, or None for start of dataset
+            t_max: Right boundary, or None for end of dataset
+        """
+        isp = self.idxspace_by_dataset_id(dsid)
+        return self._restrict_range_isp(isp, t_min, t_max)
+
     def as_stream_bundle(
         self,
         datasets: set[DatasetIdentifier] | None = None,
@@ -446,9 +484,14 @@ class SimResultFile:
         return instru_hdf5_file_as_stream_bundle(self._h5f, datasets, ranges=ranges)
 
 
+SimResultFileTypes: TypeAlias = (
+    SimResultFile | SimResultFile_V2_0_0 | SimResultFile_V2_1_0 | SimResultFile_V2_2_0
+)
+
+
 def sim_result_file(
     path: pathlib.Path | str, only_compatible: bool = False
-) -> SimResultFile | SimResultFile_V2_0_0 | SimResultFile_V2_1_0:
+) -> SimResultFileTypes:
     """Open simulation result file
 
     This provides an interface with methods for reading the file.
@@ -465,12 +508,9 @@ def sim_result_file(
         SimResultFile instance for reading file data
     """
 
-    readers: list[
-        type[SimResultFile] | type[SimResultFile_V2_0_0] | type[SimResultFile_V2_1_0]
-    ] = [SimResultFile]
-    if not only_compatible:
-        readers.append(SimResultFile_V2_0_0)
-        readers.append(SimResultFile_V2_1_0)
+    legacy = [SimResultFile_V2_0_0, SimResultFile_V2_1_0, SimResultFile_V2_2_0]
+    readers: list[Any] = [] if only_compatible else legacy
+    readers.append(SimResultFile)
 
     version: Version
     for reader in readers:

{lisainstrument-2.2.1 → lisainstrument-2.3.0}/lisainstrument/instru/instru_file_reader_v2_0_0.py

@@ -407,6 +407,41 @@ class SimResultFile:
         """
         return self._read_datasets(SimResultsNumpyCore, t_min, t_max)
 
+    def time_window_to_index_range(
+        self,
+        dsid: DatasetIdentifier,
+        t_min: float | None = None,
+        t_max: float | None = None,
+    ) -> tuple[int, int]:
+        """Return the index range contained within a given time period
+
+        For the time grid of a given dataset, the given time interval is
+        mapped to an equivalent index range. More precisely, this returns
+        indices `i0,i1` such that sample times `t_i` for indices in the range
+        `i0 <= i < i1` satisfy `t_min<=t_i<t_max`.
+
+        Beware of rounding errors for the case that `t_min` or `t_max` fall
+        onto a sample time. For application where precise control matters,
+        best use time intervals starting and ending between sample times.
+        Alternatively, one can re-use the same floating point number as
+        `t_max` in one call and `t_min` in the next. Given
+        ´i0,i1 = time_window_to_index_range(dsid, t_a, t_b)´ and
+        ´i2,i3 = time_window_to_index_range(dsid, t_b, t_c)´,
+        it is safe to assume that ´i2==i1`. Hence, the intervals
+        `i0 <= i < i1` and `i2 <= i < i3` have no overlap and cover the
+        range `i0 <= i < i3` without gap.
+
+        The default for `t_min` is such that `i0` is the first valid index
+        of the dataset. The default for `t_max` results in `i1` being the
+        last valid index + 1.
+
+        Arguments:
+            t_min: Left boundary, or None for start of dataset
+            t_max: Right boundary, or None for end of dataset
+        """
+        isp = self.idxspace_by_dataset_id(dsid)
+        return self._restrict_range_isp(isp, t_min, t_max)
+
     def as_stream_bundle(
         self,
         datasets: set[DatasetIdentifier] | None = None,

{lisainstrument-2.2.1 → lisainstrument-2.3.0}/lisainstrument/instru/instru_file_reader_v2_1_0.py

@@ -407,6 +407,41 @@ class SimResultFile:
         """
         return self._read_datasets(SimResultsNumpyCore, t_min, t_max)
 
+    def time_window_to_index_range(
+        self,
+        dsid: DatasetIdentifier,
+        t_min: float | None = None,
+        t_max: float | None = None,
+    ) -> tuple[int, int]:
+        """Return the index range contained within a given time period
+
+        For the time grid of a given dataset, the given time interval is
+        mapped to an equivalent index range. More precisely, this returns
+        indices `i0,i1` such that sample times `t_i` for indices in the range
+        `i0 <= i < i1` satisfy `t_min<=t_i<t_max`.
+
+        Beware of rounding errors for the case that `t_min` or `t_max` fall
+        onto a sample time. For application where precise control matters,
+        best use time intervals starting and ending between sample times.
+        Alternatively, one can re-use the same floating point number as
+        `t_max` in one call and `t_min` in the next. Given
+        ´i0,i1 = time_window_to_index_range(dsid, t_a, t_b)´ and
+        ´i2,i3 = time_window_to_index_range(dsid, t_b, t_c)´,
+        it is safe to assume that ´i2==i1`. Hence, the intervals
+        `i0 <= i < i1` and `i2 <= i < i3` have no overlap and cover the
+        range `i0 <= i < i3` without gap.
+
+        The default for `t_min` is such that `i0` is the first valid index
+        of the dataset. The default for `t_max` results in `i1` being the
+        last valid index + 1.
+
+        Arguments:
+            t_min: Left boundary, or None for start of dataset
+            t_max: Right boundary, or None for end of dataset
+        """
+        isp = self.idxspace_by_dataset_id(dsid)
+        return self._restrict_range_isp(isp, t_min, t_max)
+
     def as_stream_bundle(
         self,
         datasets: set[DatasetIdentifier] | None = None,