IAA-CSIC / MUTIS

mutis/lib/signal.py

# Licensed under a 3-clause BSD style license - see LICENSE

There seems to be a cyclic import (mutis.flares.bayblocks -> mutis.flares.flare).

"""Methods for synthetic generation of light curves."""

import logging

import numpy as np

Unable to import 'numpy'

import nfft

Unable to import 'nfft'

import scipy.signal as scipy_signal

Unable to import 'scipy.signal'

from numba import jit

Unable to import 'numba'

__all__ = [
    "lc_gen_samp",
    "lc_gen_psd_nft",
    "lc_gen_ou",
    "lc_gen_psd_lombscargle",
    "lc_gen_psd_fft",
    "lc_gen_psd_c",
    "fgen_wrapper",
]

log = logging.getLogger(__name__)


def fgen_wrapper(fgen, t, y, fgen_params):

Argument name "y" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

Argument name "t" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    """Wrapper for all lc_gen_* functions, so as not to duplicate code."""
        

Trailing whitespace

    if fgen == "lc_gen_samp":
        y2 = lc_gen_samp(y)

Variable name "y2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    elif fgen == "lc_gen_psd_fft":
        y2 = lc_gen_psd_fft(y)

Variable name "y2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    elif fgen == "lc_gen_psd_nft":
        y2 = lc_gen_psd_nft(t, y)

Variable name "y2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    elif fgen == "lc_gen_psd_lombscargle":
        y2 = lc_gen_psd_lombscargle(t, y)

Variable name "y2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    elif fgen == "lc_gen_psd_c":
        y2 = lc_gen_psd_c(t, y, t)

Variable name "y2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    elif fgen == "lc_gen_ou":
        if (fgen_params is None) or not ('theta' in fgen_params or 'mu' in fgen_params or 'sigma' in fgen_params):

This line is too long as per the coding-style (114/100).

            raise Exception("You need to set the parameters for the signal")
        y2 = lc_gen_ou(times=t, **fgen_params)

Variable name "y2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    else:
        raise Exception(f"Unknown fgen method {fgen}")
        

Trailing whitespace

    return y2


def lc_gen_samp(signs):
    """Generation by sampling np.random.choice with same mean and std"""

    return np.random.choice(signs, signs.size)

@jit(nopython=True)
def lc_gen_ou(theta, mu, sigma, times, scale=None, loc=None): # pragma: no cover

Too many arguments (6/5)

Argument name "mu" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    """Generation from an OU process integrating the stochastic differential equation."""

    width = 100 * times.size
    dt = (max(times) - min(times)) / width

Variable name "dt" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    s2 = np.empty(times.size)

Variable name "s2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    s2[0] = mu  # should get it from OU.rvs()!!!!
    for i in range(1, times.size):
        ti = times[i - 1]

Variable name "ti" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        y = s2[i - 1]

Variable name "y" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        while ti < times[i]:
            y = y + dt * (theta * (mu - y) + sigma * y * np.random.randn() / np.sqrt(dt))

Variable name "y" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

            ti = ti + dt

Variable name "ti" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        s2[i] = y
    if scale is not None:
        s2 = scale * s2 / np.std(s2)

Variable name "s2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    if loc is not None:
        s2 = s2 - np.mean(s2) + loc

Variable name "s2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    return s2


def lc_gen_psd_c(ts, values, times):

Argument name "ts" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    """Generation using interpolated PSD for light curves with similar PSD, mean and std."""

    f, p = scipy_signal.welch(values, nperseg=ts.size / 2)

Variable name "p" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

Variable name "f" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    fp = np.linspace(min(f), max(f), times.size // 2 + 1)

Variable name "fp" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    pp = np.interp(fp, f, p)

Variable name "pp" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    fft = np.sqrt(2 * pp * pp.size) * np.exp(1j * 2 * np.pi * np.random.random(pp.size))
    s2 = np.fft.irfft(fft, n=values.size)

Variable name "s2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    a = values.std() / s2.std()

Variable name "a" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    b = values.mean() - a * s2.mean()

Variable name "b" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    s2 = a * s2 + b

Variable name "s2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    return s2


def lc_gen_psd_fft(values):
    """Generation using Welch algorithm and the FFT, of synthetic signals with similar PSD, mean and std.

This line is too long as per the coding-style (105/100).

    Generates synthetic light curves using Lomb-Scargle algorithm
    to compute the power spectral density and the non-uniform fft
    to generate the signal."""

    # this is not valid for non-uniform times (see PSD tests for a comparison)
    f, pxx = scipy_signal.welch(values)

The variable f seems to be unused.

Variable name "f" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    # fft2 = np.sqrt(2*Pxx*Pxx.size)*np.exp(1j*2*pi*np.random.randn(Pxx.size))
    fft2 = np.sqrt(2 * pxx * pxx.size) * np.exp(1j * 2 * np.pi * np.random.random(pxx.size))
    s2 = np.fft.irfft(fft2, n=values.size)

Variable name "s2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    a = values.std() / s2.std()

Variable name "a" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    b = values.mean() - a * s2.mean()

Variable name "b" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    s2 = a * s2 + b

Variable name "s2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    return s2


def lc_gen_psd_lombscargle(times, values):
    """Generation using Lomb-Scargle algorithm and the non-uniform FFT, of synthetic signals with similar PSD, mean and std.

This line is too long as per the coding-style (124/100).

    Generates synthetic light curves using Lomb-Scargle algorithm
    to compute the power spectral density and the non-uniform fft
    to reconstruct the randomised signal."""

    if values.size % 2 != 0:
        sigp = values[:-1]
        tp = times[:-1]

Variable name "tp" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    else:
        sigp = values
        tp = times

Variable name "tp" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    offset = 1e-6
    n = sigp.size

Variable name "n" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    # k = np.arange(-n/2, n/2) no bc scipy_signal.lombscargle does not support freq zero
    k = np.linspace(-n / 2, n / 2 - 1 + offset, n)
    freqs = k / 2 / np.pi

    pxx = scipy_signal.lombscargle(tp, sigp, freqs)

    # build random phase to get real signal
    phase = np.random.random(pxx.size // 2)
    phase = np.concatenate((-np.flip(phase), [0], phase[:-1]))
    fft2 = np.sqrt(2 * pxx * pxx.size) * np.exp(1j * 2 * np.pi * phase)
    s2 = (

Variable name "s2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        nfft.nfft((times - (times.max() + times.min()) / 2) / np.ptp(times), fft2, n, use_fft=True)
        / n
    )

    # fix small deviations
    a = values.std() / s2.std()

Variable name "a" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    b = values.mean() - a * s2.mean()

Variable name "b" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    s2 = a * s2 + b

Variable name "s2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    s2 = np.real(s2)    

Variable name "s2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

Trailing whitespace

    s2 = np.asarray(s2, dtype=float, order='C') # workaround for some bug in scipy lombscargle...

Variable name "s2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

Trailing whitespace

    return s2

def lc_gen_psd_nft(times, values):
    """Generation using the non-uniform FFT of synthetic signals with similar PSD, mean and std.

    Generates synthetic light curves using the non-uniform FFT to
    compute the power spectral density and to reconstruct the
    randomised signal."""

    k = np.arange(-times.size / 2, times.size / 2)
    n = 2* (k.size//2)

Variable name "n" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    nft = nfft.nfft_adjoint(
        (times - (times.max() + times.min()) / 2) / np.ptp(times), values, n, use_fft=True
    )

    # build random phase to get real signal
    phase = np.random.random(n // 2)
    phase = np.concatenate((-np.flip(phase), [0], phase[:-1]))

    fft2 = np.abs(nft) * np.exp(1j * 2 * np.pi * phase)
    s2 = (

Variable name "s2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

        nfft.nfft((times - (times.max() + times.min()) / 2) / np.ptp(times), fft2, use_fft=True) / n
    )
    s2 = np.real(s2)  # np.real to fix small imaginary part from numerical error

Variable name "s2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    # fix small mean, std difference from numerical error
    a = values.std() / s2.std()

Variable name "a" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    b = values.mean() - a * s2.mean()

Variable name "b" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    s2 = a * s2 + b

Variable name "s2" doesn't conform to snake_case naming style ('([^\\W\\dA-Z][^\\WA-Z]2,|_[^\\WA-Z]*|__[^\\WA-Z\\d_][^\\WA-Z]+__)$' pattern)

    return s2