sgn-drift 0.1.0__py3-none-any.whl

sgn_drift-0.1.0.dist-info/METADATA

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: sgn-drift
+Version: 0.1.0
+Summary: PSD Drift Data Quality Extensions for the SGN Framework
+Author-email: James Kennington <jmk7376@psu.edu>, Zach Yarbrough <jmk7376@psu.edu>, Joshua Black <jmk7376@psu.edu>
+License-Expression: MPL-2.0
+Project-URL: Homepage, https://git.ligo.org/james.kennington/sgn-drift
+Project-URL: Documentation, https://docs.ligo.org/james.kennington/sgn-drift
+Project-URL: Issues, https://git.ligo.org/james.kennington/sgn-drift/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: gwpy
+Requires-Dist: h5py
+Requires-Dist: igwn-ligolw
+Requires-Dist: igwn-segments
+Requires-Dist: lalsuite>=7.26
+Requires-Dist: scipy<1.17
+Requires-Dist: sgn>=0.4
+Requires-Dist: sgn-ts>=0.4
+Requires-Dist: sgn-ligo
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-freezer; extra == "test"
+Requires-Dist: pytest-markdown-docs; extra == "test"
+Provides-Extra: docs
+Requires-Dist: mkdocs; extra == "docs"
+Requires-Dist: mkdocstrings; extra == "docs"
+Requires-Dist: mkdocstrings-python; extra == "docs"
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: pymdown-extensions; extra == "docs"
+Provides-Extra: lint
+Requires-Dist: black; extra == "lint"
+Requires-Dist: flake8; extra == "lint"
+Requires-Dist: flake8-bandit; extra == "lint"
+Requires-Dist: flake8-black; extra == "lint"
+Requires-Dist: flake8-bugbear; extra == "lint"
+Requires-Dist: flake8-future-annotations; extra == "lint"
+Requires-Dist: flake8-isort; extra == "lint"
+Requires-Dist: flake8-logging-format; extra == "lint"
+Requires-Dist: flake8-pyproject; extra == "lint"
+Requires-Dist: isort; extra == "lint"
+Requires-Dist: mypy; extra == "lint"
+Requires-Dist: mypy-extensions; extra == "lint"
+Provides-Extra: dev
+Requires-Dist: sgn-drift[docs]; extra == "dev"
+Requires-Dist: sgn-drift[lint]; extra == "dev"
+Requires-Dist: sgn-drift[test]; extra == "dev"
+
+# SGN-Drift
+
+**Geometric Spectral Diagnostics for Gravitational Wave Detectors.**
+
+`sgn-drift` is an extension to the [SGN](https://git.ligo.org/greg/sgn) framework designed to quantify the stability of
+the detector noise floor using Information Geometry.
+
+## Installation
+
+```bash
+pip install sgn-drift
+```
+
+## Example Usage
+
+### Command Line
+
+```bash
+sgn-drift-estimate --detector L1 --start 1263085000 --end 1263089096 --output drift_L1.csv --bands "low:10:50,mid:50:300"
+```
+
+### Python API
+
+```python
+from sgndrift.bin.estimate_drift import estimate_drift
+
+bands = {
+    "v_low": (10, 50),
+    "v_mid": (50, 300)
+}
+
+estimate_drift(
+    start=1262600000,
+    end=1262604096,
+    detector="L1",
+    output_drift="analysis.csv",
+    bands=bands,
+    verbose=True
+)
+```

sgn_drift-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+sgndrift/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sgndrift/_version.py,sha256=5jwwVncvCiTnhOedfkzzxmxsggwmTBORdFL_4wq0ZeY,704
+sgndrift/bin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sgndrift/bin/estimate_drift.py,sha256=qVp-PacdNRUAEWOrHlvzP-whMRCB_zhteZZDE1Ld_9g,8822
+sgndrift/bin/plot_drift.py,sha256=EYIhluD0asFWoYmLfpu2vsmU5TDHtjmPjCNuY2tvYLI,4746
+sgndrift/bin/plot_drift_comparison.py,sha256=0VknMCS1-szBk5trTARUYvYWEXrid-FnyOf0yM1_lnw,6355
+sgndrift/bin/plot_drift_super.py,sha256=W-OgqfL8_UFDKxyNhNe3ahXteQllu3oHPyidYcJd6Kc,7934
+sgndrift/bin/plot_drift_super_comp.py,sha256=lcHqw4w0xKfTW1DX5pAVOGM3mAlxfc9Xsz12fjlQlTQ,12222
+sgndrift/bin/plot_drift_time.py,sha256=EdLkzUe4Exsi6OJDQYLmY8PH1wSHLoRv5q3ZwKyDS8g,5929
+sgndrift/psd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sgndrift/psd/drift.py,sha256=3v0UlLc3yQLSJwLHJXQo5Hy1wRM7wV8hkMiiSGtpY8o,2413
+sgndrift/psd/estimators.py,sha256=UdI7SaUOEiQeXbBzWNfY3C0w0tS8NWMzJHzULJW30Ck,4280
+sgndrift/sinks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sgndrift/sinks/drift_sink.py,sha256=PHspvH9LupSmjLWjavvsk2a3TfU5jYXUMN0TV9lTdjs,5058
+sgndrift/transforms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sgndrift/transforms/drift.py,sha256=bbjmrW1q8awkb-oBpeWo94M-pGxHYN88iOKrkbQHL2A,4727
+sgndrift/transforms/psd.py,sha256=6LABGSUpbOE4nKzHEWybHT3ronnuUgLuV5tI46txn34,5427
+sgn_drift-0.1.0.dist-info/METADATA,sha256=-5mp3zaZIktyCf2Ap6ljRQXEGXwd0QMIWaUFqQhtoRw,2828
+sgn_drift-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+sgn_drift-0.1.0.dist-info/entry_points.txt,sha256=emRR36dQDFCkTxwuWEMnN-TeNNTrnlJ-HFeJEw_37vY,362
+sgn_drift-0.1.0.dist-info/top_level.txt,sha256=xmogf6bL8sl_VbrQ6pPMXLdY967VtYYUtFzIg_U3Rq4,9
+sgn_drift-0.1.0.dist-info/RECORD,,

sgn_drift-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sgn_drift-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,7 @@
+[console_scripts]
+sgn-drift-estimate = sgndrift.bin.estimate_drift:main
+sgn-drift-plot = sgndrift.bin.plot_drift:main
+sgn-drift-plot-comp = sgndrift.bin.plot_drift_comparison:main
+sgn-drift-plot-super = sgndrift.bin.plot_drift_super:main
+sgn-drift-plot-super-comp = sgndrift.bin.plot_drift_super_comp:main
+sgn-drift-plot-time = sgndrift.bin.plot_drift_time:main

sgn_drift-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sgndrift

sgndrift/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

sgndrift/bin/estimate_drift.py

@@ -0,0 +1,278 @@
+"""
+Drift Estimation Application Logic (Robust & Modular).
+
+This script orchestrates the SGN pipeline to estimate Geometric Spectral Drift.
+It includes logic to:
+1. Identify valid science segments (handling both Internal and Public data).
+2. Construct the pipeline dynamically for each segment.
+3. Handle data gaps gracefully without crashing the entire job.
+"""
+
+import os
+import argparse
+from typing import Optional, Dict, Tuple, List
+
+# GW Imports
+from gwpy.segments import DataQualityFlag
+
+try:
+    from gwosc.timeline import get_segments as get_gwosc_segments
+except ImportError:
+    get_gwosc_segments = None
+
+# SGN Imports
+from sgn.apps import Pipeline
+from sgn.base import SourceElement
+from sgnligo.sources.gwosc import GWOSCSource
+
+from sgndrift.transforms.psd import RecursivePSD
+from sgndrift.transforms.drift import FisherVelocity
+from sgndrift.sinks.drift_sink import DriftCSVSink
+
+
+def get_science_segments(
+    detector: str, start: float, end: float, verbose: bool = False
+) -> List[Tuple[float, float]]:
+    """
+    Queries valid science segments.
+    1. Tries internal LIGO DQSegDB (requires grid cert).
+    2. Falls back to Public GWOSC Timeline (open data).
+    3. If both fail/empty, returns full window (Force Mode).
+    """
+    # Method A: Internal LIGO Database
+    flag_name = f"{detector}:DMT-ANALYSIS_READY:1"
+    if verbose:
+        print(f"Querying segments for {flag_name} [{start} ... {end}]")
+
+    try:
+        flags = DataQualityFlag.query(flag_name, start, end)
+        if not flags.active:
+            raise ValueError("No segments found in internal DB.")
+        return [(float(seg.start), float(seg.end)) for seg in flags.active]
+
+    except Exception as e:
+        if verbose:
+            print(f"Internal segment query failed/empty ({e}). Checking GWOSC...")
+
+        segments = []
+        if get_gwosc_segments:
+            try:
+                # Method B: Public GWOSC
+                segments = get_gwosc_segments(detector, int(start), int(end))
+            except Exception as e2:
+                print(f"Warning: GWOSC segment query error: {e2}")
+        else:
+            print("Warning: 'gwosc' library not installed.")
+
+        if segments:
+            if verbose:
+                print(f"Found {len(segments)} valid segments in GWOSC.")
+            return segments
+        else:
+            print(f"Warning: No known science segments found for {detector}.")
+            print("Defaulting to full window (Pipeline will skip if data is missing).")
+            return [(start, end)]
+
+
+def build_pipeline(
+    start: float,
+    end: float,
+    detector: str,
+    output_drift: str,
+    alpha: float = 0.1,
+    fft_length: float = 1.0,
+    overlap: float = 0.5,
+    sample_rate: int = 4096,
+    bands: Optional[Dict[str, Tuple[float, float]]] = None,
+    source_element: Optional[SourceElement] = None,
+    verbose: bool = False,
+) -> Pipeline:
+    """
+    Constructs the SGN pipeline for Drift Estimation.
+    """
+    # 1. Setup Source (if not provided)
+    if source_element is None:
+        source_name = f"gwosc_{detector}_{int(start)}"
+        source_element = GWOSCSource(
+            name=source_name,
+            start=start,
+            end=end,
+            detectors=[detector],
+            sample_rate=sample_rate,
+            cache_data=True,
+            verbose=verbose,
+        )
+        source_pad_name = detector
+    else:
+        source_pad_name = detector
+
+    # 2. Pipeline Container
+    pipe = Pipeline()
+
+    # 3. PSD Estimator
+    psd_est = RecursivePSD(
+        name=f"psd_{detector}_{int(start)}",
+        sink_pad_names=("in",),
+        source_pad_names=("out",),
+        fft_length=fft_length,
+        overlap=overlap,
+        sample_rate=sample_rate,
+        alpha=alpha,
+    )
+
+    # 4. Fisher Velocity
+    fisher = FisherVelocity(
+        name=f"fisher_{detector}_{int(start)}",
+        sink_pad_names=("in",),
+        source_pad_names=("out",),
+        bands=bands or {},
+    )
+    fisher.configure()
+
+    # 5. Sink (Appends to CSV)
+    sink = DriftCSVSink(
+        name=f"sink_{detector}_{int(start)}",
+        sink_pad_names=("in",),
+        filename=output_drift,
+    )
+    sink.configure()
+
+    # 6. Build & Link
+    pipe.insert(source_element, psd_est, fisher, sink)
+
+    pipe.link({psd_est.snks["in"]: source_element.srcs[source_pad_name]})
+    pipe.link({fisher.snks["in"]: psd_est.srcs["out"]})
+    pipe.link({sink.snks["in"]: fisher.srcs["out"]})
+
+    return pipe
+
+
+def estimate_drift(
+    start: float,
+    end: float,
+    detector: str = "H1",
+    output_drift: str = "drift.csv",
+    source_element: Optional[SourceElement] = None,
+    method: str = "recursive",
+    alpha: float = 0.1,
+    fft_length: float = 1.0,
+    overlap: float = 0.5,
+    sample_rate: float = 16384.0,
+    bands: Optional[Dict[str, Tuple[float, float]]] = None,
+    force: bool = False,
+    verbose: bool = False,
+):
+    """
+    High-level Orchestrator.
+    Handles Gap Checks -> Segment Loops -> Pipeline Build -> Pipeline Run.
+    """
+    # 1. Clear output file (if starting fresh CLI run)
+    if source_element is None and os.path.exists(output_drift):
+        if verbose:
+            print(f"Clearing previous output: {output_drift}")
+        os.remove(output_drift)
+
+    # 2. Determine Segments
+    segments = []
+    if force:
+        if verbose:
+            print("Force Mode: Skipping segment check. Using full window.")
+        segments = [(start, end)]
+    elif source_element is None:
+        segments = get_science_segments(detector, start, end, verbose)
+    else:
+        # If custom source provided, trust the user
+        segments = [(start, end)]
+
+    if not segments:
+        print("No valid segments found. Use --force to attempt anyway.")
+        return
+
+    # 3. Process Each Segment
+    for seg_start, seg_end in segments:
+        duration = seg_end - seg_start
+        # Skip tiny segments
+        if duration < (fft_length * 8):
+            continue
+
+        if verbose:
+            print(f"Processing segment: {seg_start:.1f} - {seg_end:.1f}")
+
+        try:
+            # A. BUILD
+            pipe = build_pipeline(
+                start=seg_start,
+                end=seg_end,
+                detector=detector,
+                output_drift=output_drift,
+                alpha=alpha,
+                fft_length=fft_length,
+                overlap=overlap,
+                sample_rate=int(sample_rate),
+                bands=bands,
+                source_element=source_element if source_element else None,
+                verbose=verbose,
+            )
+
+            # B. RUN
+            pipe.run()
+
+        except RuntimeError as e:
+            # Handle GWOSC "No Data" errors gracefully
+            err_str = str(e)
+            if "Cannot find a GWOSC dataset" in err_str or "No data found" in err_str:
+                print(f"[Gap] No data available for {seg_start}-{seg_end}. Skipping.")
+            else:
+                print(f"[Error] Pipeline Runtime Error: {e}")
+            continue
+
+        except Exception as e:
+            print(f"[Error] Critical failure in segment {seg_start}-{seg_end}: {e}")
+            continue
+
+    if verbose:
+        print(f"Analysis complete. Results in {output_drift}")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Estimate Geometric Spectral Drift.")
+    parser.add_argument("--detector", type=str, default="H1", help="Detector ID")
+    parser.add_argument("--start", type=float, required=True, help="GPS Start")
+    parser.add_argument("--end", type=float, required=True, help="GPS End")
+    parser.add_argument("--output", type=str, default="drift.csv", help="Output CSV")
+    parser.add_argument("--alpha", type=float, default=0.1, help="Filter decay")
+    parser.add_argument("--fft-length", type=float, default=1.0, help="FFT sec")
+    parser.add_argument("--sample-rate", type=float, default=4096.0, help="Hz")
+    parser.add_argument("--bands", type=str, default=None, help="name:min:max,...")
+    parser.add_argument("--force", action="store_true", help="Ignore segment checks")
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose")
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    # Parse band string
+    bands_dict = {}
+    if args.bands:
+        for item in args.bands.split(","):
+            parts = item.split(":")
+            if len(parts) == 3:
+                bands_dict[parts[0]] = (float(parts[1]), float(parts[2]))
+
+    estimate_drift(
+        start=args.start,
+        end=args.end,
+        detector=args.detector,
+        output_drift=args.output,
+        alpha=args.alpha,
+        fft_length=args.fft_length,
+        sample_rate=args.sample_rate,
+        bands=bands_dict if bands_dict else None,
+        force=args.force,
+        verbose=args.verbose,
+    )
+
+
+if __name__ == "__main__":
+    main()

sgndrift/bin/plot_drift.py

@@ -0,0 +1,177 @@
+"""
+Drift Visualization Tool.
+
+Generates 2D scatter plots (Phase Space projections) of Geometric Drift data.
+
+Features:
+- Scatter plot of Band X vs Band Y.
+- Coloring:
+    - Time: Linear scale (Seconds from start).
+    - Bands: Explicit Log10 scale (Log10 of magnitude) for better contrast.
+"""
+
+import argparse
+import sys
+from typing import Optional
+
+import matplotlib.pyplot as plt
+import pandas as pd
+import numpy as np
+
+
+def load_data(
+    filepath: str, start: Optional[float] = None, end: Optional[float] = None
+) -> pd.DataFrame:
+    """Loads drift data from CSV and applies time filtering."""
+    try:
+        df = pd.read_csv(filepath)
+    except FileNotFoundError:
+        print(f"Error: File not found at {filepath}")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error reading CSV: {e}")
+        sys.exit(1)
+
+    df.columns = df.columns.str.strip()
+
+    if "time" not in df.columns:
+        print("Error: CSV must contain a 'time' column.")
+        sys.exit(1)
+
+    if start is not None:
+        df = df[df["time"] >= start]
+    if end is not None:
+        df = df[df["time"] <= end]
+
+    if df.empty:
+        print("Error: No data found in the specified time range.")
+        sys.exit(1)
+
+    return df
+
+
+def make_plot(
+    df: pd.DataFrame,
+    x_col: str,
+    y_col: str,
+    output_path: str,
+    color_col: Optional[str] = None,
+    log_scale: bool = True,
+    title: Optional[str] = None,
+):
+    """Generates and saves the scatter plot."""
+    if x_col not in df.columns or y_col not in df.columns:
+        print(f"Error: Columns '{x_col}' or '{y_col}' not found.")
+        print(f"Available: {list(df.columns)}")
+        sys.exit(1)
+
+    x_data = df[x_col]
+    y_data = df[y_col]
+
+    # --- Coloring Logic ---
+    c_data = None
+    c_label = None
+    cmap = None
+
+    if color_col:
+        if color_col.lower() == "time":
+            # Linear Scale for Time
+            c_data = df["time"] - df["time"].min()
+            c_label = "Time (seconds from start)"
+            cmap = "turbo"
+        elif color_col in df.columns:
+            # Explicit Log10 Transform for Bands
+            raw_data = df[color_col].copy()
+
+            # Mask zeros/negative values to avoid -inf
+            raw_data[raw_data <= 0] = np.nan
+            c_data = np.log10(raw_data)
+
+            c_label = f"Log10({color_col} Magnitude)"
+            cmap = "plasma"  # High contrast
+        else:
+            print(f"Warning: Color column '{color_col}' not found. Using solid color.")
+
+    # --- Plotting ---
+    plt.figure(figsize=(10, 8))
+
+    sc = plt.scatter(
+        x_data,
+        y_data,
+        c=c_data if c_data is not None else "tab:blue",
+        cmap=cmap,
+        s=15,
+        alpha=0.6,
+        edgecolors="none",
+    )
+
+    if c_data is not None:
+        plt.colorbar(sc, label=c_label)
+
+    plt.xlabel(f"{x_col} Drift Velocity")
+    plt.ylabel(f"{y_col} Drift Velocity")
+
+    if log_scale:
+        plt.xscale("log")
+        plt.yscale("log")
+        plt.grid(True, which="both", alpha=0.2)
+    else:
+        plt.grid(True, alpha=0.3)
+
+    if title:
+        plt.title(title)
+    else:
+        plt.title(f"Geometric Drift: {x_col} vs {y_col}")
+
+    try:
+        plt.savefig(output_path, dpi=150)
+        print(f"Plot saved to: {output_path}")
+    except Exception as e:
+        print(f"Error saving plot: {e}")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Visualize Geometric Drift Phase Space."
+    )
+    parser.add_argument("input_file", type=str, help="Path to input CSV file")
+    parser.add_argument("--x-band", type=str, default="v_low", help="X-axis column")
+    parser.add_argument("--y-band", type=str, default="v_mid", help="Y-axis column")
+    parser.add_argument(
+        "-o", "--output", type=str, default="drift_plot.png", help="Output filename"
+    )
+
+    parser.add_argument("--start", type=float, default=None, help="Start GPS")
+    parser.add_argument("--end", type=float, default=None, help="End GPS")
+
+    parser.add_argument(
+        "--color-by",
+        type=str,
+        default=None,
+        help="Column to color by (e.g. 'time', 'v_high'). Default: No color.",
+    )
+
+    parser.add_argument(
+        "--linear", action="store_true", help="Use linear scale (Default: Log)"
+    )
+    parser.add_argument("--title", type=str, default=None, help="Custom plot title")
+
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    df = load_data(args.input_file, start=args.start, end=args.end)
+    make_plot(
+        df,
+        x_col=args.x_band,
+        y_col=args.y_band,
+        output_path=args.output,
+        color_col=args.color_by,
+        log_scale=not args.linear,
+        title=args.title,
+    )
+
+
+if __name__ == "__main__":
+    main()