core.qnm

qnm

LIGO/Virgo quasi-normal mode predictions from the Choptyuk formula.

The spinor corrections predict a frequency shift for black hole QNMs

delta_f = f_QNM / 14 * (a/M)^2

where a/M is the dimensionless spin parameter. This shift is compared against detector sensitivity for current and future gravitational wave observatories.

QNMPredictor

QNMPredictor(events: list[BHEvent] | None = None, detectors: list[dict] | None = None, G: float = 6.674e-11, c: float = 300000000.0, M_sun: float = 1.989e+30)

QNM frequency shift predictions for gravitational wave events.

Attributes:

Name	Type	Description
events		List of BHEvent objects.
detectors		List of future detector specifications.
G		Gravitational constant.
c		Speed of light.
M_sun		Solar mass in kg.

Source code in src/core/qnm.py

def __init__(self, events: list[BHEvent] | None = None,
             detectors: list[dict] | None = None,
             G: float = 6.674e-11, c: float = 3e8,
             M_sun: float = 1.989e30):
    self.events = events or DEFAULT_EVENTS
    self.detectors = detectors or DEFAULT_DETECTORS
    self.G = G
    self.c = c
    self.M_sun = M_sun
    # Enhanced: effective phase from spinorial braking
    self._delta_eff = (np.pi / 7)**5 / 22
    logger.info(f"QNM predictor initialized with {len(self.events)} events")

qnm_correction property

qnm_correction: float

Enhanced QNM correction: δ_eff / π².

Derived from the spinorial braking correction where δ_eff = (π/7)^5 / 22 ≈ 1/1200.

qnm_factor property

qnm_factor: float

Enhanced QNM factor: 1 - δ_eff/π² ≈ 0.999916.

This factor multiplicatively corrects QNM frequencies for the spinorial braking effect.

corrected_frequency

corrected_frequency(omega: float) -> float

Apply enhanced QNM correction to a frequency.

Parameters:

Name	Type	Description	Default
omega	float	Uncorrected QNM frequency.	required

Returns:

Type	Description
float	Corrected frequency: ω · (1 - δ_eff/π²).

Source code in src/core/qnm.py

def corrected_frequency(self, omega: float) -> float:
    """Apply enhanced QNM correction to a frequency.

    Args:
        omega: Uncorrected QNM frequency.

    Returns:
        Corrected frequency: ω · (1 - δ_eff/π²).
    """
    return omega * self.qnm_factor

predict_shift

predict_shift(event: BHEvent, scaling: float = 14.0) -> dict

Predict QNM frequency shift for a single event.

Parameters:

Name	Type	Description	Default
event	BHEvent	BHEvent with observed parameters.	required
scaling	float	Scaling factor (default 14 from Choptyuk formula).	14.0

Returns:

Type	Description
dict	Dict with event name, predicted shift, and SNR.

Source code in src/core/qnm.py

def predict_shift(self, event: BHEvent, scaling: float = 14.0) -> dict:
    """Predict QNM frequency shift for a single event.

    Args:
        event: BHEvent with observed parameters.
        scaling: Scaling factor (default 14 from Choptyuk formula).

    Returns:
        Dict with event name, predicted shift, and SNR.
    """
    delta_f = event.f_qnm / scaling * event.spin**2
    snr = delta_f / event.sigma
    result = {
        "name": event.name,
        "mass_solar": event.mass_solar,
        "spin": event.spin,
        "f_qnm": event.f_qnm,
        "delta_f": delta_f,
        "sigma": event.sigma,
        "snr": snr,
    }
    logger.info(f"QNM {event.name}: Δf={delta_f:.2f} Hz, SNR={snr:.2f}")
    return result

predict_all

predict_all(scaling: float = 14.0) -> list[dict]

Predict QNM shifts for all events.

Returns:

Type	Description
list[dict]	List of prediction dicts.

Source code in src/core/qnm.py

def predict_all(self, scaling: float = 14.0) -> list[dict]:
    """Predict QNM shifts for all events.

    Returns:
        List of prediction dicts.
    """
    return [self.predict_shift(e, scaling) for e in self.events]

detectability

detectability(event_name: str = 'GW150914', scaling: float = 14.0) -> list[dict]

Compute detectability for a given event across all future detectors.

Parameters:

Name	Type	Description	Default
event_name	str	Which event to analyze.	'GW150914'
scaling	float	QNM scaling factor.	14.0

Returns:

Type	Description
list[dict]	List of dicts with detector name, sigma, and SNR.

Source code in src/core/qnm.py

def detectability(self, event_name: str = "GW150914",
                   scaling: float = 14.0) -> list[dict]:
    """Compute detectability for a given event across all future detectors.

    Args:
        event_name: Which event to analyze.
        scaling: QNM scaling factor.

    Returns:
        List of dicts with detector name, sigma, and SNR.
    """
    event = next((e for e in self.events if e.name == event_name), self.events[0])
    delta_f = event.f_qnm / scaling * event.spin**2

    results = []
    for det in self.detectors:
        snr = delta_f / det["sigma_hz"]
        results.append({
            "detector": det["name"],
            "sigma_hz": det["sigma_hz"],
            "snr": snr,
            "detectable": snr >= 1.0,
        })
        logger.info(f"{det['name']}: σ={det['sigma_hz']} Hz, SNR={snr:.2f}")

    return results

as_dict

as_dict() -> dict

Serialize QNM predictor state.

Source code in src/core/qnm.py

def as_dict(self) -> dict:
    """Serialize QNM predictor state."""
    return {
        "n_events": len(self.events),
        "n_detectors": len(self.detectors),
        "events": [{"name": e.name, "M": e.mass_solar, "a": e.spin,
                     "f": e.f_qnm, "sigma": e.sigma} for e in self.events],
    }