'Compute the Lomb-Scargle power at the given frequencies
Parameters
frequency : array_like or Quantity
frequencies (not angular frequencies) at which to evaluate the
periodogram. Note that in order to use method=\'fast\', frequencies
must be regularly-spaced.
method : string (optional)
specify the lomb scargle implementation to use. Options are:
- \'auto\': choose the best method based on the input
- \'fast\': use the O[N log N] fast method. Note that this requires
evenly-spaced frequencies: by default this will be checked unless
``assume_regular_frequency`` is set to True.
- \'slow\': use the O[N^2] pure-python implementation
- \'cython\': use the O[N^2] cython implementation. This is slightly
faster than method=\'slow\', but much more memory efficient.
- \'chi2\': use the O[N^2] chi2/linear-fitting implementation
- \'fastchi2\': use the O[N log N] chi2 implementation. Note that this
requires evenly-spaced frequencies: by default this will be checked
unless ``assume_regular_frequency`` is set to True.
- \'scipy\': use ``scipy.signal.lombscargle``, which is an O[N^2]
implementation written in C. Note that this does not support
heteroskedastic errors.
assume_regular_frequency : bool (optional)
if True, assume that the input frequency is of the form
freq = f0 + df * np.arange(N). Only referenced if method is \'auto\'
or \'fast\'.
normalization : string (optional, default=\'standard\')
Normalization to use for the periodogram.
Options are \'standard\', \'model\', \'log\', or \'psd\'.
fit_mean : bool (optional, default=True)
if True, include a constant offset as part of the model at each
frequency. This can lead to more accurate results, especially in
the case of incomplete phase coverage.
center_data : bool (optional, default=True)
if True, pre-center the data by subtracting the weighted mean of
the input data. This is especially important if fit_mean = False
method_kwds : dict (optional)
additional keywords to pass to the lomb-scargle method
Returns
power : ndarray
The Lomb-Scargle power at the specified frequency'

def power(self, frequency, normalization='standard', method='auto', assume_regular_frequency=False, method_kwds=None):

    frequency = self._validate_frequency(frequency)
    power = lombscargle(frequency=strip_units(frequency), center_data=self.center_data, fit_mean=self.fit_mean, nterms=self.nterms, normalization=normalization, method=method, method_kwds=method_kwds, assume_regular_frequency=assume_regular_frequency, *strip_units(self.t, self.y, self.dy))
    return (power * self._power_unit(normalization))
