lisainstrument 1.3__tar.gz → 1.4__tar.gz

{lisainstrument-1.3 → lisainstrument-1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lisainstrument
-Version: 1.3
+Version: 1.4
 Summary: LISA Instrument simulates instrumental noises, propagates laser beams, generates measurements and the on-board processing to deliver simulated telemetry data.
 Home-page: https://gitlab.in2p3.fr/lisa-simulation/instrument
 Author: Jean-Baptiste Bayle

{lisainstrument-1.3 → lisainstrument-1.4}/lisainstrument/instrument.py

@@ -9,6 +9,7 @@ Authors:
 """
 
 import re
+import math
 import logging
 import numpy as np
 import matplotlib.pyplot as plt
@@ -144,11 +145,11 @@ class Instrument:
             modulation_freqs: dictionary of modulation frequencies [Hz], or 'default'
             tdir_modulations: dictionary of callable generators of TDIR assistance modulations
                 that take an array of TPS times as argument, or None
-            clock_asds: dictionary of clock noise amplitude spectral densities
+            clock_asds: dictionary of clock noise amplitude spectral densities [/sqrt(Hz)]
             clock_offsets: dictionary of clock offsets from TPS [s]
-            clock_freqoffsets: dictionary of clock frequency offsets [s^-1], or 'default'
-            clock_freqlindrifts: dictionary of clock frequency linear drifts [s^-2], or 'default'
-            clock_freqquaddrifts: dictionary of clock frequency quadratic drifts [s^-3], or 'default'
+            clock_freqoffsets: dictionary of clock frequency offsets [s/s], or 'default'
+            clock_freqlindrifts: dictionary of clock frequency linear drifts [s/s^2], or 'default'
+            clock_freqquaddrifts: dictionary of clock frequency quadratic drifts [s/s^3], or 'default'
             clockinv_tolerance: convergence tolerance for clock noise inversion [s]
             clockinv_maxiter: maximum number of iterations for clock noise inversion
             backlink_asds: dictionary of amplitude spectral densities for backlink noise [m/sqrt(Hz)]
@@ -225,27 +226,33 @@ class Instrument:
         self.physics_dt = self.dt / self.physics_upsampling
         self.physics_fs = self.fs * self.physics_upsampling
         logger.info("Computing physics time vector (size=%s, dt=%s)", self.physics_size, self.physics_dt)
-        self.physics_t = self.t0 + np.arange(self.physics_size, dtype=np.float64) * self.physics_dt
-        self.physics_et = self.physics_t - self.t0 # elapsed time
+        self.physics_et = np.arange(self.physics_size, dtype=np.float64) * self.physics_dt # elapsed time
+        self.physics_t = self.t0 + self.physics_et
 
         # Telemetry sampling
         self.telemetry_downsampling = int(telemetry_downsampling)
-        self.initial_telemetry_size = int(initial_telemetry_size)
-        self.initial_telemetry_measurement_size = \
-            self.initial_telemetry_size * self.telemetry_downsampling
-        self.initial_telemetry_physics_size = \
-            self.initial_telemetry_measurement_size * self.physics_upsampling
-        self.telemetry_size = self.initial_telemetry_size \
-            + int(np.ceil(self.size / self.telemetry_downsampling))
         self.telemetry_dt = self.dt * self.telemetry_downsampling
         self.telemetry_fs = self.fs / self.telemetry_downsampling
+        # Extra telemetry samples before t0
+        self.initial_telemetry_size = int(initial_telemetry_size)
         self.telemetry_t0 = self.t0 - self.initial_telemetry_size * self.telemetry_dt
+        # Total telemetry size, includes initial telemetry samples
+        # plus telemetry samples covering the entire measurement time vector,
+        # hence the use of ``math.ceil`` -- the +1 is for the sample at t0
+        self.telemetry_size = self.initial_telemetry_size + 1 \
+            + math.ceil(self.size / self.telemetry_downsampling)
         logger.info("Computing telemetry time vector (size=%s, dt=%s)", self.telemetry_size, self.telemetry_dt)
-        self.telemetry_t = self.telemetry_t0 + np.arange(self.telemetry_size, dtype=np.float64) * self.telemetry_dt
-
-        self.physics_t_withinitial = self.telemetry_t0 + \
-            np.arange(self.physics_size + self.initial_telemetry_physics_size, dtype=np.float64) * self.physics_dt
-        self.physics_et_withinitial = self.physics_t_withinitial - self.t0
+        self.telemetry_t = self.telemetry_t0 \
+            + np.arange(self.telemetry_size, dtype=np.float64) * self.telemetry_dt
+        # Physics time vector covering telemetry samples
+        self.telemetry_to_physics_dt = self.telemetry_downsampling * self.physics_upsampling
+        self.physics_size_covering_telemetry = self.telemetry_size * self.telemetry_to_physics_dt
+        self.physics_et_covering_telemetry = self.telemetry_t0 - self.t0 + \
+            np.arange(self.physics_size_covering_telemetry, dtype=np.float64) * self.physics_dt
+        self.physics_t_covering_telemetry = self.t0 + self.physics_et_covering_telemetry
+        # How to cut physics data covering telemetry to regular size
+        first_sample = self.initial_telemetry_size * self.telemetry_to_physics_dt
+        self.telemetry_physics_slice = slice(first_sample, first_sample + self.physics_size)
 
         # Orbits, gravitational waves, glitches
         self.init_orbits(orbits, orbit_dataset)
@@ -653,7 +660,7 @@ class Instrument:
             logger.debug("Interpolating proper pseudo-range derivatives")
             self.d_pprs = ForEachMOSA(lambda mosa: pprs(mosa).derivative()(self.physics_t))
             logger.debug("Interpolating TPSs with respect to TCB")
-            self.tps_wrt_tcb = ForEachSC(lambda sc: tps_wrt_tcb(sc)(self.physics_t_withinitial))
+            self.tps_wrt_tcb = ForEachSC(lambda sc: tps_wrt_tcb(sc)(self.physics_t_covering_telemetry))
         except ValueError as error:
             logger.error("Missing orbit information at \n%s", self.physics_t)
             raise ValueError("missing orbit information, use longer orbit file or adjust sampling") from error
@@ -677,14 +684,19 @@ class Instrument:
             self.pprs = ForEachMOSA(lambda mosa: interpolate(dataset[:, link_index[mosa]], self.physics_t))
             logger.debug("Interpolating proper pseudo-range derivatives")
             self.d_pprs = ForEachMOSA(lambda mosa: interpolate(dataset[:, link_index[mosa]], self.physics_t, nu=1))
+        except ValueError as error:
+            logger.error("Missing orbit information at \n%s", self.physics_t)
+            raise ValueError("missing orbit information, use longer orbit file or adjust sampling") from error
+        try:
             logger.debug("Interpolating TPSs with respect to TCB")
             if self.orbit_dataset == 'tcb/ltt':
                 self.tps_wrt_tcb = ForEachSC(lambda sc: 0)
             else:
                 dataset = orbitf['tcb/delta_tau']
-                self.tps_wrt_tcb = ForEachSC(lambda sc: interpolate(dataset[:, sc_index[sc]], self.physics_t))
+                self.tps_wrt_tcb = ForEachSC(lambda sc:
+                    interpolate(dataset[:, sc_index[sc]], self.physics_t_covering_telemetry))
         except ValueError as error:
-            logger.error("Missing orbit information at \n%s", self.physics_t)
+            logger.error("Missing orbit information at \n%s", self.physics_t_covering_telemetry)
             raise ValueError("missing orbit information, use longer orbit file or adjust sampling") from error
 
     def init_gws(self, gws):
@@ -957,18 +969,18 @@ class Instrument:
             + self.integrated_clock_noise_fluctuations
 
         logger.debug("Computing THE with respect to TCB")
-        t = self.physics_et_withinitial
+        t = self.physics_et_covering_telemetry
         self.the_wrt_tcb_withinitial = \
             self.tps_wrt_tcb \
             + self.clock_offsets \
             + self.clock_freqoffsets * (t + self.tps_wrt_tcb) \
             + self.clock_freqlindrifts * (t + self.tps_wrt_tcb)**2 / 2 \
             + self.clock_freqquaddrifts * (t + self.tps_wrt_tcb)**3  / 3 \
-            + self.tps_wrt_tcb * self.clock_noise_fluctuations_withinitial \
-            + self.integrated_clock_noise_fluctuations_withinitial
+            + self.tps_wrt_tcb * self.clock_noise_fluctuations_covering_telemetry \
+            + self.integrated_clock_noise_fluctuations_covering_telemetry
 
         logger.debug("Computing MOC time correlations")
-        physics_to_telemetry = lambda _, x: x[::self.physics_upsampling * self.telemetry_downsampling]
+        physics_to_telemetry = lambda _, x: x[::self.telemetry_to_physics_dt]
         self.moc_time_correlations = self.moc_time_correlation_noises \
             + self.the_wrt_tcb_withinitial.transformed(physics_to_telemetry)
 
@@ -1516,35 +1528,36 @@ class Instrument:
         logger.debug("Generating clock noise fluctuations")
 
         # Include initial telemetry time period
-        self.clock_noise_fluctuations_withinitial = ForEachSC(lambda sc:
+        self.clock_noise_fluctuations_covering_telemetry = ForEachSC(lambda sc:
             noises.clock(
                 self.physics_fs,
-                self.physics_size + self.initial_telemetry_physics_size,
+                self.physics_size_covering_telemetry,
                 self.clock_asds[sc]),
             concurrent=self.concurrent
         )
 
         # Slice to only select physics period
-        self.clock_noise_fluctuations = self.clock_noise_fluctuations_withinitial.transformed(
-            lambda _, x: x if np.isscalar(x) else x[self.initial_telemetry_physics_size:]
-        )
+        self.clock_noise_fluctuations = \
+            self.clock_noise_fluctuations_covering_telemetry.transformed(
+                lambda _, x: x if np.isscalar(x) else x[self.telemetry_physics_slice]
+            )
 
         logger.debug("Integrating clock noise fluctuations")
 
         # Include initial telemetry time period
-        self.integrated_clock_noise_fluctuations_withinitial = \
+        self.integrated_clock_noise_fluctuations_covering_telemetry = \
             ForEachSC(lambda sc:
                 cumulative_trapezoid(np.broadcast_to(
-                    self.clock_noise_fluctuations_withinitial[sc],
-                    self.physics_size + self.initial_telemetry_physics_size),
+                    self.clock_noise_fluctuations_covering_telemetry[sc],
+                    self.physics_size_covering_telemetry),
                 dx=self.physics_dt, initial=0),
                 concurrent=self.concurrent
             )
 
         # Slice to only select physics period
         self.integrated_clock_noise_fluctuations = \
-            self.integrated_clock_noise_fluctuations_withinitial.transformed(
-                lambda _, x: x if np.isscalar(x) else x[self.initial_telemetry_physics_size:]
+            self.integrated_clock_noise_fluctuations_covering_telemetry.transformed(
+                lambda _, x: x if np.isscalar(x) else x[self.telemetry_physics_slice]
             )
 
         ## Modulation noise
@@ -1911,7 +1924,7 @@ class Instrument:
             'git_url', 'version', 'concurrent',
             'dt', 't0', 'size', 'fs', 'duration',
             'initial_telemetry_size', 'telemetry_downsampling', 'telemetry_fs',
-            'telemetry_size', 'telemetry_t0',
+            'telemetry_dt', 'telemetry_size', 'telemetry_t0',
             'physics_upsampling', 'physics_size', 'physics_dt', 'physics_fs',
             'central_freq', 'lock_config', 'lock',
             'fplan_file', 'fplan',
@@ -1981,9 +1994,9 @@ class Instrument:
                 logger.debug("Writing clock noise to '%s'", output)
                 self.clock_noise_offsets.write(hdf5, 'clock_noise_offsets')
                 self.clock_noise_fluctuations.write(hdf5, 'clock_noise_fluctuations')
-                self.clock_noise_fluctuations_withinitial.write(
+                self.clock_noise_fluctuations_covering_telemetry.write(
                     hdf5, 'clock_noise_fluctuations_withinitial')
-                self.integrated_clock_noise_fluctuations_withinitial.write(
+                self.integrated_clock_noise_fluctuations_covering_telemetry.write(
                     hdf5, 'integrated_clock_noise_fluctuations_withinitial')
                 self.integrated_clock_noise_fluctuations.write(
                     hdf5, 'integrated_clock_noise_fluctuations')
@@ -2035,9 +2048,6 @@ class Instrument:
                 logger.debug("Writing THE with respect to TCB to '%s'", output)
                 self.the_wrt_tcb_withinitial.write(hdf5, 'the_wrt_tcb_withinitial')
 
-                logger.debug("Writing MOC time correlations to '%s'", output)
-                self.moc_time_correlations.write(hdf5, 'moc_time_correlations')
-
                 logger.debug("Writing tilt-to-length couplings to '%s'", output)
                 self.local_ttls.write(hdf5, 'local_ttls')
                 self.distant_ttls.write(hdf5, 'distant_ttls')
@@ -2223,6 +2233,9 @@ class Instrument:
             self.rfi_carriers.write(hdf5, 'rfi_carriers')
             self.rfi_usbs.write(hdf5, 'rfi_usbs')
 
+            logger.debug("Writing MOC time correlations to '%s'", output)
+            self.moc_time_correlations.write(hdf5, 'moc_time_correlations')
+
             logger.info("Closing measurement file '%s'", output)
 
     def plot_fluctuations(self, output=None, skip=0):

{lisainstrument-1.3 → lisainstrument-1.4}/lisainstrument/noises.py

@@ -80,7 +80,8 @@ def violet(fs, size, asd):
     Args:
         fs: sampling frequency [Hz]
         size: number of samples [samples]
-        asd: amplitude spectral density [/sqrt(Hz)]"""
+        asd: amplitude spectral density [/sqrt(Hz)]
+    """
     logger.debug("Generating violet noise (fs=%s Hz, size=%s, asd=%s)", fs, size, asd)
     if not asd:
         logger.debug("Vanishing power spectral density, bypassing noise generation")
@@ -89,18 +90,20 @@ def violet(fs, size, asd):
     return np.gradient(white_noise, 1 / fs) / (2 * pi)
 
 
-def pink(fs, size, asd):
+def pink(fs, size, asd, fmin=None):
     """Generate a pink noise in f^(-1/2) in amplitude.
 
     Args:
         fs: sampling frequency [Hz]
         size: number of samples [samples]
-        asd: amplitude spectral density [/sqrt(Hz)]"""
+        asd: amplitude spectral density [/sqrt(Hz)]
+        fmin: saturation frequency (default to fs / size) [Hz]
+    """
     logger.debug("Generating pink noise (fs=%s Hz, size=%s, asd=%s)", fs, size, asd)
     if not asd:
         logger.debug("Vanishing power spectral density, bypassing noise generation")
         return 0
-    generator = pyplnoise.PinkNoise(fs, fs / size, fs / 2)
+    generator = pyplnoise.PinkNoise(fs, fmin or fs / size, fs / 2)
     return asd / sqrt(2) * generator.get_series(size)
 
 
@@ -110,7 +113,8 @@ def red(fs, size, asd):
     Args:
         fs: sampling frequency [Hz]
         size: number of samples [samples]
-        asd: amplitude spectral density [/sqrt(Hz)]"""
+        asd: amplitude spectral density [/sqrt(Hz)]
+    """
     logger.debug("Generating red noise (fs=%s Hz, size=%s, asd=%s)", fs, size, asd)
     if not asd:
         logger.debug("Vanishing power spectral density, bypassing noise generation")
@@ -125,7 +129,8 @@ def infrared(fs, size, asd):
     Args:
         fs: sampling frequency [Hz]
         size: number of samples [samples]
-        asd: amplitude spectral density [/sqrt(Hz)]"""
+        asd: amplitude spectral density [/sqrt(Hz)]
+    """
     logger.debug("Generating infrared noise (fs=%s Hz, size=%s, asd=%s)", fs, size, asd)
     if not asd:
         logger.debug("Vanishing power spectral density, bypassing noise generation")
@@ -173,11 +178,14 @@ def clock(fs, size, asd):
 
         S_q(f) [ffd] = (asd)^2 f^(-1)
 
+    Clock noise saturates below 1E-5 Hz, as the low-frequency part is modeled by
+    deterministing clock drifts.
+
     Args:
         asd: amplitude spectral density [/sqrt(Hz)]
     """
     logger.debug("Generating clock noise fluctuations (fs=%s Hz, size=%s, asd=%s /sqrt(Hz))", fs, size, asd)
-    return pink(fs, size, asd)
+    return pink(fs, size, asd, fmin=1E-5)
 
 
 def modulation(fs, size, asd):

{lisainstrument-1.3 → lisainstrument-1.4}/lisainstrument.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lisainstrument
-Version: 1.3
+Version: 1.4
 Summary: LISA Instrument simulates instrumental noises, propagates laser beams, generates measurements and the on-board processing to deliver simulated telemetry data.
 Home-page: https://gitlab.in2p3.fr/lisa-simulation/instrument
 Author: Jean-Baptiste Bayle

{lisainstrument-1.3 → lisainstrument-1.4}/report.py

@@ -550,7 +550,7 @@ def moc_time_correlation():
 
         plt.figure(figsize=(16, 8))
         for sc in instru.SCS:
-            plot_tseries(instru.physics_t, instru.moc_time_correlations[sc], label=sc)
+            plot_tseries(instru.telemetry_t, instru.moc_time_correlations[sc], label=sc)
         plt.ylabel('Time [s]')
         plt.title('MOC time correlation noise')
         plt.legend()
@@ -559,7 +559,7 @@ def moc_time_correlation():
 
         plt.figure(figsize=(16, 8))
         for sc in instru.SCS:
-            plot_asd(instru.physics_t, instru.moc_time_correlations[sc], label=sc)
+            plot_asd(instru.telemetry_t, instru.moc_time_correlations[sc], label=sc)
         plt.ylabel('ASD [s/sqrt(Hz)]')
         plt.title('MOC time correlation noise')
         plt.legend()
@@ -742,12 +742,12 @@ def plot_measurements(instru, pdf):
     pdf.savefig()
     plt.close()
 
-    # Time-domain TCB timer deviations
+    # Time-domain MOC time correlations
     plt.figure(figsize=(16, 8))
     for sc in instru.SCS:
-        plot_tseries(instru.t, instru.tcb_timer_deviations[sc], skip=0, label=sc)
-    plt.ylabel('Timer deviation [s]')
-    plt.title('Timer deviations from TCB')
+        plot_tseries(instru.telemetry_t, instru.moc_time_correlations[sc], skip=0, label=sc)
+    plt.ylabel('Deviation [s]')
+    plt.title('MOC time correlations')
     plt.legend()
     pdf.savefig()
     plt.close()