18209569030

Committed 03 Oct 2025 12:42AM UTC coverage: 80.878% (+1.6%) from 79.246%

Build # 18209569030

Build Type

push

github

Committed by

avivajpeyi

Commit Message

fix logger

Run Details

549 of 654 branches covered (83.94%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

469 existing lines in 17 files now uncovered.

3799 of 4722 relevant lines covered (80.45%)

1.61 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.5

/src/log_psplines/example_datasets/lvk_data.py

import matplotlib.pyplot as plt
import numpy as np
from gwosc import datasets as gwosc_datasets
from gwpy.frequencyseries import FrequencySeries
from gwpy.timeseries import TimeSeries

from ..logger import logger
from .utils import PSD_FILE


class LVKData:
    def __init__(self, strain: np.ndarray, psd: np.ndarray, freqs: np.ndarray):
        self.strain = strain
        self.psd = psd
        self.freqs = freqs

    @classmethod
    def from_simulation(cls, duration: int = 4, fs: int = 1024) -> "LVKData":
        import numpy as np
        import pycbc.noise
        from pycbc.types import FrequencySeries as PycbcFrequencySeries

        # --- Parse into numpy arrays ---
        data = np.loadtxt(PSD_FILE)
        freq, asd = data[:, 0], data[:, 1]

        # --- Convert ASD → PSD ---
        psd_vals = asd**2

        # --- Wrap into PyCBC FrequencySeries ---
        delta_f = freq[1] - freq[0]
        psd = PycbcFrequencySeries(psd_vals, delta_f=delta_f, copy=True)

        # ---- simulate noise timeseries -----
        delta_t = 1.0 / fs
        tsamples = int(duration / delta_t)
        ts = pycbc.noise.noise_from_psd(tsamples, delta_t, psd, seed=127)
        strain = ts.numpy()
        return cls(strain=strain, psd=psd_vals, freqs=freq)

    @classmethod
    def download_data(
        cls,
        detector: str = "H1",
        gps_start: int = 1126259462,
        duration: int = 1024,
        fmin: float = 20,
        fmax: float = 512,
    ) -> "LVKData":
        gps_end = gps_start + duration
        logger.info(f"Downloading {detector} data [{gps_start} - {gps_end}]")
        strain = TimeSeries.fetch_open_data(detector, gps_start, gps_end)
        strain = (strain - strain.mean()) / strain.std()
        psd = strain.psd()
        psd = psd.crop(fmin, fmax)
        return cls(
            strain=strain.value, psd=psd.value, freqs=psd.frequencies.value
        )

    @classmethod
    def from_event(
        cls,
        event_name: str,
        detector: str = "H1",
        event_duration: int = 4,
        psd_duration: int = 4,
        fmin: float = 20,
        fmax: float = 2048,
    ) -> "LVKData":
        try:
            event_gps = gwosc_datasets.event_gps(event_name)
        except ValueError:
            avail_events = gwosc_datasets.find_datasets()
            raise ValueError(
                f"Event {event_name} not found in GWOSC datasets. Avail datasets: {avail_events}"
            )

        gps_start = event_gps - event_duration - psd_duration
        return cls.download_data(
            detector=detector,
            gps_start=gps_start,
            duration=psd_duration,
            fmin=fmin,
            fmax=fmax,
        )

    def plot_psd(self, fname: str = None) -> None:
        freq = FrequencySeries(self.psd, frequencies=self.freqs)
        fig, ax = plt.subplots()
        ax.loglog(freq, color="black")
        ax.set_xlabel("Frequency [Hz]")
        ax.set_ylabel("Power/Frequency [1/Hz]")
        ax.set_title("Power Spectral Density")
        if fname:
            plt.savefig(fname, bbox_inches="tight")
        return fig, ax

1	import matplotlib.pyplot as plt	2✔
2	import numpy as np	2✔
3	from gwosc import datasets as gwosc_datasets	2✔
4	from gwpy.frequencyseries import FrequencySeries	2✔
5	from gwpy.timeseries import TimeSeries	2✔
6
7	from ..logger import logger	2✔
8	from .utils import PSD_FILE	2✔
9
10
11	class LVKData:	2✔
12	def __init__(self, strain: np.ndarray, psd: np.ndarray, freqs: np.ndarray):	2✔
13	self.strain = strain	2✔
14	self.psd = psd	2✔
15	self.freqs = freqs	2✔
16
17	@classmethod	2✔
18	def from_simulation(cls, duration: int = 4, fs: int = 1024) -> "LVKData":	2✔
19	import numpy as np	2✔
20	import pycbc.noise	2✔
21	from pycbc.types import FrequencySeries as PycbcFrequencySeries	2✔
22
23	# --- Parse into numpy arrays ---
24	data = np.loadtxt(PSD_FILE)	2✔
25	freq, asd = data[:, 0], data[:, 1]	2✔
26
27	# --- Convert ASD → PSD ---
28	psd_vals = asd**2	2✔
29
30	# --- Wrap into PyCBC FrequencySeries ---
31	delta_f = freq[1] - freq[0]	2✔
32	psd = PycbcFrequencySeries(psd_vals, delta_f=delta_f, copy=True)	2✔
33
34	# ---- simulate noise timeseries -----
35	delta_t = 1.0 / fs	2✔
36	tsamples = int(duration / delta_t)	2✔
37	ts = pycbc.noise.noise_from_psd(tsamples, delta_t, psd, seed=127)	2✔
38	strain = ts.numpy()	2✔
39	return cls(strain=strain, psd=psd_vals, freqs=freq)	2✔
40
41	@classmethod	2✔
42	def download_data(	2✔
43	cls,
44	detector: str = "H1",
45	gps_start: int = 1126259462,
46	duration: int = 1024,
47	fmin: float = 20,
48	fmax: float = 512,
49	) -> "LVKData":
50	gps_end = gps_start + duration	2✔
51	logger.info(f"Downloading {detector} data [{gps_start} - {gps_end}]")	2✔
52	strain = TimeSeries.fetch_open_data(detector, gps_start, gps_end)	2✔
53	strain = (strain - strain.mean()) / strain.std()	2✔
54	psd = strain.psd()	2✔
55	psd = psd.crop(fmin, fmax)	2✔
56	return cls(	2✔
57	strain=strain.value, psd=psd.value, freqs=psd.frequencies.value
58	)
59
60	@classmethod	2✔
61	def from_event(	2✔
62	cls,
63	event_name: str,
64	detector: str = "H1",
65	event_duration: int = 4,
66	psd_duration: int = 4,
67	fmin: float = 20,
68	fmax: float = 2048,
69	) -> "LVKData":
70	try:	×
71	event_gps = gwosc_datasets.event_gps(event_name)	×
72	except ValueError:	×
73	avail_events = gwosc_datasets.find_datasets()	×
UNCOV 74	raise ValueError(	×
75	f"Event {event_name} not found in GWOSC datasets. Avail datasets: {avail_events}"
76	)
77
78	gps_start = event_gps - event_duration - psd_duration	×
UNCOV 79	return cls.download_data(	×
80	detector=detector,
81	gps_start=gps_start,
82	duration=psd_duration,
83	fmin=fmin,
84	fmax=fmax,
85	)
86
87	def plot_psd(self, fname: str = None) -> None:	2✔
88	freq = FrequencySeries(self.psd, frequencies=self.freqs)	2✔
89	fig, ax = plt.subplots()	2✔
90	ax.loglog(freq, color="black")	2✔
91	ax.set_xlabel("Frequency [Hz]")	2✔
92	ax.set_ylabel("Power/Frequency [1/Hz]")	2✔
93	ax.set_title("Power Spectral Density")	2✔
94	if fname:	2✔
95	plt.savefig(fname, bbox_inches="tight")	2✔
96	return fig, ax	2✔

nz-gravity / LogPSplinePSD / 18209569030

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous