U f{j  @sddlmZddlmZddlZddlmZddlm Z ddl m Z dd l m Z dd lmZdd lmZdd lmZmZmZdd lmZmZmZmZddlmZddlmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%ddl&m'Z'm(Z(m)Z)m*Z*ddl+m,Z,m-Z-m.Z.m/Z/m0Z0ddl1m2Z2ddl3m4Z4m5Z5ddl6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?ddl@mAZAmBZBmCZCmDZDmEZEmFZFddlGmHZHddlImJZJmKZKddlLmMZMmNZNddlOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYdZZGddde[Z\ddZ]eRdd d!d"Z^eRd#dd$d%d&Z_d'd(Z`dWd)d*Zad+d,ZbdXd.d/ZceRdYd1d2ZdeRdZd3d4Zed[d5d6Zfd\d7d8Zgd9d:ZheRd]dInverseOperator class to represent info from inverse operator.cCs tt|S)z%Return a copy of the InverseOperator.)rIr)selfrKW/var/www/html/bwave/python/venv/lib/python3.8/site-packages/mne/minimum_norm/inverse.pycopy5szInverseOperator.copycCsttt|dddd}tt|dddd}|djd|dd}tjd tjd tjd i}||d }||||fS) NinfoTF)Zmegeegsrcz with nsourcez sourcesUnknownZFixedZFree source_ori)lenrkindr ZFIFFV_MNE_UNKNOWN_ORIZFIFFV_MNE_FIXED_ORIFIFFV_MNE_FREE_ORI)rJ n_chs_meg n_chs_eegsrc_space_descrZsrc_ori_fiff_to_name_mapsrc_orirKrKrL_get_chs_and_src_info_for_repr9s z.InverseOperator._get_chs_and_src_info_for_reprcCs\|}|\}}}}d}|d|7}|d|7}|d|7}|d|7}|d7}|S)z/Summarize inverse info instead of printing all.z)r[)rJ repr_inforWrXrYrZZentrrKrKrL__repr__Gs zInverseOperator.__repr__c CsJddlm}|}|\}}}}|d}|j|d|d||d}|S)Nr)repr_templates_envzinverse_operator.html.jinjaz MEG, z EEG)ZchannelsZsource_space_descrZsource_orientation)Zhtml_templatesr_r[Z get_templaterender) rJr_r]rWrXrYrZthtmlrKrKrL _repr_html_Ts   zInverseOperator._repr_html_N)__name__ __module__ __qualname____doc__rMr[r^rcrKrKrKrLrI2s  rIc CsPt}|djD]:}z|||Wqtk rHtd|YqXq|S)zReturn data channel indices to be used knowing an inverse operator. Unlike ``pick_channels``, this respects the order of ch_names. noise_covzThe inverse operator was computed with channel %s which is not present in the data. You should compute a new inverse operator restricted to the good data channels.)listch_namesappendindex ValueError)rjinvselnamerKrKrL_pick_channels_inverse_operatorbsrq)r=c Cst|ddt|ddd}td|t|\}}}|x}t|tj}|dks^t|dkrjt d ||d }t|tj }t|d krt d ||d }td t ||tj }|dkrt d t } t|j| d<t ||tj}|dkrt dt|j| d<t ||tj}|dkr&t dt|j| d<d | d<t ||tj}|dkr\t d|j| d<t ||tj}tjdtjdtjdi} | tt|ddd| d<t ||tj}|dkrt d|j| d<tdtdt ||tj}|dkrt d |j| d!<t| d!| d<d"| d#<t||tjdd$| d%<| d%dkrhd| d#<t||tjdd$| d%<| d%dkr~td&t||tj| d'<tdt ft!||tj"dd(| d)<td*t!||tj#| d+<td,t!||tj$| d-<| d-dk rtd.t!||tj%| d/<| d/dk r0td0t!||tj&| d1<| d1dk rZtd2t'||d"d3| d4<| d4D]} t(| | d5<qtt ||tj)}|dkrt d6t*|jd7d8} | | d9<t+||| d:<| dtj,tj-fkrt d;d| d<<t.||| d=<g| d><g| d?<g| d@<g| dA<d } t/t| d4D]p}z$t0| d4|| d| | d4|<Wn0t k r}zt dB|W5d}~XYnX| | d4|dC7} q4tdDW5QRXt1| S)EaqRead the inverse operator decomposition from a FIF file. Parameters ---------- fname : str The name of the FIF file, which ends with -inv.fif or -inv.fif.gz. %(verbose)s Returns ------- inv : instance of InverseOperator The inverse operator. See Also -------- write_inverse_operator, make_inverse_operator inverse operatorz-inv.fifz -inv.fif.gzz_inv.fifz _inv.fif.gzTread)fnameZ must_exist overwritez1Reading inverse operator decomposition from %s...NrzNo inverse solutions in %srzNo parent MRI information in %sz$ Reading inverse operator info...zModalities not foundmethodsz(Source orientation constraints not foundrSzNumber of sources not foundrQnchanzCoordinate frame tag not found coord_frameAmAm/m^2Am/m^3dataunitsz(Source orientation information not found source_nn [done]z- Reading inverse operator decomposition...zSingular values not foundsingFeigen_leads_weighted)Z transpose eigen_leadsz*Eigen leads not found in inverse operator. eigen_fields)Zlimitedrhz! Noise covariance matrix read. source_covz" Source covariance matrix read. orient_priorz Orientation priors read. depth_priorz Depth priors read. fmri_priorz fMRI priors read.)Z patch_statsrPidz,MRI/head coordinate transformation not foundZmrihead mri_head_trNzIOnly inverse solutions computed in MRI or head coordinates are acceptablenaveprojsprojwhitenerreginv noisenormz%Could not transform source space (%s)nusezF Source spaces transformed to the inverse solution coordinate frame)2r;rDr<rNr rr FIFFB_MNE_INVERSE_SOLUTIONrT ExceptionFIFFB_MNE_PARENT_MRI_FILEr FIFF_MNE_INCLUDED_METHODSdictintr}FIFF_MNE_SOURCE_ORIENTATIONFIFF_MNE_SOURCE_SPACE_NPOINTSFIFF_MNE_COORD_FRAMEFIFF_MNE_INVERSE_SOURCE_UNIT FIFF_UNIT_AMFIFF_UNIT_AM_M2FIFF_UNIT_AM_M3getgetattr$FIFF_MNE_INVERSE_SOURCE_ORIENTATIONSFIFF_MNE_INVERSE_SINGr FIFF_MNE_INVERSE_LEADSFIFF_MNE_INVERSE_LEADS_WEIGHTEDrmFIFF_MNE_INVERSE_FIELDSr#r!ZFIFFV_MNE_NOISE_COVFIFFV_MNE_SOURCE_COVFIFFV_MNE_ORIENT_PRIOR_COVFIFFV_MNE_DEPTH_PRIOR_COVZFIFFV_MNE_FMRI_PRIOR_COVr0r2ZFIFF_COORD_TRANSr7r)ZFIFFV_COORD_MRIZFIFFV_COORD_HEADrranger8rI)rur=ftree_fidZinvsZ parent_mritagrnZ unit_dictsrrkinstrKrKrLread_inverse_operatorts                             rF)rvr=c CsTt|ddt||d}t|tdtd|t|}t||W5QRXdS)aJWrite an inverse operator to a FIF file. Parameters ---------- fname : str The name of the FIF file, which ends with -inv.fif or -inv.fif.gz. inv : dict The inverse operator. %(overwrite)s .. versionadded:: 1.0 %(verbose)s See Also -------- read_inverse_operator rrrs)rurvrnz-Write inverse operator decomposition in %s...N)r;rDr?rIr<rNr_write_inverse_operator)rurnrvr=rrKrKrLwrite_inverse_operatorQs     rcCst|tjt||dt|tjt|tj|ddt||dt|tjt ||dd|krzt ||dt|tj t dt|tj|dt|tj|dtjtjtjd }d |kr|d dk rt|tj||d t|tj|d t|tj|d d |kr2t|tj|d n$d |dkrVt|tj|dd t|tj|dt|tj|dt dt||dt dt||dt d|ddk rt||d|ddk rt||d|ddk rt||dt|tj|d|dr,tj}ntj }t!|dt|||dt!|dt dt|tj t|tjdS)NrNZmri_filerrrPz$ Writing inverse operator info...rwry)rzr{r|rrSrQrxrrz$ Writing noise covariance matrix.rhz% Writing source covariance matrix.rz Writing orientation priors.rrrrrrr)"rr Z FIFFB_MNEr.rrZFIFF_MNE_FILE_NAMErrrr4rr<rNrrrrrrrrrZ FIFF_NCHANrrrrr"rrrrr )rrnZudictrUrKrKrLrtsd              rcCs|jdkrtd|jdddkr,tdt|r@t|}|dddd}||dddd7}||dddd7}|st|}|S)aXCompute the three Cartesian components of a vector or matrix together. Parameters ---------- vec : 2d array of shape [3 n x p] Input [ x1 y1 z1 ... x_n y_n z_n ] where x1 ... z_n can be vectors Returns ------- comb : array Output vector [sqrt(x1^2+y1^2+z1^2), ..., sqrt(x_n^2+y_n^2+z_n^2)] rzInput must be 2DrzInput must have 3N rowsNr)ndimrmshapenpZ iscomplexobjabsr)ZvecZsquarecombrKrKrL combine_xyzs    rcCsv|dd}|dj|kr"td|d}tt|t|}t|}|dkrbtd|d|t|d |d d S) z9Check that channels in inverse operator are measurements.r col_namesrhzQChannels in inverse operator eigen fields do not match noise covariance channels.rjrz %d channels in inverse operator z are not present in the data (%s)rNZinverseN)rjrmsortedsetrTr@)rnrNZ inv_ch_namesZ data_ch_namesZmissing_ch_namesZ n_missingrKrKrL_check_ch_namess rTcCs.|st||||||d}nd|kr*td|S)z-Check if inverse was prepared, or prepare it.rMcolorerzinverse operator has not been prepared, but got argument prepared=True. Either pass prepared=False or use prepare_inverse_operator.)prepare_inverse_operatorrm)rnrlambda2method method_paramspreparedrMrKrKrL_check_or_preparesrrFc Csddlm}|dkrtdt|ttfdt|trFtd|dddt d|}|r|d } |d krpd |d <z | }W5| |d <X|d kr| |d <~t |d |} | |d d|d d<|d dj dkrt d|d d|d d<t t|d d|d d<| |d d|d d<| |dd|dd<|drht| |dd|dd<t d|d |f||d <t|||d<t dt|d|d d\|d<} } | dkrt d| n t dt|d ddd \|d!<} |d"<g|d#<|d$kr$t|||nh|d%krt d&||d'krP|d} n,|d(kr||dt d)|d*d+|} t |dd,}|d-|f\}|drt|dd,D].}|dd|d d f| }||||<qnTt|dd,D]B}t|dd||dd|d d f| }||||<q|d.tjkrft|d d d f}d)t ||d#<t d/ng|d#<t|S)0aPrepare an inverse operator for actually computing the inverse. Parameters ---------- orig : dict The inverse operator structure read from a file. nave : int Number of averages (scales the noise covariance). lambda2 : float The regularization factor. Recommended to be 1 / SNR**2. method : "MNE" | "dSPM" | "sLORETA" | "eLORETA" Use minimum norm, dSPM (default), sLORETA, or eLORETA. method_params : dict | None Additional options for eLORETA. See Notes of :func:`apply_inverse`. .. versionadded:: 0.16 copy : bool | str If True (default), copy the inverse. False will not copy. Can be "non-src" to avoid copying the source space, which typically is not modified and can be large in memory. .. versionadded:: 0.21 %(verbose)s Returns ------- inv : instance of InverseOperator Prepared inverse operator. r)linalgz)The number of averages should be positiverM)non-srcz when a string)extraz)Preparing the inverse operator for use...rPrNrrhr}rz# Diagonal noise covariance foundeigeigvecrrrzB Scaled noise and source covariance from nave = %d to nave = %drz$ Created the regularized inverterrnamesrz5 Created an SSP operator (subspace dimension = %d)z: The projection vectors do not apply to these channels.whiteT)pcaZreturn_colorerrrrrHrEz1 Computing noise-normalization factors (%s)...rFrG?rrnrow)nrm2rS[done])Zscipyrrmr?boolstr isinstancerAr<rNrMfloatrreyerTr_compute_reginvrr rZzerosZget_blas_funcsrr rVrravelrrI)origrrrrrMr=rrnrPscalencomprZ noise_weight noise_normrronerKrKrLr s                    rcCs|dd}|dd}|dkr8|dddtjf}nd}|d} t| } |d} |dk rt|| \} } |d krz|| }|d tjkrd | } tj| | d | d f} | } || }|| }| | } |dkrtdd| Drtj |d |dd d t d ddrd} t |dd |j d f }t | d } t| | D]N\}}t| | t|}tt|||| |<t| |||||<|j} qJd|j d f|_ d| _ |dkr|d tjkstdd|dddkod kn}|stdt|ddt|d|d}||ddddf9}t||}|drdtd n&td!|t|ddtjf9}|dkr|d dd }||| | fS)"a]Assemble the kernel. Simple matrix multiplication followed by combination of the current components. This does all the data transformations to compute the weights for the eigenleads. Parameters ---------- inv : instance of InverseOperator The inverse operator to use. This object contains the matrices that will be multiplied to assemble the kernel. label : Label | None Restricts the source estimates to a given label. If None, source estimates will be computed for the entire source space. method : "MNE" | "dSPM" | "sLORETA" | "eLORETA" Use minimum norm, dSPM, sLORETA, or eLORETA. pick_ori : None | "normal" | "vector" Which orientation to pick (only matters in the case of 'normal'). %(use_cps_restricted)s Returns ------- K : array, shape (n_vertices, n_channels) | (3 * n_vertices, n_channels) The kernel matrix. Multiply this with the data to obtain the source estimate. noise_norm : array, shape (n_vertices, n_samples) | (3 * n_vertices, n_samples) Normalization to apply to the source estimate in order to obtain dSPM or sLORETA solutions. vertices : list of length 2 Vertex numbers for lh and rh hemispheres that correspond to the vertices in the source estimate. When the label parameter has been set, these correspond to the vertices in the label. Otherwise, all vertex numbers are returned. source_nn : array, shape (3 * n_vertices, 3) The direction in cartesian coordicates of the direction of the source dipoles. rr}r)rFrGrNrPr)rErHrSrrrnormalcss|]}|ddkVqdS)typeZsurfNrK).0rrKrKrL sz#_assemble_kernel..rQgư>)Zatolrr~)r~rr)r~rzUPicking normal orientation can only be done with a free orientation inverse operator.rzQPicking normal orientation can only be done when working with loose orientations.rrrrrz$ Eigenleads already weighted ... z& Eigenleads need to be weighted ...)rnewaxisr3r5r rVZc_rallZallclosereshaperrrMzipslicerTr6r1matmulstoprmdotr<rNr)rnlabelrpick_oriuse_cpsr=rrrrPvertnorZsrc_seloffsetrvslZis_looseZtransKrKrKrL_assemble_kernelsp'    &     rcCs td|dddgt||dS)zCheck pick_ori.rNrvector)rArC)rrSrPZ allow_vectorrKrKrL _check_ori"srcs\|j}dk r4fddt|dD}t||d}t|rDtd|ddrXtd dS) zCheck for EEG ref.Ncsg|]\}}|kr|qSrKrK)rciZch_namerjrKrL ,sz$_check_reference..rj)rozvEEG average reference (using a projector) is mandatory for modeling, use the method set_eeg_reference(projection=True)Zcustom_ref_appliedFz9Custom EEG reference is not allowed for inverse modeling.)rN enumeraterrrmr)rrjrNZpicksrKrrL_check_reference(s  rcCs |djS)z%Get subject id from inverse operator.rP)Z_subject)inverse_operatorrKrKrL_subject_from_inverse8srqq?c Cs(t|||||||||| } td| S)a Apply inverse operator to evoked data. Parameters ---------- evoked : Evoked object Evoked data. inverse_operator : instance of InverseOperator Inverse operator. lambda2 : float The regularization parameter. method : "MNE" | "dSPM" | "sLORETA" | "eLORETA" Use minimum norm :footcite:`HamalainenIlmoniemi1994`, dSPM (default) :footcite:`DaleEtAl2000`, sLORETA :footcite:`Pascual-Marqui2002`, or eLORETA :footcite:`Pascual-Marqui2011`. %(pick_ori)s prepared : bool If True, do not call :func:`prepare_inverse_operator`. label : Label | None Restricts the source estimates to a given label. If None, source estimates will be computed for the entire source space. method_params : dict | None Additional options for eLORETA. See Notes for details. .. versionadded:: 0.16 return_residual : bool If True (default False), return the residual evoked data. Cannot be used with ``method=='eLORETA'``. .. versionadded:: 0.17 %(use_cps_restricted)s .. versionadded:: 0.20 %(verbose)s Returns ------- stc : SourceEstimate | VectorSourceEstimate | VolSourceEstimate The source estimates. residual : instance of Evoked The residual evoked data, only returned if return_residual is True. See Also -------- apply_inverse_raw : Apply inverse operator to raw object. apply_inverse_epochs : Apply inverse operator to epochs object. Notes ----- Currently only the ``method='eLORETA'`` has additional options. It performs an iterative fit with a convergence criterion, so you can pass a ``method_params`` :class:`dict` with string keys mapping to values for: 'eps' : float The convergence epsilon (default 1e-6). 'max_iter' : int The maximum number of iterations (default 20). If less regularization is applied, more iterations may be necessary. 'force_equal' : bool Force all eLORETA weights for each direction for a given location equal. The default is None, which means ``True`` for loose-orientation inverses and ``False`` for free- and fixed-orientation inverses. See below. The eLORETA paper :footcite:`Pascual-Marqui2011` defines how to compute inverses for fixed- and free-orientation inverses. In the free orientation case, the X/Y/Z orientation triplet for each location is effectively multiplied by a 3x3 weight matrix. This is the behavior obtained with ``force_equal=False`` parameter. However, other noise normalization methods (dSPM, sLORETA) multiply all orientations for a given location by a single value. Using ``force_equal=True`` mimics this behavior by modifying the iterative algorithm to choose uniform weights (equivalent to a 3x3 diagonal matrix with equal entries). It is necessary to use ``force_equal=True`` with loose orientation inverses (e.g., ``loose=0.2``), otherwise the solution resembles a free-orientation inverse (``loose=1.0``). It is thus recommended to use ``force_equal=True`` for loose orientation and ``force_equal=False`` for free orientation inverses. This is the behavior used when the parameter ``force_equal=None`` (default behavior). References ---------- .. footbibliography:: r)_apply_inverser<rN) evokedrrrrrrrreturn_residualrr=outrKrKrL apply_inverse=s_ r cCsT||}d||j||j}|d9}t|d|dd|S)Nrdz Explained z5.1fz % variance)Zconjsumrealr<rN)r}ZestprefixresZvar_exprKrKrL _log_exp_varsr c  Csrt|tdt||ddtd|tt||d|d|j} t||jt || ||||dd} ~t |j | } t d |j ft d t| t d t| |||| d \} }}}t| |j| }t d | d| d}t| dt| d|j| }t| dd|}t| dt| ddj|ddtjf|}t| dt| d|}t|||r|}|j| |8<| dtjko|dk}|r|dkrt dt|}|dk rt d|f|r |dkr |jddd}||9}d|jd}t|jd}t| }t| d|}t||||||dk||d}|rn||fS|S)NrrNrjrrSrPrrz$Applying inverse operator to "%s"...$ Picked %d channels from the data Computing inverse...)rz Computing residual...rrrrrr}rrr' Combining the current components...z %s...rraxisrsfreqtmintstepsubjectrrsrc_type) r?r'rrAINVERSE_METHODSrrrrNrrqrjr<commentrTrrrr}Trr rMr rVrrepeatrtimesrr:r9)rrrrrrrrrrrrnrorrrrsolPiZdata_wZw_tZdata_estZ data_est_wZresidual is_free_orirrrrstcrKrKrLrs~              rc# Cst|tdt||ddtd|tt| |d|dt||jt||||| | }t |j |}t dt dt |t d ||||f\}}|d k r||}t |||| | \}}}}|dtjko| d k}| d k r|rtt|jd t| }t d ||jd }| dkr8|jdn |jdd}tj||ft||d}td|| D]j}t||d d ||| f}| dkrt|}||d d ||| f<t d|| d |fqln.t||}|r| dkrt dt|}|d k r8| dkr0|r0|jddd}||9}t|d}d|jd}t|} t|d|}!t||||| | dk||!d}"t d|"S)aApply inverse operator to Raw data. Parameters ---------- raw : Raw object Raw data. inverse_operator : dict Inverse operator. lambda2 : float The regularization parameter. method : "MNE" | "dSPM" | "sLORETA" | "eLORETA" Use minimum norm, dSPM (default), sLORETA, or eLORETA. label : Label | None Restricts the source estimates to a given label. If None, source estimates will be computed for the entire source space. start : int Index of first time sample (index not time is seconds). stop : int Index of first time sample not to include (index not time is seconds). nave : int Number of averages used to regularize the solution. Set to 1 on raw data. time_func : callable Linear function applied to sensor space time series. %(pick_ori)s buffer_size : int (or None) If not None, the computation of the inverse and the combination of the current components is performed in segments of length buffer_size samples. While slightly slower, this is useful for long datasets as it reduces the memory requirements by approx. a factor of 3 (assuming buffer_size << data length). Note that this setting has no effect for fixed-orientation inverse operators. prepared : bool If True, do not call :func:`prepare_inverse_operator`. method_params : dict | None Additional options for eLORETA. See Notes of :func:`apply_inverse`. .. versionadded:: 0.16 %(use_cps_restricted)s .. versionadded:: 0.20 %(verbose)s Returns ------- stc : SourceEstimate | VectorSourceEstimate | VolSourceEstimate The source estimates. See Also -------- apply_inverse_epochs : Apply inverse operator to epochs object. apply_inverse : Apply inverse operator to evoked object. rawrNrjrrSrPzApplying inverse to raw...r rNrrzQ computing inverse and combining the current components (using %d segments)...rrrdtypez segment %d / %d done..z' combining the current components...rrrrr)r?rrrArrrrNrrqrjr<rTrr rVrrceilrremptyZ result_typerrrrrr:r9)#r!rrrrstartrrZ time_funcr buffer_sizerrrr=rnror}rrrrrrZn_segn_timesZ n_dipolesrposZ sol_chunkrrrrr rKrKrLapply_inverse_raws<          "         r*c  cst|tdtd|tt||d|dt||jt||||||} t|j | } t dt | t dt | |||| \} }}}d|jd}|j d }t|p|d k }|d kr|d k r|jd d d}|s|d k r| |9} t|}zdt |f}Wn&tk r&dt |jf}YnXt|D]\}}t d|d|f|rt| || }|d krt dt|}|d k r||9}n2t | | jdkr| || f}nt| || }t|d|}t||||||d k||d}|Vq0t dd S)zDGenerate inverse solutions for epochs. Used in apply_inverse_epochs.epochsrrSrP Picked %d channels from the datazComputing inverse...rrrrrNrrz / %dz / %d (at most)zProcessing epoch : %d%srz#combining the current components...rr)r?r%rArrrrNrrqrjr<rTrrr*rr RuntimeErroreventsrrrrrr:r9)r+rrrrrrrrrr=rnrorrrrrrrrtotalrerrr rKrKrL_apply_inverse_epochs_genusl                r1c Cs4t|||||||| || | d } |s0dd| D} | S)aApply inverse operator to Epochs. Parameters ---------- epochs : Epochs object Single trial epochs. inverse_operator : dict Inverse operator. lambda2 : float The regularization parameter. method : "MNE" | "dSPM" | "sLORETA" | "eLORETA" Use minimum norm, dSPM (default), sLORETA, or eLORETA. label : Label | None Restricts the source estimates to a given label. If None, source estimates will be computed for the entire source space. nave : int Number of averages used to regularize the solution. Set to 1 on single Epoch by default. %(pick_ori)s return_generator : bool Return a generator object instead of a list. This allows iterating over the stcs without having to keep them all in memory. prepared : bool If True, do not call :func:`prepare_inverse_operator`. method_params : dict | None Additional options for eLORETA. See Notes of :func:`apply_inverse`. .. versionadded:: 0.16 %(use_cps_restricted)s .. versionadded:: 0.20 %(verbose)s Returns ------- stc : list of (SourceEstimate | VectorSourceEstimate | VolSourceEstimate) The source estimates for all epochs. See Also -------- apply_inverse_raw : Apply inverse operator to raw object. apply_inverse : Apply inverse operator to evoked object. )rrrrr=rrrcSsg|]}|qSrKrK)rr rKrKrLrsz(apply_inverse_epochs..)r1) r+rrrrrrZreturn_generatorrrrr=ZstcsrKrKrLapply_inverse_epochss 0r2c  sttt|tdtd|} fdd| D} t|t|d| dd}ttt |d||dd }|d t j k}t d |d |r|d krd}d}n|}d}t |||||||| d| d }t|jd|jjdf}j| d d | f|j}tj||jddd}|jjd dd|_|||j|j|j|j}|rxtdtj|j|jd|}|j|j9_td|S)aqApply inverse operator to covariance data. Parameters ---------- cov : instance of Covariance Covariance data, computed on the time segment for which to compute source power. %(info_not_none)s Used specify the channels to include. inverse_operator : instance of InverseOperator Inverse operator. nave : int Number of averages used to regularize the solution. lambda2 : float The regularization parameter. method : "MNE" | "dSPM" | "sLORETA" | "eLORETA" Use minimum norm, dSPM (default), sLORETA, or eLORETA. %(pick_ori_novec)s prepared : bool If True, do not call :func:`prepare_inverse_operator`. label : Label | None Restricts the source estimates to a given label. If None, source estimates will be computed for the entire source space. method_params : dict | None Additional options for eLORETA. See Notes for details. %(use_cps)s %(verbose)s Returns ------- stc : SourceEstimate | VectorSourceEstimate | VolSourceEstimate The source estimates. See Also -------- apply_inverse : Apply inverse operator to evoked object. apply_inverse_raw : Apply inverse operator to raw object. apply_inverse_epochs : Apply inverse operator to epochs object. Notes ----- .. versionadded:: 0.20 This code is based on the original research code from :footcite:`Sabbagh2020` and has been useful to correct for individual field spread using source localization in the context of predictive modeling. References ---------- .. footbibliography:: rrcsg|]}d|qS)rrK)ridxcovrKrLr4sz%apply_inverse_cov..rjT)orderedr5)rrrSr)NrNrF)rrr~r)rZkeepdims)rrrr)r?r#rIrqrrr&rrrTr rVrArrr}rrr __class__Zverticesrrrr<rNrZ magnitude)r5rNrrrrrrrrrr=roZ use_namesrrZuse_oricombiner rrrKr4rLapply_inverse_covsf7      r:c  Cs|}t|d||}~tdd|D} tdd|D}| rnt|dkr^tdd|krntd|dddkrtd |d k rt|}|d krtd ||pd }| rt |s| rt d t |ddddn|d k r| stdn.css|]}|dkVqdS)rNrKr;rKrKrLrxsrz]Computing inverse solutions for mixed source spaces with fixed orientations is not supported.volumez^Computing inverse solutions for volume source spaces with fixed orientations is not supported.zoComputing inverse solutions with restricted orientations (loose < 1) is not supported for volume source spaces.Nrz9depth exponent should be greater than or equal to 0, got z0Converting forward solution to fixed orientationTF) force_fixedrrMzFor a fixed orientation inverse solution with depth weighting, the forward solution must be free-orientation and in surface orientationziForward operator has fixed orientation and can only be used to make a fixed-orientation inverse operator.surf_oriz2Converting forward solution to surface orientation)r>rrMrzSelected %d channelsrj)explimit_depth_chsrlimitrhrankz` Picked elements from a free-orientation depth-weighting prior into the fixed-orientation onerr)r>r=rrM)loosezWhitening the forward solution.)rr=rBrr}z%Creating the source covariance matrixr"r7z#Adjusting source covariance matrix.Zfro)ordr)rMr/rvaluesanyrTrmrrr*r<rNr,r-r(AssertionErrorr+r$r rronesrr#rrZnormr)forwardrNrhfixedrCrBrrr?r@rZallow_fixed_depthrAZ fixed_inverseZconstrained_inverseZ info_pickedrrrrgain source_std trace_GRGTn_nzerorrKrKrL_prepare_forwardZs                  rOauto皙?c snt|d}t|||||fd|d|\ } } } } } }}}tt| dddddd d d d d tdd }fdd|dD|dd<|d~~~~tdt| dd\}}}~ tdt |td|dd|j dd|ddk dt|j | dg|j d|j dd}t|j |j d|j dggd }d}d}t | d!D]6}t| |}|d"krd#}|d$ks|d%krrd#}qr|r|rtj}n|rtj}ntj}| d k rt| tjgd#gd d | jdgd& } | d k r&t| tjgd#gd d | jdgd& } t| | | jtjd#ggd d dgd' }|j|||d(| ||| |d) t|S)*a Assemble inverse operator. Parameters ---------- %(info_not_none)s Specifies the channels to include. Bad channels (in ``info['bads']``) are not used. forward : dict Forward operator. noise_cov : instance of Covariance The noise covariance matrix. %(loose)s %(depth)s fixed : bool | 'auto' Use fixed source orientations normal to the cortical mantle. If True, the loose parameter must be "auto" or 0. If 'auto', the loose value is used. %(rank_none)s %(use_cps)s %(verbose)s Returns ------- inv : instance of InverseOperator Inverse operator. Notes ----- For different sets of options (**loose**, **depth**, **fixed**) to work, the forward operator must have been loaded using a certain configuration (i.e., with **force_fixed** and **surf_ori** set appropriately). For example, given the desired inverse type (with representative choices of **loose** = 0.2 and **depth** = 0.8 shown in the table in various places, as these are the defaults for those parameters): +---------------------+-----------+-----------+-----------+-----------------+--------------+ | Inverse desired | Forward parameters allowed | +=====================+===========+===========+===========+=================+==============+ | | **loose** | **depth** | **fixed** | **force_fixed** | **surf_ori** | +---------------------+-----------+-----------+-----------+-----------------+--------------+ | | Loose constraint, | 0.2 | 0.8 | False | False | True | | | Depth weighted | | | | | | +---------------------+-----------+-----------+-----------+-----------------+--------------+ | | Loose constraint | 0.2 | None | False | False | True | +---------------------+-----------+-----------+-----------+-----------------+--------------+ | | Free orientation, | 1.0 | 0.8 | False | False | True | | | Depth weighted | | | | | | +---------------------+-----------+-----------+-----------+-----------------+--------------+ | | Free orientation | 1.0 | None | False | False | True | False | +---------------------+-----------+-----------+-----------+-----------------+--------------+ | | Fixed constraint, | 0.0 | 0.8 | True | False | True | | | Depth weighted | | | | | | +---------------------+-----------+-----------+-----------+-----------------+--------------+ | | Fixed constraint | 0.0 | None | True | True | True | +---------------------+-----------+-----------+-----------+-----------------+--------------+ Also note that, if the source space (as stored in the forward solution) has patch statistics computed, these are used to improve the depth weighting. Thus slightly different results are to be expected with and without this information. For depth weighting, 0.8 is generally good for MEG, and between 2 and 5 is good for EEG, see :footcite:`LinEtAl2006a`. References ---------- .. footbibliography:: Z depth_mner)rrrFrSrrQrzryrrPNrN) rrrSrrQrryrrPrrNcs g|]}|ddkr|qS)rNrjrK)rbadrIrKrLr?sz)make_inverse_operator..badsz9Computing SVD of whitened and weighted lead field matrix.)Z full_matricesz largest singular value = %gz) scaling factor to adjust the trace = gz (nchan = rz nzero = r)rjr)r}r row_namesrncol)r}rrXrWrrxrOTmagZgrad) r}rUrTdiagrrrdimnfreer) r}r[rUrZrrrrr\rTr) rrrrrrrhrrw)rBrOrrZ_check_consistencyr<rNrrmaxrrrrrr ZFIFFV_MNE_MEG_EEGZ FIFFV_MNE_MEGZ FIFFV_MNE_EEGrsizerrupdaterI)rNrIrhrCdepthrJrBrr=Z gain_inforKrrrLrMrrnrrrZhas_megZhas_eegr3Zch_typerwrrKrSrLmake_inverse_operatorsI      2       rac Csttj|dtjd}t|}t|}|d|}tjdd,t|dk||d|d|d|<W5QRX|S)z Safely compute reginv from sing.rr"Nignore)invalidrr)rarrayZfloat64Z zeros_likecompute_rank_inverseZerrstatewhere)rnrrrrNrKrKrLrzs  rcCsV|dd}|dds(t|dk}n*t|d|ddd}|dd|}|S) zCompute the rank of a linear inverse operator (MNE, dSPM, etc.). Parameters ---------- inv : instance of InverseOperator The inverse operator. Returns ------- rank : int The rank of the inverse operator. rhrrZrrrrr[)rrr)rnrrBrrKrKrLres   recCsddlm}t||ddt||jt||jdddd}t|j|}t d t |t |d t |d |j |}t |d d |}|j\}}t|} || } t d|| | f~t j|ddd} | | } t |} | dt |t}| dk}t j| |<d||<d}|d|dddt jf}|d| }tdD]}||| t jdd|f}d||ddk<|dd|fd|}t j||dd}d|t |d||k<|sq| ||9<qLtddt | }t | } | |fS)a-Estimate the SNR as a function of time for evoked data. Parameters ---------- evoked : instance of Evoked Evoked instance. inv : instance of InverseOperator The inverse operator. %(verbose)s Returns ------- snr : ndarray, shape (n_times,) The SNR estimated from the whitened data (i.e., GFP of whitened data). snr_est : ndarray, shape (n_times,) The SNR estimated using the mismatch between the unregularized solution and the regularized solution. Notes ----- ``snr_est`` is estimated by using different amounts of inverse regularization and checking the mismatch between predicted and measured whitened data. In more detail, given our whitened inverse obtained from SVD: .. math:: \tilde{M} = R^\frac{1}{2}V\Gamma U^T The values in the diagonal matrix :math:`\Gamma` are expressed in terms of the chosen regularization :math:`\lambda^2 \sim 1/\rm{SNR}^2` and singular values :math:`\lambda_k` as: .. math:: \gamma_k = \frac{1}{\lambda_k}\frac{\lambda_k^2}{\lambda_k^2 + \lambda^2} We also know that our predicted data is given by: .. math:: \hat{x}(t) = G\hat{j}(t)=C^\frac{1}{2}U\Pi w(t) And thus our predicted whitened data is just: .. math:: \hat{w}(t) = U\Pi w(t) Where :math:`\Pi` is diagonal with entries entries: .. math:: \lambda_k\gamma_k = \frac{\lambda_k^2}{\lambda_k^2 + \lambda^2} If we use no regularization, note that :math:`\Pi` is just the identity matrix. Here we test the squared magnitude of the difference between unregularized solution and regularized solutions, choosing the biggest regularization that achieves a :math:`\chi^2`-test significance of 0.001. .. versionadded:: 0.9.0 r)chi2rNrjrrErrr,rrrr}zEffective nchan = %d - %d = %drrg$@rFgGz?rNgMbP?irzSNR estimation did not converge)Z scipy.statsrgrrrNrrrqrjr<rTrrr}rrerr%fillrHrinfrZisfrrfrFr>r)rrnr=rgroZ data_whiteZ data_white_efZn_chr(Zn_ch_effZn_zerosignalZsnrZ lambda2_est remainingrRZ lambda_multZsing2valZn_iterrewerrZsnr_estrKrKrL estimate_snrsRB    "         ro)F)T)rFNTN)TN)T)N) rrFNFNNFTN)r) rFNNNrNNNFNTN)rFNrNFNTN) rFNrNFFNTN) rrrFNFNNTN)rPrQrPNTN)N)urMrmathrnumpyrZ_eloretarfixesrZio.baserZ io.constantsr Zio.openr Zio.tagr Z io.matrixr r rZio.projrrrrZio.treerZio.writerrrrrrrrZio.pickrrrrr5r r!r"r#r$r+r%rr&r'rIr(r)r*r+r,r-Zforward.forwardr.r/Z source_spacer0r1r2r3r4r5Zsurfacer6Z transformsr7r8Zsource_estimater9r:utilsr;r<r=r>r?r@rArBrCrDrrrIrqrrrrrrrrrrrrr rr*r1r2r:rOrarrerorKrKrKrLs         (    00]"_    w   e C  I ; _