U f{jpL @sddlZddlZddlmZddlmZmZmZm Z m Z dddZ d d d Z d dZ ddZd!ddZed"ddZedejdd dddddf ddZed#ddZdS)$N) parallel_func) sum_squaredwarnverboselogger _check_optionTlinearcCsddlm}ddlm}m}ddlm} ddlm} t t |}t t |}t ||} t j|dd} |d k r.||krd |} | d |7} | d 7} t| g}t|||d d\}}|D]`}t |jd}|j|||d}|t jd|jdd|d d}|t t|}||qt |}n | |||}d|d}| |}|||}||||}|d d d |f}d| t d| | }d| |d<t ||}|r|dk}|stdt |g}||||}}t|dkst|jd|kst||fS)aCompute Discrete Prolate Spheroidal Sequences. Will give of orders [0,Kmax-1] for a given frequency-spacing multiple NW and sequence length N. .. note:: Copied from NiTime. Parameters ---------- N : int Sequence length. half_nbw : float Standardized half bandwidth corresponding to 2 * half_bw = BW*f0 = BW*N/dt but with dt taken as 1. Kmax : int Number of DPSS windows to return is Kmax (orders 0 through Kmax-1). low_bias : bool Keep only tapers with eigenvalues > 0.9. interp_from : int (optional) The dpss can be calculated using interpolation from a set of dpss with the same NW and Kmax, but shorter N. This is the length of this shorter set of dpss windows. .. note:: If SciPy 1.1 or greater is available, interpolating is likely not necessary as DPSS computations should be sufficiently fast. interp_kind : str (optional) This input variable is passed to scipy.interpolate.interp1d and specifies the kind of interpolation as a string ('linear', 'nearest', 'zero', 'slinear', 'quadratic, 'cubic') or as an integer specifying the order of the spline interpolator to use. Returns ------- v, e : tuple, The v array contains DPSS windows shaped (Kmax, N). e are the eigenvalues. Notes ----- Tridiagonal form of DPSS calculation from :footcite:`Slepian1978`. References ---------- .. footbibliography:: r) interpolate)rfftirfft)dpssr) next_fast_lendZdtypeNz$In dpss_windows, interp_from is: %s zand N is: %s. z(Please enter interp_from smaller than N.F)low_bias)kind)Zendpointg?z:Could not properly use low_bias, keeping lowest-bias taper) Zscipyr scipy.fftr r Zscipy.signal.windowsr filterrnpZint32operatorindexfloatarange ValueError dpss_windowsshapeZinterp1dZlinspacesqrtrappendarrayconjZsincdotanyrZargmaxlenAssertionError)Nhalf_nbwZKmaxr interp_fromZ interp_kindr r r Zsp_dpssrWZnidxZe_sr reZthis_dxtmpZd_tempZrxx_sizen_fftZdpss_fftZdpss_rxxreigvalsidxr3\/var/www/html/bwave/python/venv/lib/python3.8/site-packages/mne/time_frequency/multitaper.pyr sV0               rFcCs|j\}}}t||kr td|dkr0tdt|}t||tjddtjf} tj| tj|ddtj} ~ t |t |f} |dddd|f}|rt ||| jdf} t t || D]\} \}}t|ddddf|ddtjf}t |}t|D]}||ddtjf|d|ddtjf|}||ddtjf9}||8}ttj|ddd d krqt||}|}q||dkrtd || | ddf<|r|| | ddddf<q|r| | fS| SdS) aUse iterative procedure to compute the PSD from tapered spectra. .. note:: Modified from NiTime. Parameters ---------- x_mt : array, shape=(n_signals, n_tapers, n_freqs) The DFTs of the tapered sequences (only positive frequencies) eigvals : array, length n_tapers The eigenvalues of the DPSS tapers freq_mask : array Frequency indices to keep max_iter : int Maximum number of iterations for weight computation return_weights : bool Also return the weights Returns ------- psd : array, shape=(n_signals, np.sum(freq_mask)) The computed PSDs weights : array shape=(n_signals, n_tapers, np.sum(freq_mask)) The weights used to combine the tapered spectra Notes ----- The weights to use for making the multitaper estimate, such that :math:`S_{mt} = \sum_{k} |w_k|^2S_k^{mt} / \sum_{k} |w_k|^2` z"Need one eigenvalue for each taperz.Not enough tapers to compute adaptive weights.N)Zdxrrraxisg|=z7Iterative multi-taper PSD computation did not converge.)rr&rrr _psd_from_mtnewaxisZtrapzpiemptysum enumeratezipZ zeros_likerangemaxmeanr)x_mtr1 freq_maskZmax_iterZreturn_weightsZ n_signalsn_tapersn_freqsZrt_eigZpsd_estZx_varpsdweightsiZxkvarZpsd_itererrnZd_kr3r3r4_psd_from_mt_adaptive{sD   (   rMcCsD||}||9}|jjdd}|d||jjdd9}|S)zCompute PSD from tapered spectra. Parameters ---------- x_mt : array Tapered spectra weights : array Weights used to combine the tapered spectra Returns ------- psd : array The computed PSD r7r)r#realr=)rCrHrGr3r3r4r9s  r9cCsftj||||dd}t||jjddt||jjdd}|d|9}|S)aCompute CSD from tapered spectra. Parameters ---------- x_mt : array Tapered spectra for x y_mt : array Tapered spectra for y weights_x : array Weights used to combine the tapered spectra of x_mt weights_y : array Weights used to combine the tapered spectra of y_mt Returns ------- psd: array The computed PSD rNr7r)rr=r#r rO)rCZy_mtZ weights_xZ weights_ycsddenomr3r3r4 _csd_from_mts  rRc Csddlm}m}|dkr"|jd}|tj|ddd}||d|}|jdkrX|jdnd}tj|jdd|t|ftj d }t |D],\} } || d tj ddf||d || <q|d t d <|ddkr|dt d <||fS)a Compute tapered spectra. Parameters ---------- x : array, shape=(..., n_times) Input signal dpss : array, shape=(n_tapers, n_times) The tapers sfreq : float The sampling frequency n_fft : int | None Length of the FFT. If None, the number of samples in the input signal will be used. Returns ------- x_mt : array, shape=(..., n_tapers, n_times) The tapered spectra freqs : array The frequency points in Hz of the spectra r)r rfftfreqNrT)r8Zkeepdims?rr.)rL).r@r).r) rr rSrrrBndimzerosr&Z complex128r>r:r ) r-r sfreqr/r rSfreqsrErCr2sigr3r3r4 _mt_spectras & r[c Csddlm}t|trFtd|f|||tj}|tddfS|dk rdt ||d|} nd} | d krt d || ||ft d | } t || | ||d \}} td t | |rt | dkrtdt | fd}|| |fS)z+Triage windowing and multitaper parameters.r) get_windowz7 Using standard spectrum estimation with "%s" windowrFNrUg@g?zXbandwidth value %s yields a normalized bandwidth of %s < 0.5, use a value of at least %sr)rr*z= Using multitaper spectrum estimation with %d DPSS windowsr6zXNot adaptively combining the spectral estimators due to a low number of tapers (%s < 3).)Z scipy.signalr\ isinstancestrrinforr:Zonesrrintrr&r) n_timesrX bandwidthradaptiver*rr\Z window_funr)Z n_tapers_maxr1r3r3r4_compute_mt_paramsFs<     rdglengthpowerc sddlm} td|ddg|j} t|}|jd} |jdd}|d| }t| ||||\}}t |}t tj ddtj f}| | d|}||k||k@|}t |}|d krtj |jd||fd d }nt |jd|f}t d t t d d }ttd|jd||jdgf}t|dd|d dD]\}}t|||||d}|dkr|st|ddddf||||<nRtt| \}} t||| }|fddt||D}t||||<n|ddddf|||<qN|dkr,||}|dkr<|fn||f}|||_| d kr`|d}|d krt|||fS||fSdS)aECompute power spectral density (PSD) using a multi-taper method. Parameters ---------- x : array, shape=(..., n_times) The data to compute PSD from. sfreq : float The sampling frequency. fmin : float The lower frequency of interest. fmax : float The upper frequency of interest. bandwidth : float The bandwidth of the multi taper windowing function in Hz. adaptive : bool Use adaptive weights to combine the tapered spectra into PSD (slow, use n_jobs >> 1 to speed up computation). low_bias : bool Only use tapers with more than 90%% spectral concentration within bandwidth. %(normalization)s output : str The format of the returned ``psds`` array. Can be either ``'complex'`` or ``'power'``. If ``'power'``, the power spectral density is returned. If ``output='complex'``, the complex fourier coefficients are returned per taper. %(n_jobs)s %(verbose)s Returns ------- psds : ndarray, shape (..., n_freqs) or (..., n_tapers, n_freqs) The power spectral densities. All dimensions up to the last (or the last two if ``output='complex'``) will be the same as input. freqs : array The frequency points in Hz of the PSD. weights : ndarray The weights used for averaging across tapers. Only returned if ``output='complex'``. See Also -------- mne.io.Raw.plot_psd mne.Epochs.plot_psd csd_multitaper psd_multitaper Notes ----- .. versionadded:: 0.14.0 r)rS normalizationrefullrNrTcomplexrirrfc3s|]}|VqdS)Nr3).0r-r1rDZmy_psd_from_mt_adaptiver3r4 sz'psd_array_multitaper..)rrSrrVrZ atleast_2drZreshaperdr&r r:rWrAZ concatenaterr?r[r9rrMminZ array_split)r-rXZfminZfmaxrbrcrrgoutputn_jobsrrSZndim_inraZdshaper rErHrYrFrGZn_chunkoffsetsstartstoprCparallelZn_splitsoutZ last_dimsr3rlr4psd_array_multitaperls^7     &" & "     rv@rric Cs,ddlm} | |||d||||||| | d S)a Compute Time-Frequency Representation (TFR) using DPSS tapers. Same computation as `~mne.time_frequency.tfr_multitaper`, but operates on :class:`NumPy arrays ` instead of `~mne.Epochs` objects. Parameters ---------- epoch_data : array of shape (n_epochs, n_channels, n_times) The epochs. sfreq : float | int Sampling frequency of the data. freqs : array-like of float, shape (n_freqs,) The frequencies. n_cycles : float | array of float Number of cycles in the wavelet. Fixed number or one per frequency. Defaults to 7.0. zero_mean : bool If True, make sure the wavelets have a mean of zero. Defaults to True. time_bandwidth : float If None, will be set to 4.0 (3 tapers). Time x (Full) Bandwidth product. The number of good tapers (low-bias) is chosen automatically based on this to equal floor(time_bandwidth - 1). Defaults to None. use_fft : bool Use the FFT for convolutions or not. Defaults to True. decim : int | slice To reduce memory usage, decimation factor after time-frequency decomposition. Defaults to 1. If `int`, returns tfr[..., ::decim]. If `slice`, returns tfr[..., decim]. .. note:: Decimation may create aliasing artifacts, yet decimation is done after the convolutions. output : str, default 'complex' * 'complex' : single trial per taper complex values. * 'power' : single trial power. * 'phase' : single trial per taper phase. * 'avg_power' : average of single trial power. * 'itc' : inter-trial coherence. * 'avg_power_itc' : average of single trial power and inter-trial coherence across trials. %(n_jobs)s The number of epochs to process at the same time. The parallelization is implemented across channels. Defaults to 1. %(verbose)s Returns ------- out : array Time frequency transform of epoch_data. If ``output in ['complex', 'phase']``, then the shape of ``out`` is ``(n_epochs, n_chans, n_tapers, n_freqs, n_times)``; if output is 'power', the shape of ``out`` is ``(n_epochs, n_chans, n_freqs, n_times)``, else it is ``(n_chans, n_freqs, n_times)``. If output is 'avg_power_itc', the real values in ``out`` contain the average power and the imaginary values contain the ITC: ``out = avg_power + i * itc``. See Also -------- mne.time_frequency.tfr_multitaper mne.time_frequency.tfr_morlet mne.time_frequency.tfr_array_morlet mne.time_frequency.tfr_stockwell mne.time_frequency.tfr_array_stockwell Notes ----- .. versionadded:: 0.14.0 r) _compute_tfrZ multitaper) rXmethodn_cycles zero_meantime_bandwidthuse_fftdecimrorpr)Ztfrrx) Z epoch_datarXrYrzr{r|r}r~rorprrxr3r3r4tfr_array_multitapersK r)TNr )r5F)N)NN)rwTNTrriNN)rnumpyrrtrutilsrrrrrrrMr9rRr[rdinfrvrr3r3r3r4sF  n m . % q