ml4gw 0.4.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

ml4gw/spectral.py

@@ -12,14 +12,18 @@ https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.csd.html
 from typing import Optional, Union
 
 import torch
-from torchtyping import TensorType
+from jaxtyping import Float
+from torch import Tensor
 
-from ml4gw import types
+from ml4gw.types import (
+    FrequencySeries1to3d,
+    PSDTensor,
+    TimeSeries1to3d,
+    WaveformTensor,
+)
 
-time = None
 
-
-def median(x, axis):
+def median(x: Float[Tensor, "... size"], axis: int) -> Float[Tensor, "..."]:
     """
     Implements a median calculation that matches numpy's
     behavior for an even number of elements and includes
@@ -33,7 +37,7 @@ def median(x, axis):
 
 
 def _validate_shapes(
-    x: torch.Tensor, nperseg: int, y: Optional[torch.Tensor] = None
+    x: Tensor, nperseg: int, y: Optional[Tensor] = None
 ) -> None:
     if x.shape[-1] < nperseg:
         raise ValueError(
@@ -83,14 +87,14 @@ def _validate_shapes(
 
 
 def fast_spectral_density(
-    x: torch.Tensor,
+    x: TimeSeries1to3d,
     nperseg: int,
     nstride: int,
-    window: torch.Tensor,
-    scale: torch.Tensor,
+    window: Float[Tensor, " {nperseg//2+1}"],
+    scale: float,
     average: str = "median",
-    y: Optional[torch.Tensor] = None,
-) -> torch.Tensor:
+    y: Optional[TimeSeries1to3d] = None,
+) -> FrequencySeries1to3d:
     """
     Compute the power spectral density of a multichannel
     timeseries or a batch of multichannel timeseries, or
@@ -107,9 +111,9 @@ def fast_spectral_density(
             The timeseries tensor whose power spectral density
             to compute, or for cross spectral density the
             timeseries whose fft will be conjugated. Can have
-            shape either
-            `(batch_size, num_channels, length * sample_rate)`
-            or `(num_channels, length * sample_rate)`.
+            shape `(batch_size, num_channels, length * sample_rate)`,
+            `(num_channels, length * sample_rate)`, or
+            `(length * sample_rate)`.
         nperseg:
             Number of samples included in each FFT window
         nstride:
@@ -150,7 +154,7 @@ def fast_spectral_density(
             channel in `x` across _all_ of `x`'s batch elements.
     Returns:
         Tensor of power spectral densities of `x` or its cross spectral
-            density with the timeseries in `y`.
+        density with the timeseries in `y`.
     """
 
     _validate_shapes(x, nperseg, y)
@@ -240,17 +244,16 @@ def fast_spectral_density(
 
 
 def spectral_density(
-    x: torch.Tensor,
+    x: TimeSeries1to3d,
     nperseg: int,
     nstride: int,
-    window: torch.Tensor,
-    scale: torch.Tensor,
+    window: Float[Tensor, " {nperseg//2+1}"],
+    scale: float,
     average: str = "median",
-) -> torch.Tensor:
+) -> FrequencySeries1to3d:
     """
     Compute the power spectral density of a multichannel
-    timeseries or a batch of multichannel timeseries, or
-    the cross power spectral density of two such timeseries.
+    timeseries or a batch of multichannel timeseries.
     This implementation is exact for all frequency bins, but
     slower than the fast implementation.
 
@@ -259,9 +262,9 @@ def spectral_density(
             The timeseries tensor whose power spectral density
             to compute, or for cross spectral density the
             timeseries whose fft will be conjugated. Can have
-            shape either
-            `(batch_size, num_channels, length * sample_rate)`
-            or `(num_channels, length * sample_rate)`.
+            shape `(batch_size, num_channels, length * sample_rate)`,
+            `(num_channels, length * sample_rate)`, or
+            `(length * sample_rate)`.
         nperseg:
             Number of samples included in each FFT window
         nstride:
@@ -336,11 +339,11 @@ def spectral_density(
 
 
 def truncate_inverse_power_spectrum(
-    psd: types.PSDTensor,
-    fduration: Union[TensorType["time"], float],
+    psd: PSDTensor,
+    fduration: Union[Float[Tensor, " time"], float],
     sample_rate: float,
     highpass: Optional[float] = None,
-) -> types.PSDTensor:
+) -> PSDTensor:
     """
     Truncate the length of the time domain response
     of a whitening filter built using the specified
@@ -399,7 +402,7 @@ def truncate_inverse_power_spectrum(
     q = torch.fft.irfft(inv_asd, n=N, norm="forward", dim=-1)
 
     # taper the edges of the TD filter
-    if isinstance(fduration, torch.Tensor):
+    if isinstance(fduration, Tensor):
         pad = fduration.size(-1) // 2
         window = fduration
     else:
@@ -422,8 +425,8 @@ def truncate_inverse_power_spectrum(
 
 
 def normalize_by_psd(
-    X: types.WaveformTensor,
-    psd: types.PSDTensor,
+    X: WaveformTensor,
+    psd: PSDTensor,
     sample_rate: float,
     pad: int,
 ):
@@ -447,12 +450,12 @@ def normalize_by_psd(
 
 
 def whiten(
-    X: types.WaveformTensor,
-    psd: types.PSDTensor,
-    fduration: Union[TensorType["time"], float],
+    X: WaveformTensor,
+    psd: PSDTensor,
+    fduration: Union[Float[Tensor, " time"], float],
     sample_rate: float,
     highpass: Optional[float] = None,
-) -> types.WaveformTensor:
+) -> WaveformTensor:
     """
     Whiten a batch of timeseries using the specified
     background one-sided power spectral densities (PSDs),
@@ -460,7 +463,8 @@ def whiten(
     `fduration` and possibly to highpass filter.
 
     Args:
-        X: batch of multichannel timeseries to whiten
+        X:
+            batch of multichannel timeseries to whiten
         psd:
             PSDs use to whiten the data. The frequency
             response of the whitening filter will be roughly
@@ -496,7 +500,7 @@ def whiten(
 
     # figure out how much data we'll need to slice
     # off after whitening
-    if isinstance(fduration, torch.Tensor):
+    if isinstance(fduration, Tensor):
         pad = fduration.size(-1) // 2
     else:
         pad = int(fduration * sample_rate / 2)

ml4gw/transforms/pearson.py

@@ -1,5 +1,8 @@
 import torch
+from jaxtyping import Float
+from torch import Tensor
 
+from ml4gw.types import TimeSeries1to3d
 from ml4gw.utils.slicing import unfold_windows
 
 
@@ -40,7 +43,7 @@ class ShiftedPearsonCorrelation(torch.nn.Module):
         super().__init__()
         self.max_shift = max_shift
 
-    def _shape_checks(self, x: torch.Tensor, y: torch.Tensor):
+    def _shape_checks(self, x: TimeSeries1to3d, y: TimeSeries1to3d):
         if x.ndim > 3:
             raise ValueError(
                 "Tensor x can only have up to 3 dimensions "
@@ -61,8 +64,9 @@ class ShiftedPearsonCorrelation(torch.nn.Module):
                     )
                 )
 
-    # TODO: torchtyping annotate
-    def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+    def forward(
+        self, x: TimeSeries1to3d, y: TimeSeries1to3d
+    ) -> Float[Tensor, "windows ..."]:
         self._shape_checks(x, y)
         dim = x.size(-1)
 

ml4gw/transforms/qtransform.py

@@ -3,6 +3,10 @@ from typing import List, Optional, Tuple
 
 import torch
 import torch.nn.functional as F
+from jaxtyping import Float, Int
+from torch import Tensor
+
+from ml4gw.types import FrequencySeries1to3d, TimeSeries1to3d, TimeSeries3d
 
 """
 All based on https://github.com/gwpy/gwpy/blob/v3.0.8/gwpy/signal/qtransform.py
@@ -44,7 +48,7 @@ class QTile(torch.nn.Module):
         duration: float,
         sample_rate: float,
         mismatch: float,
-    ):
+    ) -> None:
         super().__init__()
         self.mismatch = mismatch
         self.q = q
@@ -63,18 +67,18 @@ class QTile(torch.nn.Module):
         self.register_buffer("indices", self.get_data_indices())
         self.register_buffer("window", self.get_window())
 
-    def ntiles(self):
+    def ntiles(self) -> int:
         """
         Number of tiles in this frequency row
         """
         tcum_mismatch = self.duration * 2 * torch.pi * self.frequency / self.q
         return int(2 ** torch.ceil(torch.log2(tcum_mismatch / self.deltam)))
 
-    def _get_indices(self):
+    def _get_indices(self) -> Int[Tensor, " windowsize"]:
         half = int((self.windowsize - 1) / 2)
         return torch.arange(-half, half + 1)
 
-    def get_window(self):
+    def get_window(self) -> Float[Tensor, " windowsize"]:
         """
         Generate the bi-square window for this row
         """
@@ -87,7 +91,7 @@ class QTile(torch.nn.Module):
         )
         return torch.Tensor((1 - xfrequencies**2) ** 2 * norm)
 
-    def get_data_indices(self):
+    def get_data_indices(self) -> Int[Tensor, " windowsize"]:
         """
         Get the index array of relevant frequencies for this row
         """
@@ -95,7 +99,9 @@ class QTile(torch.nn.Module):
             self._get_indices() + 1 + self.frequency * self.duration,
         ).type(torch.long)
 
-    def forward(self, fseries: torch.Tensor, norm: str = "median"):
+    def forward(
+        self, fseries: FrequencySeries1to3d, norm: str = "median"
+    ) -> TimeSeries1to3d:
         """
         Compute the transform for this row
 
@@ -176,7 +182,7 @@ class SingleQTransform(torch.nn.Module):
         q: float = 12,
         frange: List[float] = [0, torch.inf],
         mismatch: float = 0.2,
-    ):
+    ) -> None:
         super().__init__()
         self.q = q
         self.spectrogram_shape = spectrogram_shape
@@ -198,7 +204,7 @@ class SingleQTransform(torch.nn.Module):
         )
         self.qtiles = None
 
-    def get_freqs(self):
+    def get_freqs(self) -> Float[Tensor, " nfreq"]:
         """
         Calculate the frequencies that will be used in this transform.
         For each frequency, a `QTile` is created.
@@ -262,7 +268,7 @@ class SingleQTransform(torch.nn.Module):
         if dimension == "batch":
             return torch.max(max_across_ft, dim=-1).values
 
-    def compute_qtiles(self, X: torch.Tensor, norm: str = "median"):
+    def compute_qtiles(self, X: TimeSeries1to3d, norm: str = "median") -> None:
         """
         Take the FFT of the input timeseries and calculate the transform
         for each `QTile`
@@ -272,7 +278,7 @@ class SingleQTransform(torch.nn.Module):
         X[..., 1:] *= 2
         self.qtiles = [qtile(X, norm) for qtile in self.qtile_transforms]
 
-    def interpolate(self, num_f_bins: int, num_t_bins: int):
+    def interpolate(self, num_f_bins: int, num_t_bins: int) -> TimeSeries3d:
         """
         Interpolate each `QTile` to the specified number of time and
         frequency bins. Note that PyTorch does not have the same
@@ -299,7 +305,7 @@ class SingleQTransform(torch.nn.Module):
 
     def forward(
         self,
-        X: torch.Tensor,
+        X: TimeSeries1to3d,
         norm: str = "median",
         spectrogram_shape: Optional[Tuple[int, int]] = None,
     ):
@@ -371,7 +377,7 @@ class QScan(torch.nn.Module):
         qrange: List[float] = [4, 64],
         frange: List[float] = [0, torch.inf],
         mismatch: float = 0.2,
-    ):
+    ) -> None:
         super().__init__()
         self.qrange = qrange
         self.mismatch = mismatch
@@ -397,7 +403,7 @@ class QScan(torch.nn.Module):
             ]
         )
 
-    def get_qs(self):
+    def get_qs(self) -> List[float]:
         """
         Determine the values of Q to try for the set of Q-transforms
         """
@@ -413,7 +419,7 @@ class QScan(torch.nn.Module):
 
     def forward(
         self,
-        X: torch.Tensor,
+        X: TimeSeries1to3d,
         fsearch_range: List[float] = None,
         norm: str = "median",
         spectrogram_shape: Optional[Tuple[int, int]] = None,

ml4gw/transforms/scaler.py

@@ -1,6 +1,8 @@
 from typing import Optional
 
 import torch
+from jaxtyping import Float
+from torch import Tensor
 
 from ml4gw.transforms.transform import FittableTransform
 
@@ -34,7 +36,7 @@ class ChannelWiseScaler(FittableTransform):
         self.register_buffer("mean", mean)
         self.register_buffer("std", std)
 
-    def fit(self, X: torch.Tensor) -> None:
+    def fit(self, X: Float[Tensor, "... time"]) -> None:
         """Fit the scaling parameters to a timeseries
 
         Computes the channel-wise mean and standard deviation
@@ -60,7 +62,9 @@ class ChannelWiseScaler(FittableTransform):
 
         super().build(mean=mean, std=std)
 
-    def forward(self, X: torch.Tensor, reverse: bool = False) -> torch.Tensor:
+    def forward(
+        self, X: Float[Tensor, "... time"], reverse: bool = False
+    ) -> Float[Tensor, "... time"]:
         if not reverse:
             return (X - self.mean) / self.std
         else:

ml4gw/transforms/snr_rescaler.py

@@ -2,8 +2,9 @@ from typing import Optional
 
 import torch
 
-from ml4gw import gw
+from ml4gw.gw import compute_network_snr
 from ml4gw.transforms.transform import FittableSpectralTransform
+from ml4gw.types import BatchTensor, TimeSeries2d, WaveformTensor
 
 
 class SnrRescaler(FittableSpectralTransform):
@@ -34,7 +35,7 @@ class SnrRescaler(FittableSpectralTransform):
 
     def fit(
         self,
-        *background: torch.Tensor,
+        *background: TimeSeries2d,
         fftlength: Optional[float] = None,
         overlap: Optional[float] = None,
     ):
@@ -58,10 +59,10 @@ class SnrRescaler(FittableSpectralTransform):
 
     def forward(
         self,
-        responses: gw.WaveformTensor,
-        target_snrs: Optional[gw.ScalarTensor] = None,
+        responses: WaveformTensor,
+        target_snrs: Optional[BatchTensor] = None,
     ):
-        snrs = gw.compute_network_snr(
+        snrs = compute_network_snr(
             responses, self.background, self.sample_rate, self.mask
         )
         if target_snrs is None:

ml4gw/transforms/spectral.py

@@ -1,8 +1,11 @@
 from typing import Optional
 
 import torch
+from jaxtyping import Float
+from torch import Tensor
 
 from ml4gw.spectral import fast_spectral_density, spectral_density
+from ml4gw.types import FrequencySeries1to3d, TimeSeries1to3d
 
 
 class SpectralDensity(torch.nn.Module):
@@ -34,6 +37,10 @@ class SpectralDensity(torch.nn.Module):
         average:
             Aggregation method to use for combining windowed FFTs.
             Allowed values are `"mean"` and `"median"`.
+        window:
+            Window array to multiply by each FFT window before
+            FFT computation. Should have length `nperseg`.
+            Defaults to a hanning window.
         fast:
             Whether to use a faster spectral density computation that
             support cross spectral density, or a slower one which does
@@ -47,6 +54,9 @@ class SpectralDensity(torch.nn.Module):
         fftlength: float,
         overlap: Optional[float] = None,
         average: str = "mean",
+        window: Optional[
+            Float[Tensor, " {int(fftlength*sample_rate)}"]
+        ] = None,
         fast: bool = False,
     ) -> None:
         if overlap is None:
@@ -63,11 +73,18 @@ class SpectralDensity(torch.nn.Module):
         self.nperseg = int(fftlength * sample_rate)
         self.nstride = self.nperseg - int(overlap * sample_rate)
 
-        # TODOs: Do we allow for arbitrary windows?
-        # Making this buffer persistent in case we want
-        # to implement this down the line, so that custom
-        # windows can be loaded in.
-        self.register_buffer("window", torch.hann_window(self.nperseg))
+        # if no window is provided, default to a hanning window;
+        # validate that window is correct size
+        if window is None:
+            window = torch.hann_window(self.nperseg)
+
+        if window.size(0) != self.nperseg:
+            raise ValueError(
+                "Window must have length {} got {}".format(
+                    self.nperseg, window.size(0)
+                )
+            )
+        self.register_buffer("window", window)
 
         # scale corresponds to "density" normalization, worth
         # considering adding this as a kwarg and changing this calc
@@ -81,7 +98,9 @@ class SpectralDensity(torch.nn.Module):
         self.average = average
         self.fast = fast
 
-    def forward(self, x: torch.Tensor, y: Optional[torch.Tensor] = None):
+    def forward(
+        self, x: TimeSeries1to3d, y: Optional[TimeSeries1to3d] = None
+    ) -> FrequencySeries1to3d:
         if self.fast:
             return fast_spectral_density(
                 x,

ml4gw/transforms/spectrogram.py

@@ -3,8 +3,12 @@ from typing import Dict, List
 
 import torch
 import torch.nn.functional as F
+from jaxtyping import Float
+from torch import Tensor
 from torchaudio.transforms import Spectrogram
 
+from ml4gw.types import TimeSeries3d
+
 
 class MultiResolutionSpectrogram(torch.nn.Module):
     """
@@ -122,7 +126,9 @@ class MultiResolutionSpectrogram(torch.nn.Module):
 
         return [dict(zip(kwargs, col)) for col in zip(*kwargs.values())]
 
-    def forward(self, X: torch.Tensor) -> torch.Tensor:
+    def forward(
+        self, X: TimeSeries3d
+    ) -> Float[Tensor, "batch channel frequency time"]:
         """
         Calculate spectrograms of the input tensor and
         combine them into a single spectrogram

ml4gw/transforms/transform.py

@@ -3,6 +3,7 @@ from typing import Optional
 import torch
 
 from ml4gw.spectral import spectral_density
+from ml4gw.types import FrequencySeries1to3d, TimeSeries1to3d
 
 
 class FittableTransform(torch.nn.Module):
@@ -43,12 +44,12 @@ class FittableTransform(torch.nn.Module):
 class FittableSpectralTransform(FittableTransform):
     def normalize_psd(
         self,
-        x,
+        x: TimeSeries1to3d,
         sample_rate: float,
         num_freqs: int,
         fftlength: Optional[float] = None,
         overlap: Optional[float] = None,
-    ):
+    ) -> FrequencySeries1to3d:
         # if we specified an FFT length, convert
         # the (assumed) time-domain data to the
         # frequency domain
@@ -68,7 +69,7 @@ class FittableSpectralTransform(FittableTransform):
                 scale=scale,
             )
 
-        # add two dummy dimensions in case we need to inerpolate
+        # add two dummy dimensions in case we need to interpolate
         # the frequency dimension, since `interpolate` expects
         # a (batch, channel, spatial) formatted tensor as input
         x = x.view(1, 1, -1)

ml4gw/transforms/waveforms.py

@@ -1,8 +1,11 @@
 from typing import List, Optional
 
 import torch
+from jaxtyping import Float
+from torch import Tensor
 
 from ml4gw import gw
+from ml4gw.types import BatchTensor
 
 
 # TODO: should these live in ml4gw.waveforms submodule?
@@ -10,8 +13,8 @@ from ml4gw import gw
 class WaveformSampler(torch.nn.Module):
     def __init__(
         self,
-        parameters: Optional[torch.Tensor] = None,
-        **polarizations: torch.Tensor,
+        parameters: Optional[Float[Tensor, "batch num_params"]] = None,
+        **polarizations: Float[Tensor, "batch time"],
     ):
         super().__init__()
         # make sure we have the same number of waveforms
@@ -29,7 +32,7 @@ class WaveformSampler(torch.nn.Module):
             elif num_waveforms is None:
                 num_waveforms = tensor.shape[0]
 
-            self.polarizations[polarization] = torch.Tensor(tensor)
+            self.polarizations[polarization] = Tensor(tensor)
 
         if parameters is not None and len(parameters) != num_waveforms:
             raise ValueError(
@@ -73,10 +76,10 @@ class WaveformProjector(torch.nn.Module):
 
     def forward(
         self,
-        dec: gw.ScalarTensor,
-        psi: gw.ScalarTensor,
-        phi: gw.ScalarTensor,
-        **polarizations,
+        dec: BatchTensor,
+        psi: BatchTensor,
+        phi: BatchTensor,
+        **polarizations: Float[Tensor, "batch time"],
     ):
         ifo_responses = gw.compute_observed_strain(
             dec,

ml4gw/transforms/whitening.py

@@ -1,9 +1,15 @@
-from typing import Optional
+from typing import Optional, Union
 
 import torch
 
 from ml4gw import spectral
 from ml4gw.transforms.transform import FittableSpectralTransform
+from ml4gw.types import (
+    FrequencySeries1d,
+    FrequencySeries1to3d,
+    TimeSeries1d,
+    TimeSeries3d,
+)
 
 
 class Whiten(torch.nn.Module):
@@ -58,7 +64,9 @@ class Whiten(torch.nn.Module):
         window = torch.hann_window(size, dtype=torch.float64)
         self.register_buffer("window", window)
 
-    def forward(self, X: torch.Tensor, psd: torch.Tensor) -> torch.Tensor:
+    def forward(
+        self, X: TimeSeries3d, psd: FrequencySeries1to3d
+    ) -> TimeSeries3d:
         """
         Whiten a batch of multichannel timeseries by a
         background power spectral density.
@@ -142,7 +150,7 @@ class FixedWhiten(FittableSpectralTransform):
     def fit(
         self,
         fduration: float,
-        *background: torch.Tensor,
+        *background: Union[TimeSeries1d, FrequencySeries1d],
         fftlength: Optional[float] = None,
         highpass: Optional[float] = None,
         overlap: Optional[float] = None
@@ -224,7 +232,7 @@ class FixedWhiten(FittableSpectralTransform):
         fduration = torch.Tensor([fduration])
         self.build(psd=psd, fduration=fduration)
 
-    def forward(self, X: torch.Tensor) -> torch.Tensor:
+    def forward(self, X: TimeSeries3d) -> TimeSeries3d:
         """
         Whiten the input timeseries tensor using the
         PSD fit by the `.fit` method, which must be

ml4gw/types.py

@@ -1,10 +1,25 @@
-from torchtyping import TensorType
-
-WaveformTensor = TensorType["batch", "num_ifos", "time"]
-PSDTensor = TensorType["num_ifos", "frequency"]
-ScalarTensor = TensorType["batch"]
-VectorGeometry = TensorType["batch", "space"]
-TensorGeometry = TensorType["batch", "space", "space"]
-NetworkVertices = TensorType["num_ifos", 3]
-NetworkDetectorTensors = TensorType["num_ifos", 3, 3]
-TimeSeriesTensor = TensorType["num_channels", "time"]
+from typing import Union
+
+from jaxtyping import Float
+from torch import Tensor
+
+WaveformTensor = Float[Tensor, "batch num_ifos time"]
+PSDTensor = Float[Tensor, "num_ifos frequency"]
+BatchTensor = Float[Tensor, "batch"]
+VectorGeometry = Float[Tensor, "batch space"]
+TensorGeometry = Float[Tensor, "batch space space"]
+NetworkVertices = Float[Tensor, "num_ifos 3"]
+NetworkDetectorTensors = Float[Tensor, "num_ifos 3 3"]
+
+
+TimeSeries1d = Float[Tensor, "time"]
+TimeSeries2d = Float[TimeSeries1d, "channel"]
+TimeSeries3d = Float[TimeSeries2d, "batch"]
+TimeSeries1to3d = Union[TimeSeries1d, TimeSeries2d, TimeSeries3d]
+
+FrequencySeries1d = Float[Tensor, "frequency"]
+FrequencySeries2d = Float[FrequencySeries1d, "channel"]
+FrequencySeries3d = Float[FrequencySeries2d, "batch"]
+FrequencySeries1to3d = Union[
+    FrequencySeries1d, FrequencySeries2d, FrequencySeries3d
+]

ml4gw/utils/interferometer.py

@@ -4,7 +4,7 @@ import torch
 # based on values from
 # https://lscsoft.docs.ligo.org/lalsuite/lal/_l_a_l_detectors_8h_source.html
 class InterferometerGeometry:
-    def __init__(self, name: str):
+    def __init__(self, name: str) -> None:
         if name == "H1":
             self.x_arm = torch.Tensor(
                 (-0.22389266154, +0.79983062746, +0.55690487831)
@@ -35,6 +35,12 @@ class InterferometerGeometry:
             self.vertex = torch.Tensor(
                 (4.54637409900e06, 8.42989697626e05, 4.37857696241e06)
             )
+        elif name == "K1":
+            self.x_arm = torch.Tensor((-0.3759040, -0.8361583, 0.3994189))
+            self.y_arm = torch.Tensor((0.7164378, 0.01114076, 0.6975620))
+            self.vertex = torch.Tensor(
+                (-3777336.024, 3484898.411, 3765313.697)
+            )
         else:
             raise ValueError(
                 f"{name} is not recognized as an interferometer, "