pywavelet 0.0.1b0__py3-none-any.whl → 0.1.0__py3-none-any.whl

pywavelet/transforms/types/wavelet.py

@@ -0,0 +1,374 @@
+import matplotlib.pyplot as plt
+from typing import Optional, Tuple
+
+import numpy as np
+
+from .common import is_documented_by, xp, fmt_timerange
+from .plotting import plot_wavelet_grid, plot_wavelet_trend
+
+
+class Wavelet:
+    """
+    A class to represent a wavelet transform result, with methods for plotting and accessing key properties like duration, sample rate, and grid size.
+
+    Attributes
+    ----------
+    data : xp.ndarray
+        2D array representing the wavelet coefficients (frequency x time).
+    time : xp.ndarray
+        Array of time points.
+    freq : xp.ndarray
+        Array of corresponding frequency points.
+    """
+
+    def __init__(
+            self,
+            data: xp.ndarray,
+            time: xp.ndarray,
+            freq: xp.ndarray,
+    ):
+        """
+        Initialize the Wavelet object with data, time, and frequency arrays.
+
+        Parameters
+        ----------
+        data : xp.ndarray
+            2D array representing the wavelet coefficients (frequency x time).
+        time : xp.ndarray
+            Array of time points.
+        freq : xp.ndarray
+            Array of corresponding frequency points.
+
+        Raises
+        ------
+        AssertionError
+            If the length of the time array does not match the number of time bins in `data`.
+            If the length of the frequency array does not match the number of frequency bins in `data`.
+        """
+        nf, nt = data.shape
+        assert len(time) == nt, f"len(time)={len(time)} != nt={nt}"
+        assert len(freq) == nf, f"len(freq)={len(freq)} != nf={nf}"
+
+        self.data = data
+        self.time = time
+        self.freq = freq
+
+    @is_documented_by(plot_wavelet_grid)
+    def plot(self, ax=None, *args, **kwargs) -> Tuple[plt.Figure, plt.Axes]:
+        kwargs["time_grid"] = kwargs.get("time_grid", self.time)
+        kwargs["freq_grid"] = kwargs.get("freq_grid", self.freq)
+        return plot_wavelet_grid(wavelet_data=self.data, ax=ax, *args, **kwargs)
+
+    @is_documented_by(plot_wavelet_trend)
+    def plot_trend(self, ax=None, *args, **kwargs) -> Tuple[plt.Figure, plt.Axes]:
+        kwargs["time_grid"] = kwargs.get("time_grid", self.time)
+        kwargs["freq_grid"] = kwargs.get("freq_grid", self.freq)
+        return plot_wavelet_trend(wavelet_data=self.data, ax=ax, *args, **kwargs)
+
+    @property
+    def Nt(self) -> int:
+        """
+        Number of time bins.
+
+        Returns
+        -------
+        int
+            Length of the time array.
+        """
+        return len(self.time)
+
+    @property
+    def Nf(self) -> int:
+        """
+        Number of frequency bins.
+
+        Returns
+        -------
+        int
+            Length of the frequency array.
+        """
+        return len(self.freq)
+
+    @property
+    def ND(self) -> int:
+        """
+        Total number of data points in the wavelet grid.
+
+        Returns
+        -------
+        int
+            The product of `Nt` and `Nf`.
+        """
+        return self.Nt * self.Nf
+
+    @property
+    def delta_T(self) -> float:
+        """
+        Time resolution (ΔT) of the wavelet grid.
+
+        Returns
+        -------
+        float
+            Difference between consecutive time points.
+        """
+        return self.time[1] - self.time[0]
+
+    @property
+    def delta_F(self) -> float:
+        """
+        Frequency resolution (ΔF) of the wavelet grid.
+
+        Returns
+        -------
+        float
+            Inverse of twice the time resolution.
+        """
+        return 1 / (2 * self.delta_T)
+
+    @property
+    def duration(self) -> float:
+        """
+        Duration of the wavelet grid.
+
+        Returns
+        -------
+        float
+            Total duration in seconds.
+        """
+        return float(self.Nt * self.delta_T)
+
+    @property
+    def delta_t(self) -> float:
+        """
+        Time resolution of the wavelet grid, normalized by the total number of data points.
+
+        Returns
+        -------
+        float
+            Time resolution per data point.
+        """
+        return float(self.duration / self.ND)
+
+    @property
+    def delta_f(self) -> float:
+        """
+        Frequency resolution of the wavelet grid, normalized by the total number of data points.
+
+        Returns
+        -------
+        float
+            Frequency resolution per data point.
+        """
+        return 1 / (2 * self.delta_t)
+
+    @property
+    def t0(self) -> float:
+        """
+        Initial time point of the wavelet grid.
+
+        Returns
+        -------
+        float
+            First time point in the time array.
+        """
+        return float(self.time[0])
+
+    @property
+    def tend(self) -> float:
+        """
+        Final time point of the wavelet grid.
+
+        Returns
+        -------
+        float
+            Last time point in the time array.
+        """
+        return float(self.time[-1])
+
+    @property
+    def shape(self) -> Tuple[int, int]:
+        """
+        Shape of the wavelet grid.
+
+        Returns
+        -------
+        Tuple[int, int]
+            Tuple representing the shape of the data array (Nf, Nt).
+        """
+        return self.data.shape
+
+    @property
+    def sample_rate(self) -> float:
+        """
+        Sample rate of the wavelet grid.
+
+        Returns
+        -------
+        float
+            Sample rate calculated as the inverse of the time resolution.
+        """
+        return 1 / self.delta_t
+
+    @property
+    def fs(self) -> float:
+        """
+        Sample rate (fs) of the wavelet grid.
+
+        Returns
+        -------
+        float
+            The sample rate.
+        """
+        return self.sample_rate
+
+    @property
+    def nyquist_frequency(self) -> float:
+        """
+        Nyquist frequency of the wavelet grid.
+
+        Returns
+        -------
+        float
+            Nyquist frequency, which is half of the sample rate.
+        """
+        return self.sample_rate / 2
+
+    def to_timeseries(self, nx: float = 4.0, mult: int = 32) -> "TimeSeries":
+        """
+        Convert the wavelet grid to a time-domain signal.
+
+        Returns
+        -------
+        TimeSeries
+            A `TimeSeries` object representing the time-domain signal.
+        """
+        from ..inverse import from_wavelet_to_time
+        return from_wavelet_to_time(self, dt=self.delta_t, nx=nx, mult=mult)
+
+    def to_frequencyseries(self, nx: float = 4.0) -> "FrequencySeries":
+        """
+        Convert the wavelet grid to a frequency-domain signal.
+
+        Returns
+        -------
+        FrequencySeries
+            A `FrequencySeries` object representing the frequency-domain signal.
+        """
+        from ..inverse import from_wavelet_to_freq
+        return from_wavelet_to_freq(self, dt=self.delta_t, nx=nx)
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the Wavelet object.
+
+        Returns
+        -------
+        str
+            String containing information about the shape of the wavelet grid.
+        """
+
+        frange = ",".join([f"{f:.2e}" for f in (self.freq[0], self.freq[-1])])
+        trange = fmt_timerange((self.t0, self.tend))
+        Nfpow2 = int(np.log2(self.shape[0]))
+        Ntpow2 = int(np.log2(self.shape[1]))
+        shapef = f"NfxNf=[2^{Nfpow2}, 2^{Ntpow2}]"
+        return f"Wavelet({shapef}, [{frange}]Hz, {trange})"
+
+    def __add__(self, other):
+        """Element-wise addition of two Wavelet objects."""
+        if isinstance(other, Wavelet):
+            return Wavelet(data=self.data + other.data, time=self.time, freq=self.freq)
+        elif isinstance(other, float):
+            return Wavelet(data=self.data + other, time=self.time, freq=self.freq)
+
+    def __sub__(self, other):
+        """Element-wise subtraction of two Wavelet objects."""
+        if isinstance(other, Wavelet):
+            return Wavelet(data=self.data - other.data, time=self.time, freq=self.freq)
+        elif isinstance(other, float):
+            return Wavelet(data=self.data - other, time=self.time, freq=self.freq)
+
+    def __mul__(self, other):
+        """Element-wise multiplication of two Wavelet objects."""
+        if isinstance(other, Wavelet):
+            return Wavelet(data=self.data * other.data, time=self.time, freq=self.freq)
+        elif isinstance(other, float):
+            return Wavelet(data=self.data * other, time=self.time, freq=self.freq)
+
+    def __truediv__(self, other):
+        """Element-wise division of two Wavelet objects."""
+        if isinstance(other, Wavelet):
+            return Wavelet(data=self.data / other.data, time=self.time, freq=self.freq)
+        elif isinstance(other, float):
+            return Wavelet(data=self.data / other, time=self.time, freq=self.freq)
+
+    def __eq__(self, other:"Wavelet") -> bool:
+        """Element-wise comparison of two Wavelet objects."""
+        data_all_same = xp.isclose(xp.nansum(self.data - other.data), 0)
+        time_same = (self.time == other.time).all()
+        freq_same = (self.freq == other.freq).all()
+        return data_all_same and time_same and freq_same
+
+
+    def noise_weighted_inner_product(self, other:"Wavelet", psd:"Wavelet") -> float:
+        """
+        Compute the noise-weighted inner product of two wavelet grids given a PSD.
+
+        Parameters
+        ----------
+        other : Wavelet
+            A `Wavelet` object representing the other wavelet grid.
+        psd : Wavelet
+            A `Wavelet` object representing the power spectral density.
+
+        Returns
+        -------
+        float
+            The noise-weighted inner product.
+        """
+        from ...utils import noise_weighted_inner_product
+        return noise_weighted_inner_product(self, other, psd)
+
+
+    def matched_filter_snr(self, template:"Wavelet", psd:"Wavelet") -> float:
+        """
+        Compute the matched filter SNR of the wavelet grid given a template.
+
+        Parameters
+        ----------
+        template : Wavelet
+            A `Wavelet` object representing the template.
+
+        Returns
+        -------
+        float
+            The matched filter signal-to-noise ratio.
+        """
+        mf = self.noise_weighted_inner_product(template, psd)
+        return mf / self.optimal_snr(psd)
+
+    def optimal_snr(self, psd:"Wavelet") -> float:
+        """
+        Compute the optimal SNR of the wavelet grid given a PSD.
+
+        Parameters
+        ----------
+        psd : Wavelet
+            A `Wavelet` object representing the power spectral density.
+
+        Returns
+        -------
+        float
+            The optimal signal-to-noise ratio.
+        """
+        return xp.sqrt(self.noise_weighted_inner_product(self, psd))
+
+    def __copy__(self):
+        return Wavelet(
+            data=self.data.copy(),
+            time=self.time.copy(),
+            freq=self.freq.copy()
+        )
+
+    def copy(self):
+        return self.__copy__()

pywavelet/transforms/types/wavelet_mask.py

@@ -0,0 +1,34 @@
+from typing import List
+
+from .common import fmt_timerange, is_documented_by, xp
+
+
+class WaveletMask:
+    def __init__(
+        self,
+        mask: xp.ndarray,
+        time: xp.ndarray,
+        freq: xp.ndarray,
+    ):
+        self.mask = mask
+        self.time = time
+        self.freq = freq
+
+    def __repr__(self):
+        return f"WaveletMask({self.mask.shape}, {fmt_timerange(self.time)}, {self.freq})"
+
+    @classmethod
+    def from_grid(cls, time_grid: xp.ndarray, freq_grid: xp.ndarray):
+        nt, nf = len(time_grid), len(freq_grid)
+        mask = xp.zeros((nf, nt), dtype=bool)
+        return cls(mask, time_grid, freq_grid)
+
+    @classmethod
+    def from_frange(
+        cls, time_grid: xp.ndarray, freq_grid: xp.ndarray, frange: List[float]
+    ):
+        self = cls.from_grid(time_grid, freq_grid)
+        self.mask[
+            (freq_grid >= frange[0]) & (freq_grid <= frange[1]), :
+        ] = True
+        return self

pywavelet/utils.py

@@ -0,0 +1,76 @@
+from typing import Union
+
+import numpy as np
+from scipy.interpolate import interp1d
+
+from .transforms.types import FrequencySeries, TimeSeries, Wavelet, WaveletMask
+
+DATA_TYPE = Union[TimeSeries, FrequencySeries, Wavelet]
+
+
+def evolutionary_psd_from_stationary_psd(
+    psd: np.ndarray,
+    psd_f: np.ndarray,
+    f_grid: np.ndarray,
+    t_grid: np.ndarray,
+    dt: float,
+) -> Wavelet:
+    """
+    PSD[ti,fi] = PSD[fi] / dt
+    """
+    Nt = len(t_grid)
+    delta_f = f_grid[1] - f_grid[0]
+    nan_val = np.max(psd)
+    psd_grid = interp1d(
+        psd_f,
+        psd,
+        kind="nearest",
+        fill_value=nan_val,
+        bounds_error=False,
+    )(f_grid)
+
+    # repeat the PSD for each time bin
+    psd_grid = np.repeat(psd_grid[None, :], Nt, axis=0) / dt
+    return Wavelet(psd_grid.T, time=t_grid, freq=f_grid)
+
+
+def noise_weighted_inner_product(
+    d: Wavelet, h: Wavelet, PSD: Wavelet
+) -> float:
+    return np.nansum((d.data * h.data) / PSD.data)
+
+
+def compute_snr(d: Wavelet, h: Wavelet, PSD: Wavelet) -> float:
+    """Compute the SNR of a model h[ti,fi] given freqseries d[ti,fi] and PSD[ti,fi].
+
+    SNR(h) = Sum_{ti,fi} [ h_hat[ti,fi] d[ti,fi] / PSD[ti,fi]
+
+    Parameters
+    ----------
+    h : np.ndarray
+        The model in the wavelet domain (binned in [ti,fi]).
+    d : np.ndarray
+        The freqseries in the wavelet domain (binned in [ti,fi]).
+    PSD : np.ndarray
+        The PSD in the wavelet domain (binned in [ti,fi]).
+
+    Returns
+    -------
+    float
+        The SNR of the model h given freqseries d and PSD.
+
+    """
+    return np.sqrt(noise_weighted_inner_product(d, h, PSD))
+
+
+def compute_likelihood(
+    data: Wavelet, template: Wavelet, psd: Wavelet, mask: WaveletMask = None
+) -> float:
+    d = data.data
+    h = template.data
+    p = psd.data
+    if mask is not None:
+        m = mask.mask
+        d, h, p = d * m, h * m, p * m
+
+    return -0.5 * np.nansum((d - h) ** 2 / p)

pywavelet-0.1.0.dist-info/METADATA

@@ -0,0 +1,35 @@
+Metadata-Version: 2.1
+Name: pywavelet
+Version: 0.1.0
+Summary: WDM wavelet transform your time/freq series!
+Author-email: Pywavelet Team <avi.vajpeyi@gmail.com>
+Project-URL: Homepage, https://pywavelet.github.io/pywavelet/
+Project-URL: Bug Reports, https://pywavelet.com/pywavelet/pywavelet/issues
+Project-URL: Source, https://github.com/pywavelet/pywavelet/
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.8
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: numba
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: tqdm
+Requires-Dist: rich
+Requires-Dist: rocket-fft
+Requires-Dist: astropy>=5.2.1
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: flake8>=5.0.4; extra == "dev"
+Requires-Dist: black>=22.12.0; extra == "dev"
+Requires-Dist: black[jupyter]>=22.12.0; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: jupyter-book; extra == "dev"
+Requires-Dist: GitPython; extra == "dev"
+

pywavelet-0.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+pywavelet/__init__.py,sha256=zcK3Qj4wTrGZF1rU3aT6yA9LvliAOD4DVOY7gNfHhCI,53
+pywavelet/_version.py,sha256=IMl2Pr_Sy4LVRKy_Sm4CdwUl1Gryous6ncL96EMYsnM,411
+pywavelet/logger.py,sha256=u5Et6QLUU0IuTnPnxfev5-4GYmihTo7_yBCTf-rVUsA,377
+pywavelet/utils.py,sha256=-fZULV8ze1cxs0SP03Di-naYPgNvHbADsFrJ6Vzi7aE,1918
+pywavelet/transforms/__init__.py,sha256=FolK8WiVEJmGDC9xMupYVI_essXaXS4LYWKbqEqGx6o,289
+pywavelet/transforms/phi_computer.py,sha256=vo1PK9Z70kKV-1lfyRoxWdhSYqwIgJK5CRCCJVei3xI,4545
+pywavelet/transforms/forward/__init__.py,sha256=Yq4Tg3Ze98-17C9FIkOqMUdiLHe9x_YoyuRvxOxMOP0,176
+pywavelet/transforms/forward/from_freq.py,sha256=HWADciv746P5zWNhnyRKDEDACTQnwDTR4usf2k0VIWk,2663
+pywavelet/transforms/forward/from_time.py,sha256=zfpvmq7UHnynzAnsM_Pf4MXpO1GJ0TaCCERQKNsaBNU,2340
+pywavelet/transforms/forward/main.py,sha256=FJSLUUsk3I91lUeB2YFiXQdX8gB9maFW60e4tgrd45A,4053
+pywavelet/transforms/forward/wavelet_bins.py,sha256=43CHVSjNgC59Af1_h9t33VBBqGHJmIUaOUhJgekhMnc,1419
+pywavelet/transforms/inverse/__init__.py,sha256=J4KIzPzbHNg_8fV_c1MpPq3slSqHQV0j3VFrjfd1Nog,121
+pywavelet/transforms/inverse/main.py,sha256=l5yFvzmWObrO5Xt_8KYp62w829ab0pQLxcv0-QxkvG0,3015
+pywavelet/transforms/inverse/to_freq.py,sha256=SExZMax-8A-tJpIA86pYY61X2qvlZ2MrZY27uzCQSV0,2778
+pywavelet/transforms/inverse/to_time.py,sha256=BAYvrr41QHIbzwYMPyMnzv5mqSx40YigmBruWBwtZwc,5041
+pywavelet/transforms/types/__init__.py,sha256=bNw6gb1S7aA1-wl38LEL7j0BhJBJveYDt2ERn-0kU4k,147
+pywavelet/transforms/types/common.py,sha256=sLBn2d9cuL6NYeIv6NIogDjY6rYPZAPzCtWGwMlAwkI,1290
+pywavelet/transforms/types/frequencyseries.py,sha256=Rtwt486UL0-TgMAdcMMVpyfi5PSLzxFcdE_RsYuyxQk,7463
+pywavelet/transforms/types/plotting.py,sha256=aEIFoSuQRYwYc2639yLkbujXx_aav5A5tXG29rOSMOQ,10275
+pywavelet/transforms/types/timeseries.py,sha256=Nl1tiKZ7kwu-EZ5JtubwgzgyjQZR86eGU3C3kElIPNg,9296
+pywavelet/transforms/types/wavelet.py,sha256=raODhyegBd1_esuv2YP6tK_Nj9fYaLQ6O4pxpiFAVZU,10790
+pywavelet/transforms/types/wavelet_mask.py,sha256=Qst9NQmvr6vx0Tg8TMABRnDdD3iQgiwgaQKqyf0lwfU,937
+pywavelet-0.1.0.dist-info/METADATA,sha256=sCAmMS5b2zEqsetgkkFgb7DopcPjn_V1o1y3uzIAEEE,1307
+pywavelet-0.1.0.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+pywavelet-0.1.0.dist-info/top_level.txt,sha256=g0Ezt0Rg0X-nrd-a0pAXKVRkuWNsF2M9Ynsjb9b2UYQ,10
+pywavelet-0.1.0.dist-info/RECORD,,

{pywavelet-0.0.1b0.dist-info → pywavelet-0.1.0.dist-info}/WHEEL

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

pywavelet/fft_funcs.py

@@ -1,16 +0,0 @@
-"""helper to make sure available fft functions are consistent across modules depending on install
-mkl-fft is faster so it is the default, but numpy fft is probably more commonly installed to it is the fallback"""
-try:
-    import mkl_fft
-
-    rfft = mkl_fft.rfft_numpy
-    irfft = mkl_fft.irfft_numpy
-    fft = mkl_fft.fft
-    ifft = mkl_fft.ifft
-except ImportError:
-    import numpy
-
-    rfft = numpy.fft.rfft
-    irfft = numpy.fft.irfft
-    fft = numpy.fft.fft
-    ifft = numpy.fft.ifft

pywavelet/likelihood/likelihood_base.py

@@ -1,9 +0,0 @@
-from abc import ABC, abstractmethod
-
-
-class LikelihoodBase(ABC):
-    def __init__(self):
-        pass
-
-    def log_likelihood(self, data, model):
-        pass

pywavelet/likelihood/whittle.py

@@ -1,24 +0,0 @@
-"""Whittle Likelihood (in the wavelet domain)
-See eq 18, Cornish 2020 "Time-Frequency Analysis of Gravitational Wave Data"
-
-LnL(d|h) = -1/2 * Sum_{ti,fi} [ ln(2pi) + ln(PSD[ti,fi]) + (d[ti,fi]-h[ti,fi])^2/PSD[ti,fi]]
-
-where
-- d[ti,fi] is the data in the wavelet domain,
-- h[ti,fi] is the model in the wavelet domain,
-- PSD[ti,fi] is the _evolutionary_ power spectral density in the wavelet domain.
-
-For stationary noise:
-PSD[ti,fi] = PSD[fi * Nt/2] Delta_f,
-where
-- fi * Nt/2 is the frequency index in the wavelet domain,
-- Delta_f is the frequency bin width in the wavelet domain.
-
-
-"""
-
-from .likelihood_base import LikelihoodBase
-
-
-class WhittleLikelihood(LikelihoodBase):
-    pass

pywavelet/transforms/common.py

@@ -1,77 +0,0 @@
-import numpy as np
-import scipy
-
-from .. import fft_funcs as fft
-
-PI = np.pi
-
-
-def phitilde_vec(om: np.ndarray, Nf: int, nx=4.0) -> np.ndarray:
-    """compute phitilde, om i array, nx is filter steepness, defaults to 4."""
-    # Note: Pi is Nyquist angular frequency
-    DOM = PI / Nf  # 2 pi times DF
-    insDOM = 1.0 / np.sqrt(DOM)
-    B = PI / (2 * Nf)
-    A = (DOM - B) / 2
-    z = np.zeros(om.size)
-
-    mask = (np.abs(om) >= A) & (np.abs(om) < A + B)
-
-    x = (np.abs(om[mask]) - A) / B
-    y = scipy.special.betainc(nx, nx, x)
-    z[mask] = insDOM * np.cos(PI / 2.0 * y)
-
-    z[np.abs(om) < A] = insDOM
-    return z
-
-
-def phitilde_vec_norm(Nf: int, Nt: int, nx: int) -> np.ndarray:
-    """Normalize phitilde for inverse frequency domain transform."""
-
-    # Calculate the frequency values
-    ND = Nf * Nt
-    omegas = 2 * np.pi / ND * np.arange(0, Nt // 2 + 1)
-
-    # Calculate the unnormalized phitilde (u_phit)
-    u_phit = phitilde_vec(omegas, Nf, nx)
-
-    # Normalize the phitilde
-    nrm_fctor = np.sqrt(
-        (2 * np.sum(u_phit[1:] ** 2) + u_phit[0] ** 2) * 2 * PI / ND
-    )
-    nrm_fctor /= PI ** (3 / 2) / PI
-
-    return u_phit / nrm_fctor
-
-
-def phi_vec(Nf: int, nx: int = 4.0, mult: int = 16) -> np.ndarray:
-    """get time domain phi as fourier transform of phitilde_vec"""
-    insDOM = 1.0 / np.sqrt(PI / Nf)
-    K = mult * 2 * Nf
-    half_K = mult * Nf  # np.int64(K/2)
-
-    dom = 2 * PI / K  # max frequency is K/2*dom = pi/dt = OM
-
-    DX = np.zeros(K, dtype=np.complex128)
-
-    # zero frequency
-    DX[0] = insDOM
-
-    DX = DX.copy()
-    # postive frequencies
-    DX[1 : half_K + 1] = phitilde_vec(dom * np.arange(1, half_K + 1), Nf, nx)
-    # negative frequencies
-    DX[half_K + 1 :] = phitilde_vec(
-        -dom * np.arange(half_K - 1, 0, -1), Nf, nx
-    )
-    DX = K * fft.ifft(DX, K)
-
-    phi = np.zeros(K)
-    phi[0:half_K] = np.real(DX[half_K:K])
-    phi[half_K:] = np.real(DX[0:half_K])
-
-    nrm = np.sqrt(K / dom)  # *np.linalg.norm(phi)
-
-    fac = np.sqrt(2.0) / nrm
-    phi *= fac
-    return phi