U f{j @sddlmZddlmZddlmZddlZddlmZ ddl Z ddl m Z ddl ZddlmZddlmZmZdd lmZmZmZmZmZdd lmZmZmZdd lmZm Z m!Z!m"Z"d d l#m$Z$m%Z%m&Z&m'Z'ddl(m)Z)m*Z*ddl+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8d dl9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCd dlDmEZEd dlmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^d dl_m`Z`d dlambZbmcZcmdZdmeZed dlfmgZgmhZhd dl9miZimjZjmkZkeJGddde"ee$e%e&e^eSe> ZlddZmd;ddZndd Zod!d"Zpd#d$ZqGd%d&d&erZsGd'd(d(erZtd)d*ZuGd+d,d,Zvd-d.ZweJd/d0Zxd1d2Zyd3d4ZzePdd?d@Z!eddAdBZ"e#e$j%dfdJdK Z%eddMdNZ&eddPdQZ'eddddSdTZ(eddddUdVZ)eddZd[Z*edddd\d]d^Z+d_d`Z,e-e.ddadRdbdcddddedd,dddd,ddddfe/dd,dgddCddd,d,dhddfddddidjdkZ0ee-e1dej2dddddd,dddldmdndod,dCd,dddd,ddFdpdfdqdrZ3e-e4ddvdwZ5e dxdyZ6e dzd{Z7e d|d}Z8d~dZ9edddZ:e;dddZddZ?dddZ@dddZAdddZBedddddZCdddZDZES)BaseRawa Base class for Raw data. Parameters ---------- %(info_not_none)s preload : bool | str | ndarray Preload data into memory for data manipulation and faster indexing. If True, the data will be preloaded into memory (fast, requires large amount of memory). If preload is a string, preload is the file name of a memory-mapped file which is used to store the data on the hard drive (slower, requires less memory). If preload is an ndarray, the data are taken from that array. If False, data are not read until save. first_samps : iterable Iterable of the first sample number from each raw file. For unsplit raw files this should be a length-one list or tuple. last_samps : iterable | None Iterable of the last sample number from each raw file. For unsplit raw files this should be a length-one list or tuple. If None, then preload must be an ndarray. filenames : tuple Tuple of length one (for unsplit raw files) or length > 1 (for split raw files). raw_extras : list of dict The data necessary for on-demand reads for the given reader format. Should be the same length as ``filenames``. Will have the entry ``raw_extras['orig_nchan']`` added to it for convenience. orig_format : str The data format of the original raw file (e.g., ``'double'``). dtype : dtype | None The dtype of the raw data. If preload is an ndarray, its dtype must match what is passed here. buffer_size_sec : float The buffer size in seconds that should be written by default using :meth:`mne.io.Raw.save`. orig_units : dict | None Dictionary mapping channel names to their units as specified in the header file. Example: {'FC1': 'nV'}. .. versionadded:: 0.17 %(verbose)s See Also -------- mne.io.Raw : Documentation of attribute and methods. Notes ----- This class is public to allow for stable type-checking in user code (i.e., ``isinstance(my_raw_object, BaseRaw)``) but should not be used as a constructor for `Raw` objects (use instead one of the subclass constructors, or one of the ``mne.io.read_raw_*`` functions). Subclasses must provide the following methods: * _read_segment_file(self, data, idx, fi, start, stop, cals, mult) (only needed for types that support on-demand disk reads) F)rNNdouble?r?c  sVt|tjrz|jtjtjfkr,td|j|j|kr>td|_d_ t |dksZt |djj ddg}d} n$|dkrtd|sd_ d} nd} t |_t |_d} jdd $td trtd d <W5QRX_t| _td }td D]*}d |d d |d||<qt|dkd}t |dkrtdfdd|D|_tdd|D_jD]}d |d<qfddtt |D_j_jdk rt drtdjd_ t|_!t"|t#dt$d|d|_%r tt&sXtd't(t)t*| dD]*\}}|krn|}|=||<qntd}d|kr̈j+d,ds|-dfdd|D}t.|s||/d}td'|t0_1t_2d_3|_45d|d_6| rJ7|t8_9dS) Nz.datatype must be float64 or complex128, not %szpreload and dtype must matchTrrFz5last_samps must be given unless preload is an ndarraych_names)Z check_after meas_datenchanchsrangecalzBad cals for channels %scsi|]}|j|qS)r]).0iiselfrcJ/var/www/html/bwave/python/venv/lib/python3.8/site-packages/mne/io/base.py sz$BaseRaw.__init__..css |]}|dkrtn|VqdSrY)dictrdrrcrcrh sz#BaseRaw.__init__..Z orig_nchancsg|]}tdqS)r_)nparange)rd_inforcrh sz$BaseRaw.__init__..compszCurrent compensation grade : %d orig_format)rZsingleintshortz,orig_units must be of type dict, but got {}zSTI 014.fifcsg|] }|kqSrcrc)rdch) orig_unitsrcrhrssz+Channel {} has no associated original unit.): isinstancernndarraydtypefloat64Z complex128 RuntimeError ValueError_datapreloadlenAssertionErrorshapearray _last_samps _first_samps_unlocktupler=rrfloatbuffer_size_secemptyrawhere_calslist _raw_extras _read_pickscompensation_grade_read_comp_grader>_comp _filenamesrDstrrGrurjformattyperzip filenamesendswithremoveallindexr Z _orig_unitsZ _projectors _projector_dtype_set_annotations _cropped_samp _preload_datarFZ _init_kwargs)rgrrrZ first_sampsZ last_sampsrZ raw_extrasrur~rr{r?Zload_from_diskZ orig_ch_namescalskbadrlZold_chZnew_chZ this_unitr]Z ch_correspondZch_without_orig_unitrc)rrr{rgrh__init__vs     (               zBaseRaw.__init__c Cst|}|j}||kr|jr$td|jr.|n|j}t|j||}td||ft |j||jrtdt t dt |jdt |jgg}t|dd|ddD]8\}}t ||jdd||f|jdd||f<qn||_|S) aApply CTF gradient compensation. .. warning:: The compensation matrices are stored with single precision, so repeatedly switching between different of compensation (e.g., 0->1->3->2) can increase numerical noise, especially if data are saved to disk in between changing grades. It is thus best to only use a single gradient compensation level in final analyses. Parameters ---------- grade : int CTF gradient compensation level. %(verbose)s Returns ------- raw : instance of Raw The modified Raw instance. Works in-place. zECannot change compensation on data where projectors have been appliedz*Compensator constructed to change %d -> %dz#Applying compensator to loaded datari'Nr)rwrprojrrrrrrr>rrn concatenaterortimesrdotrr) rgZgrader?Z current_compZ from_compcompZlimsstartstoprcrcrhapply_gradient_compensations.   "z#BaseRaw.apply_gradient_compensationcCs|jS)z@Datatype for loading data (property so subclasses can override).)rrfrcrcrh_dtypeszBaseRaw._dtyperc Cs|t|}|dkr|jntt||jg}||kr8td|dkrT|jd}td}nt|}t|}~||jdksxt|||f} |j } t |t j r|j | krtd|j | f|} n t|| | } t dgt j|jddf} t | } t t || ddt |d| dd } tt t|j|}|jt jddf}|dk r|j d|j dkr~|j dksnt|jdk r|dk r|j|}t |||}n|j||}n|dk r|||}nd}~|dkr|j|}|j |dfks t|}nhd}|j |t|jfks0tt t j|dd d}|dd|f}t !d t|d t|jd |dk|dkAstd}t "| dD]}|j#|}|dkr||| |7}t || ||j#||j$|dg}||j#|ks||krtd||}t|||}t|j%||}t&|'| dd|f||t|t|||||7}q| S)aZRead a chunk of raw data. Parameters ---------- start : int, (optional) first sample to include (first is 0). If omitted, defaults to the first sample in data. stop : int, (optional) First sample to not include. If omitted, data is included to the end. sel : array, optional Indices of channels to select. data_buffer : array or str, optional numpy array to fill with data read, must have the correct shape. If str, a np.memmap with the correct data type will be used to store the data. projector : array SSP operator to apply to the data. %(verbose)s Returns ------- data : array, [channels x samples] the data matrix (channels x samples). NzNo data in this ranger_z)data_buffer has incorrect shape: %s != %srrwr~rr)ZaxiszReading /z channels due to projectionz"Bad array indexing, could be a bug)(rwn_timesminrrrslicer_convert_slicerrr|rnr}r_allocate_datarr _raw_lengthscumsum logical_andless greater_equalror]rravelnewaxisrrTranyr>debugZnonzerorrr_ReadSegmentFileProtector_read_segment_file)rgrrsel data_buffer projectorr?Zn_outidxZ data_shaper~data cumul_lensZ files_usedrmultZneed_idxoffsetfiZ start_fileZ stop_fileZn_readthis_slZorig_idxrcrcrh _read_segments            0          zBaseRaw._read_segmentcCstdS)aRead a segment of data from a file. Only needs to be implemented for readers that support ``preload=False``. Any implementation should only make use of: - self._raw_extras[fi] - self._filenames[fi] So be sure to store any information necessary for reading raw data in self._raw_extras[fi]. Things like ``info`` can be decoupled from the original data (e.g., different subsets of channels) due to picking before preload, for example. Parameters ---------- data : ndarray, shape (n_out, stop - start + 1) The data array. Should be modified inplace. idx : ndarray | slice The requested channel indices. fi : int The file index that must be read from. start : int The start sample in the given file. stop : int The stop sample in the given file (inclusive). cals : ndarray, shape (len(idx), 1) Channel calibrations (already sub-indexed). mult : ndarray, shape (n_out, len(idx) | None The compensation + projection + cals matrix, if applicable. N)NotImplementedErrorrgrrrrrrrrcrcrhrszBaseRaw._read_segment_filec Cs|dkr dS|rt|jdkr|j}|jd}t||j} t| ||k} t| | |j| ||k} |j| D]} | drv| Sqv|j |t ||fddS)awCheck if data segment is bad. If the slice is good, returns the data in desired range. If rejected based on annotation, returns description of the bad segment as a string. Parameters ---------- start : int First sample of the slice. stop : int End of the slice. picks : array of int Channel picks. reject_start : int First sample to check for overlaps with bad annotations. reject_stop : int Last sample to check for overlaps with bad annotations. reject_by_annotation : bool Whether to perform rejection based on annotations. False by default. Returns ------- data : array | str Data in the desired range (good segment) or description of the bad segment. rNsfreqrF return_times) r annotationsrrrWonsetrnrduration descriptionlower startswith_getitemr) rgrrpicksZ reject_startZ reject_stopreject_by_annotationannotrroverlapsdescrrcrcrh_check_bad_segments   zBaseRaw._check_bad_segmentcCs|js|d|S)a|Load raw data. Parameters ---------- %(verbose)s Returns ------- raw : instance of Raw The raw object with data. Notes ----- This function will load raw data if it was not already preloaded. If data were already preloaded, it will do nothing. .. versionadded:: 0.10.0 T)rr)rgr?rcrcrh load_datas zBaseRaw.load_datacCs|}t|ttjfr|sd}tddt|jdd|jdf|j||j d|_ t|j |jdkslt d |_ d|_ |dS) zActually preload the data.Nz-Reading %d ... %d = %9.3f ... %9.3f secs...rrrrrr_T)r|boolrnZbool_r>rrrrrrrrrrclose)rgrrrcrcrhrszBaseRaw._preload_datacCs|jt|jdSNr) first_samprrrrfrcrcrh _first_timeszBaseRaw._first_timecCs|jS)z@The first data sample. See :term:`first_samp`. )rrfrcrcrhrszBaseRaw.first_sampcCs|jS)z>The first time point (including first_samp but not meas_date).)rrfrcrcrh first_time szBaseRaw.first_timecCs|jt|jdS)zThe last data sample.r)rsumrrfrcrcrh last_sampszBaseRaw.last_sampcCs|jt|jdSr)rrrrrfrcrcrh _last_timeszBaseRaw._last_timecsvt|}|dkrd}n@|jddkr4td|fn"|jdtd|j}||}t||}tt | ||S)aConvert time to indices. Parameters ---------- times : list-like | float | int List of numbers or a number representing points in time. use_rounding : bool If True, use rounding (instead of truncation) when converting times to indices. This can help avoid non-unique indices. origin : datetime | float | int | None Time reference for times. If None, ``times`` are assumed to be relative to :term:`first_samp`. .. versionadded:: 0.17.0 Returns ------- index : ndarray Indices relative to :term:`first_samp` corresponding to the times supplied. Nrr^z:origin must be None when info["meas_date"] is None, got %s) r-rrrrr total_secondsrn atleast_1dsuperrX time_as_index)rgr use_roundingorigindeltaZfirst_samp_in_abs_time __class__rcrhrs  zBaseRaw.time_as_indexcCsddt|j|jDS)NcSsg|]\}}||dqS)rrc)rdflrcrcrhrsAsz(BaseRaw._raw_lengths..)rrrrfrcrcrhr?szBaseRaw._raw_lengthscCs|jS)z7:class:`~mne.Annotations` for marking segments of data. _annotationsrfrcrcrhrCszBaseRaw.annotationscCs t|jS)zThe filenames used.)rrrfrcrcrhrHszBaseRaw.filenamesTraisec Cst|jd}|dkr(tggg||_nt|td|dkrN|jdk rNtdd|jd}|}||j||jdkr|j d|j d||d |j |j 7_ nP|t d|j }|t |j d|d } |j || |d |j ||j8_ ||_||_|S) aSetter for annotations. This setter checks if they are inside the data range. Parameters ---------- annotations : instance of mne.Annotations | None Annotations to set. If None, the annotations is defined but empty. %(emit_warning)s The default is True. %(on_missing_ch_names)s %(verbose)s Returns ------- self : instance of Raw The raw object with annotations. r^NraQAmbiguous operation. Setting an Annotation object with known ``orig_time`` to a raw object which has ``meas_date`` set to None is ambiguous. Please, either set a meaningful ``meas_date`` to the raw object; or set ``orig_time`` to None in which case the annotation onsets would be taken in reference to the first sample of the raw object.r[rrr) emit_warning)seconds)tmintmaxr)r-rrrUrrD orig_timercopyZ_prune_ch_namescroprrrrrZ _orig_time) rgrrZ on_missingr?r^rZnew_annotationsrrrcrcrhrMs2    zBaseRaw.set_annotationscCsPt|drLt|jdddk rL|jj}|`zt|Wntk rJYnXdS)Nrfilename)hasattrgetattrrrosrOSError)rgrrcrcrh__del__s zBaseRaw.__del__cCs|S)zEntering with block.rcrfrcrcrh __enter__szBaseRaw.__enter__cCs0z |Wntk r*|||fYSXdS)zExit with block.N)r Exception)rgZexception_typeZ exception_valtracercrcrh__exit__s zBaseRaw.__exit__cCs0t|ts|tdddf}t|dkr.tdt|j|d}t|dtrl|d}|j|j|j }}}nT|d}t |dj j dkrt|}t|tt jfr||dd}}}ntd|dkrd}|dk r|dkrtd|t|tt jfrt |g}|dk r&t|dkr&td |||fS) z+Parse the __getitem__ / __setitem__ tuples.Nrz7Unable to access raw data (need both channels and time)rriz%Must pass int or slice to __getitem__zstep needs to be 1 : %d givenzEmpty channel list)r|rrrrrrrrrsteprnrr~kindrwintegerr)rgitemrZ time_slicerrrZitem1rcrcrh_parse_get_set_paramss2     zBaseRaw._parse_get_set_paramscCs ||S)aGet raw data and times. Parameters ---------- item : tuple or array-like See below for use cases. Returns ------- data : ndarray, shape (n_channels, n_times) The raw data. times : ndarray, shape (n_times,) The times associated with the data. Examples -------- Generally raw data is accessed as:: >>> data, times = raw[picks, time_slice] # doctest: +SKIP To get all data, you can thus do either of:: >>> data, times = raw[:] # doctest: +SKIP Which will be equivalent to: >>> data, times = raw[:, :] # doctest: +SKIP To get only the good MEG data from 10-20 seconds, you could do:: >>> picks = mne.pick_types(raw.info, meg=True, exclude='bads') # doctest: +SKIP >>> t_idx = raw.time_as_index([10., 20.]) # doctest: +SKIP >>> data, times = raw[picks, t_idx[0]:t_idx[1]] # doctest: +SKIP )r)rgrrcrcrh __getitem__s$zBaseRaw.__getitem__cCsz||\}}}|jr*|j|||f}n|j||||jd}|rrtj|||jdtd}||j d}||fS|SdS)N)rrrrrrr) rrrrrrnrorrrr)rgrrrrrrrrcrcrhrs zBaseRaw._getitemcCs0t|d||\}}}||j|||f<dS)zSet raw data content.zModifying data of RawN)rErr)rgrvaluerrrrcrcrh __setitem__s zBaseRaw.__setitem__)rrr?c Cst|ddddt|ddddt|j|dd d }|d k rFt|||} tt|jd |}|||\} } |d kr|| n|}|d kr| n|}tt d ||j }tt d ||j }t |j d ks|d kr>|j |t||f|d} |r| \}}|d k r|| d d tjf9}||fS|d k r:| | d d tjf9} | Std|ddgt|dg\}}||k||k@}t|||}t|||}t |d kr||||f\}}|d k r|| d d tjf9}|r||fS|S||}t|t}t||D],\}}||krqd|||||<qtdg|dgg}t|d d|dd @d |}t|d d|dd @d |}||}||}|d kr|dkrjd}t||||||||tt ||f}t|jd}d }t||D]T\}}||kr(q|||}||||f\|d d ||f<|||<|}qnTd}t||||||||||||f\}}tj|d d |ddf<n||||f\}}|d k r|| d d tjf9}|r||fS|S)aGet data in the given range. Parameters ---------- %(picks_all)s start : int The first sample to include. Defaults to 0. stop : int | None End sample (first not to include). If None (default), the end of the data is used. reject_by_annotation : None | 'omit' | 'NaN' Whether to reject by annotation. If None (default), no rejection is done. If 'omit', segments annotated with description starting with 'bad' are omitted. If 'NaN', the bad samples are filled with NaNs. return_times : bool Whether to return times as well. Defaults to False. %(units)s tmin : int | float | None Start time of data to get in seconds. The ``tmin`` parameter is ignored if the ``start`` parameter is bigger than 0. .. versionadded:: 0.24.0 tmax : int | float | None End time of data to get in seconds. The ``tmax`` parameter is ignored if the ``stop`` parameter is defined. .. versionadded:: 0.24.0 %(verbose)s Returns ------- data : ndarray, shape (n_channels, n_times) Copy of the data in the given range. times : ndarray, shape (n_times,) Times associated with the data samples. Only returned if return_times=True. Notes ----- .. versionadded:: 0.14.0 int-likerrw)types item_name type_name)rNrz int, NonerrcexcludeNr_rrrZomitnanBADFrrzBOmitting {} of {} ({:.2%}) samples, retaining {} ({:.2%}) samples.zHSetting {} of {} ({:.2%}) samples to NaN, retaining {} ({:.2%}) samples.) rDrrr_get_ch_factorsrnrroZ_handle_tmin_tmaxrmaxrrrrrrrGrr+maximumminimumonesrrrrrr>rzerosrr)rgrrrrrunitsrrr? ch_factorsZ tmin_startZ tmax_stopgetitemrrZonsetsZendsZkeep n_samplesusedrendZstartsZstopsZn_keptZ n_rejectedmsgrrcrcrhget_datas.        ((      ,   zBaseRaw.get_datac  st|dt|j|ddd}ts,td|j|dk rT||jjkrT|j||_|rtt |\}}|dkr|D],} t | ddff|j| ddf<qtnD|fdd |D} t |D]\} } | | |j| ddf<qn(t |ddff|j|ddf<|S) aApply a function to a subset of channels. %(applyfun_summary_raw)s Parameters ---------- %(fun_applyfun)s %(picks_all_data_noref)s %(dtype_applyfun)s %(n_jobs)s %(channel_wise_applyfun)s .. versionadded:: 0.18 %(verbose)s %(kwargs_fun)s Returns ------- self : instance of Raw The raw object with transformed data. zraw.apply_functionrcFrZ with_ref_megzfun needs to be a functionNrc3s |]}|fVqdSrYrc)rdpZdata_infunkwargsZp_funrcrhrmsz)BaseRaw.apply_function..) rErrrcallablerrr~astyper4r3 enumerate) rgr1rr~n_jobsZ channel_wiser?r2parallelrZdata_picks_newppr/rcr0rhapply_functions4 zBaseRaw.apply_functionautofirzerohammingfirwinedge bad_acq_skipreflect_limitedcs*tj||||||||| | | | | ||dS)N) r6method iir_paramsphase fir_window fir_designskip_by_annotationpadr?)rfilter)rgZl_freqZh_freqr filter_lengthZl_trans_bandwidthZh_trans_bandwidthr6rCrDrErFrGrHrIr?rrcrhrJs"zBaseRaw.filter皙?cCs\t|jd}t|j|ddd}t|dt|j|||||||| | ||d| | | |d|_|S)aNotch filter a subset of channels. Parameters ---------- freqs : float | array of float | None Specific frequencies to filter out from data, e.g., ``np.arange(60, 241, 60)`` in the US or ``np.arange(50, 251, 50)`` in Europe. ``None`` can only be used with the mode ``'spectrum_fit'``, where an F test is used to find sinusoidal components. %(picks_all_data)s %(filter_length_notch)s notch_widths : float | array of float | None Width of each stop band (centred at each freq in freqs) in Hz. If None, ``freqs / 200`` is used. trans_bandwidth : float Width of the transition band in Hz. Only used for ``method='fir'``. %(n_jobs_fir)s %(method_fir)s %(iir_params)s mt_bandwidth : float | None The bandwidth of the multitaper windowing function in Hz. Only used in 'spectrum_fit' mode. p_value : float P-value to use in F-test thresholding to determine significant sinusoidal components to remove when ``method='spectrum_fit'`` and ``freqs=None``. Note that this will be Bonferroni corrected for the number of frequencies, so large p-values may be justified. %(phase)s %(fir_window)s %(fir_design)s %(pad_fir)s The default is ``'reflect_limited'``. .. versionadded:: 0.15 %(verbose)s Returns ------- raw : instance of Raw The raw instance with filtered data. See Also -------- mne.filter.notch_filter mne.io.Raw.filter Notes ----- Applies a zero-phase notch filter to the channels selected by "picks". By default the data of the Raw object is modified inplace. The Raw object has to have the data loaded e.g. with ``preload=True`` or ``self.load_data()``. .. note:: If n_jobs > 1, more memory is required as ``len(picks) * n_times`` additional time points need to be temporaily stored in memory. For details, see :func:`mne.filter.notch_filter`. rrcZ data_or_ica)rnonezraw.notch_filterF)rK notch_widthstrans_bandwidthrCrD mt_bandwidthp_valuerr6rrErFrGrI)rrrrrEr/r)rgZfreqsrrKrNrOr6rCrDrPrQrErFrGrIr?fsrcrcrhr/s.D zBaseRaw.notch_filterboxcarc  s|dkr*z t|} Wntk r(YnXtt|jdtdgt|jf} |dkrvt|jdddgd}nt |j|ddd}t ||||d } t fd d |jD\} } | dt | t } } tdgt| }|jr tt|j|d f|jj}tt |j| D]6\}\}}t||||d }|jr|jdd| || |d f}t|f| |dd|f<t|dkrPt||||jd |||f<ntt|jD]}|j|| || |d ddd}|dkr|dkrtt|j|d f|j}||kr4t|||jd d}n t|f| }||||f<qqt t|j| |_t|j| t |_t |j| d |_ t| |j|<t!| |j |jd st"||_d|_|j#d}|dkrtj$n|}|j%$t&|d|jd<|jd<W5QRX|dkrpz&t|}t|t| krRt'dWntk rjYnX|S|(}t)t|dddf| t |jjd |j*d |dddf<||fSdS)aa Resample all channels. If appropriate, an anti-aliasing filter is applied before resampling. See :ref:`resampling-and-decimating` for more information. .. warning:: The intended purpose of this function is primarily to speed up computations (e.g., projection calculation) when precise timing of events is not required, as downsampling raw data effectively jitters trigger timings. It is generally recommended not to epoch downsampled data, but instead epoch and then downsample, as epoching downsampled data jitters triggers. For more, see `this illustrative gist `_. If resampling the continuous data is desired, it is recommended to construct events using the original data. The event onsets can be jointly resampled with the raw data using the 'events' parameter (a resampled copy is returned). Parameters ---------- sfreq : float New sample rate to use. %(npad)s %(window_resample)s stim_picks : list of int | None Stim channels. These channels are simply subsampled or supersampled (without applying any filtering). This reduces resampling artifacts in stim channels, but may lead to missing triggers. If None, stim channels are automatically chosen using :func:`mne.pick_types`. %(n_jobs_cuda)s events : 2D array, shape (n_events, 3) | None An optional event matrix. When specified, the onsets of the events are resampled jointly with the data. NB: The input events are not modified, but a new array is returned with the raw instead. %(pad)s The default is ``'reflect_limited'``. .. versionadded:: 0.15 %(verbose)s Returns ------- raw : instance of Raw The resampled version of the raw object. events : array, shape (n_events, 3) | None If events are jointly resampled, these are returned with the raw. See Also -------- mne.io.Raw.filter mne.Epochs.resample Notes ----- For some data, it may be more accurate to use ``npad=0`` to reduce artifacts. This is dataset dependent -- check your data! For optimum performance and to make use of ``n_jobs > 1``, the raw object has to have the data loaded e.g. with ``preload=True`` or ``self.load_data()``, but this increases memory requirements. The resulting raw object will have the data loaded into memory. NrrFT)ZmegZref_megZstimrrcr.)upZdownnpadwindowr6rIc3s|]}t|VqdSrY)r1)rdZold_lenZo_sfreqrrcrhrmsz#BaseRaw.resample..rrerrorr\lowpassg@zResampling of the stim channels caused event information to become unreliable. Consider finding events on the original data and passing the event matrix as a parameter.)+rSr rrrrnrrrr rrjrrrwrrrrr]rr~r5rr0r2rrar-roundrrr4rZ array_equalrgetinfrrrArr#r)rgrrUrVZ stim_picksr6eventsrIr?Zoriginal_eventsoffsetsr2ratioZn_newsZ new_offsetsZnew_datariZn_origZn_newrZ data_chunkciZresamprYZresampled_eventsrcrWrhr0'sL     "       zBaseRaw.resamplerc s6jdjd}|dkr |}||kr8td||f|dkrPtd|fn||krhtd||fttj||jd|dd d d g\}}td gtjj d d f}t |}t t ||ddt ||dd } t| d } j|7_tj| _jd ||| d 7<tj| _jd || d dd|8<fd d| D_tfddjDstfdd| D_fdd| D_jrjdd||df_j} | jdkr&jddkst| jj8_| dS)aCrop raw data file. Limit the data from the raw file to go between specific times. Note that the new ``tmin`` is assumed to be ``t=0`` for all subsequently called functions (e.g., :meth:`~mne.io.Raw.time_as_index`, or :class:`~mne.Epochs`). New :term:`first_samp` and :term:`last_samp` are set accordingly. Thus function operates in-place on the instance. Use :meth:`mne.io.Raw.copy` if operation on a copy is desired. Parameters ---------- %(tmin_raw)s %(tmax_raw)s %(include_tmax)s %(verbose)s Returns ------- raw : instance of Raw The cropped raw object, modified in-place. rrNz%tmin (%s) must be less than tmax (%s)rztmin (%s) must be >= 0z@tmax (%s) must be less than or equal to the max time (%0.4f sec))r include_tmaxrrrwrcsg|]}j|qSrc)rrdr`rfrcrhrssz BaseRaw.crop..c3s$|]}t|tjdkVqdSrN)rrrkrfrcrhrmszBaseRaw.crop..csg|]}j|qSrc)rrcrfrcrhrs scsg|]}j|qSrc)rrcrfrcrhrs sr^F)rrrrrnrr@rrrrrrrrrrrrrrrrrrrrrrrrr) rgrrrbr?Zmax_timeZsminZsmaxrZkeepersrrcrfrhrsf  &    z BaseRaw.cropcCsx|dkr|j}g}|D]\}|d|j}|jd d|krHdkrPnnd}||||d}||q|S)aGet crops of raw data file for selected annotations. Parameters ---------- annotations : instance of Annotations | None The annotations to use for cropping the raw file. If None, the annotations from the instance are used. %(verbose)s Returns ------- raws : list The cropped raw objects. Nrrrrr)rrrrrrappend)rgrr?rawsrrZraw_croprcrcrhcrop_by_annotationss$ zBaseRaw.crop_by_annotationsrv2GBneuromagc Csd} | tdd| D7} d}t|ddd}t|d| |d t| } |js\||jkr\td |jrvt|j rvt d t t j t jt jt jd }td ||t ddddd }||}||}|dd}|dkrt|rtdt|| dd}|r t|j}t|\}}t|dddn |j}d}|||\}}||}t| tdtd| dt||||||||||||| | dd| dS)a Save raw data to file. Parameters ---------- fname : str File name of the new dataset. This has to be a new filename unless data have been preloaded. Filenames should end with ``raw.fif`` (common raw data), ``raw_sss.fif`` (Maxwell-filtered continuous data), ``raw_tsss.fif`` (temporally signal-space-separated data), ``_meg.fif`` (common MEG data), ``_eeg.fif`` (common EEG data), or ``_ieeg.fif`` (common intracranial EEG data). You may also append an additional ``.gz`` suffix to enable gzip compression. %(picks_all)s %(tmin_raw)s %(tmax_raw)s buffer_size_sec : float | None Size of data chunks in seconds. If None (default), the buffer size of the original file is used. drop_small_buffer : bool Drop or not the last buffer. It is required by maxfilter (SSS) that only accepts raw files with buffers of the same size. proj : bool If True the data is saved with the projections applied (active). .. note:: If ``apply_proj()`` was used to apply the projections, the projectons will be active even if ``proj`` is False. fmt : 'single' | 'double' | 'int' | 'short' Format to use to save raw data. Valid options are 'double', 'single', 'int', and 'short' for 64- or 32-bit float, or 32- or 16-bit integers, respectively. It is **strongly** recommended to use 'single', as this is backward-compatible, and is standard for maintaining precision. Note that using 'short' or 'int' may result in loss of precision, complex data cannot be saved as 'short', and neither complex data types nor real data stored as 'double' can be loaded with the MNE command-line tools. See raw.orig_format to determine the format the original data were stored in. %(overwrite)s To overwrite original file (the same one that was loaded), data must be preloaded upon reading. split_size : str | int Large raw files are automatically split into multiple pieces. This parameter specifies the maximum size of each piece. If the parameter is an integer, it specifies the size in Bytes. It is also possible to pass a human-readable string, e.g., 100MB. .. note:: Due to FIFF file limitations, the maximum split size is 2GB. %(split_naming)s .. versionadded:: 0.17 %(verbose)s Notes ----- If Raw is a concatenation of several raw files, **be warned** that only the measurement information from the first raw file is stored. This likely means that certain operations with external tools may not work properly on a saved concatenated file (e.g., probably some or all forms of SSS). It is recommended not to concatenate and then save raw files for this reason. Samples annotated ``BAD_ACQ_SKIP`` are not stored in order to optimize memory. Whatever values, they will be loaded as 0s when reading file. )zraw.fifz raw_sss.fifz raw_tsss.fifz_meg.fifz_eeg.fifz _ieeg.fifcSsg|]}|dqS)z.gzrc)rdercrcrhrssz BaseRaw.save..)ryz.fif.gzTrX overwriter?raw) endings_errzGYou cannot save data to the same file. Please use a different filename.zUSaving raw file with complex data. Loading with command-line MNE tools will not work.)rxrwrvrZfmtF)rrrrxz?Complex data must be saved as "single" or "double", not "short")fnamerlr?projs)rN split_naming)ribids)rr5r;r)rrrrnZ iscomplexobjrrArjrZFIFFT_DAU_PACK16Z FIFFT_INTZ FIFFT_FLOATZ FIFFT_DOUBLErGkeysrrrrr_tmin_tmax_to_start_stop_get_buffer_sizerDr _write_raw)rgrprrrrdrop_small_bufferrrorl split_sizerrr?ZendingsrnZ type_dictZ reset_dict reset_range data_typeZ data_testrrrrr buffer_sizercrcrhsave<s`F       z BaseRaw.saverkc Cs&ddlm}||||||||ddS)a Export Raw to external formats. %(export_fmt_support_raw)s %(export_warning)s Parameters ---------- %(fname_export_params)s %(export_fmt_params_raw)s %(physical_range_export_params)s %(add_ch_type_export_params)s %(overwrite)s .. versionadded:: 0.24.1 %(verbose)s Notes ----- .. versionadded:: 0.24 %(export_warning_note_raw)s %(export_eeglab_note)s %(export_edf_note)s r) export_raw)physical_range add_ch_typerlr?N)exportr~)rgrprorrrlr?r~rcrcrhrs   zBaseRaw.exportcCstt||jd}|dkr(tj}n|jt|dddd}t||j|j d}||ksh|dkrxt d||f||fS)NrT)rrrz*tmin (%s) and tmax (%s) yielded no samples) rwrnfloorrrr\rrrrrr)rgrrrrrcrcrhrusz BaseRaw._tmin_tmax_to_start_stopg$@wZ lightgraycyanrr)theme overview_moder?c #%CsNt|||||||||| | | | | ||||||||||||||||||| |!|"d#S)N) noise_covevent_idshow_scrollbarsshow_scalebars time_format precompute use_openglrrr?)rO)#rgr]rrZ n_channelsbgcolorcolorZ bad_colorZ event_colorscalingsZ remove_dcorderZ show_optionstitleshowblockZhighpassrYZ filtorderZclippingZshow_first_samprZgroup_by butterflyZdecimrrrrrrrrrr?rcrcrhplots> z BaseRaw.plotblackZlinearZstdgQ?badscCs<t|||||||||| | | | | ||||||||||||dS)N)fminfmaxrrrn_fft n_overlaprraxrxscale area_mode area_alphadBestimaterr6average line_alphaspatial_colorssphererVrr?)rP)rgrrrrrrrrrrrrrrrrrr6rrrrrVrr?rcrcrhplot_psds. zBaseRaw.plot_psddrcCs,t|||||||||| | | | | ||||dS)N)rrrrrrrlayoutr fig_facecoloraxis_facecolorrrrr6axesr?)rQ)rgrrrrrrrrrrrrrrr6rr?rcrcrh plot_psd_topos  zBaseRaw.plot_psd_topocCs |jdS)zChannel names.r]rqrfrcrcrhr]$szBaseRaw.ch_namescCs$t|jt|jd}d|jd<|S)z Time points.rFZ WRITEABLE)rLrrrrflags)rgoutrcrcrhr)s z BaseRaw.timescCs|j|jdS)zNumber of time points.rrrrfrcrcrhr0szBaseRaw.n_timescCs|jS)aReturn the number of time points. Returns ------- len : int The number of time points. Examples -------- This can be used as:: >>> len(raw) # doctest: +SKIP 1000 rrfrcrcrh__len__5szBaseRaw.__len__c s|jd}g}|dk rt|jdt|}dd|D}W5QRXfdd|D}t|t|}|dkr|d|d |jd} |st| nt| ||krt d |d |||jd<nt d |dS) aMark channels as bad from a text file. This function operates mostly in the style of the C function ``mne_mark_bad_channels``. Each line in the text file will be interpreted as a name of a bad channel. Parameters ---------- bad_file : path-like | None File name of the text file containing bad channels. If ``None`` (default), bad channels are cleared, but this is more easily done directly with ``raw.info['bads'] = []``. force : bool Whether or not to force bad channel marking (of those that exist) if channels are not found, instead of raising an error. Defaults to ``False``. %(verbose)s rNr]cSsg|] }|r|qSrcrc)rdlinercrcrhrs`sz-BaseRaw.load_bad_channels..csg|]}|kr|qSrcrc)rdranamesrcrhrsasrz bad channel(s) from: z not found in: zUpdating bad channels: z -> zNo channels updated. Bads are: ) rr frozensetopenread splitlinesrrrrAr>) rgZbad_fileforcer?Z prev_badsZnew_badsfidZ bad_namesZ count_diffr,rcrrhload_bad_channelsFs"     zBaseRaw.load_bad_channelsc Cs*t|ts|g}|g}||7}t||jo.NTFr_cSsg|] }|jqSrcr)rdZrrrcrcrhrssz"BaseRaw.append..r)rrrrr^rrz BAD boundaryz EDGE boundaryz Append error)"r|r_check_raw_compatibilityrrrrrrnrrrrr~rarrrrr5rrrVrerrrZr_rrrrrrWr)rgrfrZall_rawsZ all_preloadedr_Zc_nsZnsampZ this_datarr`rrZ edge_sampsrlr)Z edge_samprrcrcrhrers     (      zBaseRaw.appendcCsdS)zClean up the object. Does nothing for objects that close their file descriptors. Things like RawFIF will override this method. Nrcrfrcrcrhrsz BaseRaw.closecCst|S)zReturn copy of Raw instance. Returns ------- inst : instance of Raw A copy of the instance. rrfrcrcrhrsz BaseRaw.copycCsx|jd}|dkrdn t|d}tt|j}|d|jr@dnd7}d|t|j|j |j d|f}d|j j |fS) Nrz, z, data%s loadedz notz%s%s x %s (%0.1f s), ~%srz <%s | %s>) ropbasenamerr7_sizerrr]rrr__name__)rgnamesize_strsrcrcrh__repr__s zBaseRaw.__repr__c Csddlm}dd|jD}t|j|jd\}}t|d\}}t|ddt|ddt|d}|d}|j|j j |d ||d S) Nr)repr_templates_envcSs g|]}|dk rtj|qSrY)rpathr)rdrrcrcrhrssz'BaseRaw._repr_html_..<02d:zraw.html.jinja)caption)Z info_reprrr) Zhtml_templatesrrdivmodrrrwZ get_templaterenderrr _repr_html_) rgrr basenamesmrhrZ raw_templatercrcrhrs &  zBaseRaw._repr_html_cCst|dt|}|jdks,|jddkr4tdt||j}t|j |}t |dkrdtd||d}|dddf t }t ||jkst ||jkrtd |j|jft||dddfkstd |rd |j|ddf<|j|||jf|dddf7<dS) alAdd events to stim channel. Parameters ---------- events : ndarray, shape (n_events, 3) Events to add. The first column specifies the sample number of each event, the second column is ignored, and the third column provides the event value. If events already exist in the Raw instance at the given sample numbers, the event values will be added together. stim_channel : str | None Name of the stim channel to add to. If None, the config variable 'MNE_STIM_CHANNEL' is used. If this is not found, it will default to 'STI 014'. replace : bool If True the old events on the stim channel are removed before adding the new ones. Notes ----- Data must be preloaded in order to add events. z Adding eventsrrz"events must be shape (n_events, 3)rzChannel %s not foundNz.event sample numbers must be between %s and %sz%event sample numbers must be integersr)rErnZasarrayndimrrr<rrr r]rr4rwrrrrr)rgr]Z stim_channelreplacepickrrcrcrh add_eventss&        zBaseRaw.add_eventscCs.|dkr|j}t|}tt||jdS)zGet the buffer size.Nr)rrrwrnceilrr)rgrrcrcrhrv&szBaseRaw._get_buffer_sizec  Cst} dg} dddg} t|| }t|| |jd}t|j|ddd}||||f\} }| j} |rj| } t|| ||} t}t |||}| d|ft || ||||dgd }|S) aExport data in tabular structure as a pandas DataFrame. Channels are converted to columns in the DataFrame. By default, an additional column "time" is added, unless ``index`` is not ``None`` (in which case time values form the DataFrame's index). Parameters ---------- %(picks_all)s %(index_df_raw)s Defaults to ``None``. %(scalings_df)s %(copy_df)s start : int | None Starting sample index for creating the DataFrame from a temporal span of the Raw object. ``None`` (the default) uses the first sample. stop : int | None Ending sample index for creating the DataFrame from a temporal span of the Raw object. ``None`` (the default) uses the last sample. %(long_format_df_raw)s %(time_format_df_raw)s .. versionadded:: 0.20 %(verbose)s Returns ------- %(df_return)s timemsrdatetimer^rrcr)Z default_index) r6r8rKrrrrrrJrrIrerH)rgrrrrrrZ long_formatrr?pdZvalid_index_argsZvalid_time_formatsrrZmindexdfrcrcrh to_data_frame-s($   zBaseRaw.to_data_framecCsddlm}|jd}tt}|j|d<t|D]}|jd|}||d}|dt|j||dt |d|dt ||d ||d |d t ||d ||d |dt |q0|rddl}||} d| j_| Std} td} t|D]b}| |d|} | |d|d} | dkr| |d|<dD]}|||| 9<q`qt dtt|t dt dd|dDt dt dd|dDt dt dd|dDd}t|tdd|dddd|dddd|dddd|dddddd ddd ddd ddddt|D]}|d|dd|d|d|dd|d|d|dd|d|d|dd}d D]}||||d!d7}q||d|d!7}t|qjdS)"aDescribe channels (name, type, descriptive statistics). Parameters ---------- data_frame : bool If True, return results in a pandas.DataFrame. If False, only print results. Columns 'ch', 'type', and 'unit' indicate channel index, channel type, and unit of the remaining five columns. These columns are 'min' (minimum), 'Q1' (first quartile or 25% percentile), 'median', 'Q3' (third quartile or 75% percentile), and 'max' (maximum). Returns ------- result : None | pandas.DataFrame If data_frame=False, returns None. If data_frame=True, returns results in a pandas.DataFrame (requires pandas). r)scoreatpercentiler_rr`runitrQ1medianQ3Kr!Nrzrr&r)rrrrr!rrcSsg|] }t|qSrcr)rdnrcrcrhrssz$BaseRaw.describe..cSsg|] }t|qSrcr)rdtrcrcrhrsscSsg|] }t|qSrcr)rdurcrcrhrss)rzrrr>z 9)rrrrz>9.2f)Z scipy.statsrrrrrr]rarerrrnrrr!ZpandasZ DataFramerrrNr[rrprintupper)rgZ data_frameqr_colsrrzrrrrr&rscalingcolZlensr,rcrcrhdescribehsR         v hzBaseRaw.describe)N)rNNNNN)F)N)FN)Tr)T)NrNNFN)NNNTN) Nr:r:r:Nr;Nr<r=r>r?rBN)Nr:Nr[Nr;NNrLr<r=r>rBN)r:rSNNNrBN)rNT)N) NrNNFFrvFrhriN)r:r:F)rNrrFrrNrrrTTFNNN)NFN)N)N)NF)N)NNNTNNFN)F)Fr __module__ __qualname____doc__r?rnrrrpropertyrrrrrrrrrrrrrrrrr r rrrrrr-r9r:r.rJr/r0rrgr}rrurCrOrRrrPr\rrQrr]rrrrr9rerrrrrrvrr __classcell__rcrcrrhrX8s;m .  r# -      $   : '&   5  O (M        + _   * :rXcCs<|dkrt||}n"t|ddtjt|d||d}|S)z4Allocate data in memory or in memmap for preloading.)NTz path-likerzw+)moder~r)rnr%rDZmemmapr)rrr~rrcrcrhrs  rFcCst||r|nd}||S)aConvert indices to time. Parameters ---------- index : list-like | int List of ints or int representing points in time. use_first_samp : boolean If True, the time returned is relative to the session onset, else relative to the recording onset. Returns ------- times : ndarray Times corresponding to the index supplied. r)rnr)rrrZuse_first_samprrcrcrh_index_as_timesrcCs8t|r0t|dkr0t|d|ddS|SdS)Nrrr)rrndiffrr)rrcrcrhrsrc st|dttfddtt|}td}|j|d}t|trt t |t | @}t|dkrtt d|d|d |i}t|tr| D]@\}t|}|dkrfd d t|D} || |9<q|S) aGet scaling factors for data, given units. Parameters ---------- inst : instance of Raw | Epochs | Evoked The instance. %(units)s picks_idxs : ndarray The picks as provided through _picks_to_idx. Returns ------- ch_factors : ndarray of floats, shape(len(picks),) The sacling factors for each channel, ordered according to picks. Nr&)rrsi_units)rrzI"units" cannot be str if there is more than one channel type with a unit .rcsg|]\}}|kr|qSrcrc)rdZi_chrzch_typercrhrssz#_get_ch_factors..)rDrrjrnr$rrNZget_channel_typesr|rsetrtritems _get_scalingr5) instr&Z picks_idxsr'rZch_typesZ unit_ch_typeZch_unitrindicesrcrrhr s       r c szd}tdfddD}td}t|}|d}|krVt|d||t|tkrt|d|d |d t|D]B\}fd d |D}||krt|d|d |d qt|D]\}d } |ddkrd} |dks|dkrd} n$|d|kr6||d} nd} | dkr| rP| | 9} dkrd|| }qdkr|| }q|S)aReturn the scaling factor based on the channel type and a target unit. Parameters ---------- ch_type : str The channel type. target_unit : str The target unit for the provided channel type. Returns ------- scaling : float The scaling factor to convert from the si_unit (used by default for MNE objects) to the target unit. r[rcsi|]}||dqS)r)split)rdkey)rrcrhrisz _get_scaling..prefixesrz5 is not a channel type that can be scaled from units.z is not a valid unit for z, use a sub-multiple of z instead.csg|]}|qSrcrc)rdprefix)r si_unit_listrcrhrs,sz _get_scaling..Fr²Trum²rr)rNrrtrKeyErrorrrr5) rZ target_unitrZsi_units_splittedr Z prefix_listZ unit_listrZvalidZ has_squarefactorrc)rr rrhr sP        rc@s eZdZdZddZddZdS)rzEEnsure only _filenames, _raw_extras, and _read_segment_file are used.cCs(||_t|dst|j|_|j|_dS)Nr)_ReadSegmentFileProtector__rawrrrr)rgrmrcrcrhrLsz"_ReadSegmentFileProtector.__init__c Cs|jj||||||||SrY)rrrrrcrcrhrRsz,_ReadSegmentFileProtector._read_segment_fileN)rrrrrrrcrcrcrhrIsrc@s8eZdZdZddZeddZeddZdd Zd S) _RawShellzCreate a temporary raw object.cCs.d|_d|_d|_d|_d|_d|_d|_dSrY)rrrrrZ_rawdirrrfrcrcrhrZsz_RawShell.__init__cCs|j|jdS)Nrrrfrcrcrhrcsz_RawShell.n_timescCs|jSrYrrfrcrcrhrgsz_RawShell.annotationscCs$|dkrtgggd}||_dSrY)rUrr)rgrrcrcrhrksz_RawShell.set_annotationsN) rrrrrrrrrrcrcrcrhrWs   rcCst|j}||ks||kr,td|||ft||d}t|\}}|dkr| dkrfd|||f}q| dksrtt|||d}t||n|}| dkr|dkrt|||d}t dt |t||t |}n |}t }t d |t ||d d }t|\}t||||||j}|8t||||||||| || || | |||||| d d }W5QRXW5QRX||kr| dkstt dt |d|_t|||dkrt d||fS)zWrite raw file with splitting.z@Cannot write raw file with no data: %s -> %s (max: %s) requested)rprlrriz%s-%d%srsrzReserving possible split file z Writing %srrcT)rlzRenaming BIDS split file Fz[done])rrrr5rsplitextrr r>rrr_ReservedFilenamerrr_start_writing_rawr_write_raw_fidrshutilmove)rprmrrrror{rzrrr|rrxryrrpart_idx prev_fnamerlZ n_times_maxbaseext use_fnamereserved_fnamectxrr final_fnamercrcrhrwss|            rwc@s$eZdZddZddZddZdS)rc Cs>||_tt|st|t|dW5QRXd|_dS)NrT)rprisdirdirnamerrr)rgrprcrcrhrs   z_ReservedFilename.__init__cCs|SrYrcrfrcrcrhr sz_ReservedFilename.__enter__cCs|jrt|jdSrY)rrrp)rgexc_type exc_value tracebackrcrcrhrsz_ReservedFilename.__exit__N)rrrrr rrcrcrcrhrsrc'Cs|j|}|dkr t|tj||dkr| dk rt|tjt|tjtjt|tj | |ddk rxt |tj |dt|tj |dt |tj|}|| krtd|tt|||}t||}|d|kr||d<t|d\}}d}t|dkr@t||r.t||r.d}n|dkr@td d}| }t||D]\}}|r||k||k@r|d7}qRn|dkrt|tj|d}||||f\} }!t|!||kst| dk rt| | } | r||krt|!|krtd qFt d |d d |d dt!|| |||}"|"|}#|"| t"}$|$dkrvtd|#| |$|t"f|"| |#t"kr>|||kr>|}t#|||||||||||| | | ||d||\}%}&t|tjt|tjtj$t|tj t%&|%|ddk rt |tj |dt|tj |&t |tjqF|"}qRtd| |'ddrpt |tj(n t |tj)t |tj*|S)Nrmeas_idrzfile is larger than "split_size" after writing measurement information, you must use a larger value for split size: %s plus enough bytes for the chosen buffer_sizerrAFTzeAcquisition skips detected but did not fit evenly into output buffer_size, will be written as zeroes.z2Skipping data chunk due to small buffer ... [done]z Writing FIF Z6dz ... z ...zbuffer size (%s) is too large for the given split size (%s) by %s bytes after writing info (%s) and leaving enough space for end tags (%s): decrease "buffer_size_sec" or increase "split_size".z Closing %s maxshield)+rr&rZFIFF_FIRST_SAMPLErZ FIFFB_REFZ FIFF_REF_ROLEZFIFFV_ROLE_PREV_FILEr(ZFIFF_REF_FILE_NAMEr'ZFIFF_REF_FILE_IDZFIFF_REF_FILE_NUMr tellrrrarnrr+rZin1drrArrZFIFF_DATA_SKIPrrr>rrr_write_raw_bufferr*rwZFIFFV_ROLE_NEXT_FILErrr[FIFFB_IAS_RAW_DATAFIFFB_RAW_DATA FIFFB_MEAS)'rmrrrrrrrrr|rryrrrxrorprr{rzrrrlrZpos_prevZfirstsZlastsZ sk_onsetsZsk_endsZdo_skipsZn_current_skiprfirstlastrrposZthis_buff_size_bytesZoverageZ next_fnameZnext_idxrcrcrhrs     $              rcCst||}t|tjt|tj|ddk r@t|tj|dg}t|dD]V}|d|d|d<|dkrd|d|d <||d|d |d|d qPt ||||d t |d krt ||| d drt|tj n t|tj|S)aStart write raw data in file. Parameters ---------- fid : file The created file. %(info_not_none)s sel : array of int | None Indices of channels to include. If None, all channels are included. data_type : int The data_type in case it is necessary. Should be 4 (FIFFT_FLOAT), 5 (FIFFT_DOUBLE), 16 (FIFFT_DAU_PACK16), or 3 (FIFFT_INT) for raw data. reset_range : bool If True, the info['chs'][k]['range'] parameter will be set to unity. annotations : instance of Annotations The annotations to write. Returns ------- fid : file The file descriptor. cals : list calibration factors. r$Nr_rr`ZscannoTr[rarb)r{rzrr%F)r rrr*r'Z FIFF_BLOCK_IDZFIFF_PARENT_BLOCK_IDrarerrr,r[r(r))rrrrr{rzrrrrcrcrhr3 s$    (    rcCs|jdt|krtdtd|ddddgd}t|rt|dkrNt}d }q|dkr`t}d }q|dkrnt}qt }n$|dkrt }n|dkrt }ntd |t |d d d f}|r| tj}||tj|d S) aWrite raw buffer. Parameters ---------- fid : file descriptor an open raw data file. buf : array The buffer to write. cals : array Calibration factors. fmt : str 'short', 'int', 'single', or 'double' for 16/32 bit int or 32/64 bit float for each item. This will be doubled for complex datatypes. Note that short and int formats cannot be used for complex data. rz)buffer and calibration sizes do not matchrorxrwrvrZFTz=only "single" and "double" supported for writing complex dataN)rrrrGrnZ isrealobjr!r&r"r#r$r%rr4Zint32rZFIFF_DATA_BUFFER)rbufrroZcast_intZwrite_functionrcrcrhr'y s.  r'c sxtdtD]8}t|tds:td|ddD]R}|j|dj|}}||kr>td|d|dt|dt|q>t|jd tdjd kstd |t|j dj kstd |tdjd t|jd krtd tddt djd |jd Dstd qtfddDstt ddd_ dS)z7Ensure all instances of Raw have compatible parameters.rrzraw[z] type must match)r_rrz].info[z] must match: z != r]z&raw[%d]['info']['ch_names'] must matchzraw[%d]._cals must matchrqz,SSP projectors in raw files must be the samecss|]\}}t||VqdSrY)r)rdp1Zp2rcrcrhrm sz+_check_raw_compatibility..c3s|]}|jdjkVqdSrd)rurkrmrcrhrm szuraw files do not all have the same data format, could result in precision mismatch. Setting raw.orig_format="unknown"unknownN) rarr|rrrrreprrrrrrAru)rmr`rabrcr0rhr s,"$  & rr) on_mismatchr?c Cst|ddddD](\}}t|dj|jd|d|dq|dk rt|t|kr^tdtd d |D\}}t|||} |d|dd||dkr|dS|d| fSdS) aConcatenate `~mne.io.Raw` instances as if they were continuous. .. note:: ``raws[0]`` is modified in-place to achieve the concatenation. Boundaries of the raw files are annotated bad. If you wish to use the data as continuous recording, you can remove the boundary annotations after concatenation (see :meth:`mne.Annotations.delete`). Parameters ---------- raws : list List of `~mne.io.Raw` instances to concatenate (in order). %(preload_concatenate)s events_list : None | list The events to concatenate. Defaults to ``None``. %(on_mismatch_info)s %(verbose)s Returns ------- raw : instance of Raw The result of the concatenation (first Raw instance passed in). events : ndarray of int, shape (n_events, 3) The events. Only returned if ``event_list`` is not None. rN)rrzraws[])Zinfo1Zinfo2rr5z=`raws` and `event_list` are required to be of the same lengthcSsg|]}|j|jfqSrc)rrrkrcrcrhrs sz$concatenate_raws..)r5rrrrrrrTre) rfrZ events_listr5r?rrmr+r,r]rcrcrhconcatenate_raws s  r7cCs8d}|r$t|tr|dks4t|n|d7}t|dS)zWarn or error about MaxShield.zThis file contains raw Internal Active Shielding data. It may be distorted. Elekta recommends it be run through MaxFilter to produce reliable results. Consider closing the file and running MaxFilter on the data.yeszY Use allow_maxshield=True if you are sure you want to load the data despite this warning.N)r|rrAr)Zallow_maxshieldr,rcrcrh_check_maxshield s  r9)rF)NN)} contextlibrrrrrros.pathrrr collectionsrnumpyrn constantsrutilsr r rr r r rrZ meas_inforrrrrrrrZchannels.channelsrrrrZ compensatorrrwriterrr r!r"r#r$r%r&r'r(r)r*rr+r,r-rJr.r/r0r1r2r3r7r4r5r6r7r8r9r:r;r<r=r>r?r@rArBrCrDrErFrGrHrIrJrKrLrMdefaultsrNZvizrOrPrQrReventrSrTrUrVrWrXrrrr robjectrrrwrrrr'rr7r9rcrcrcrh s      <  l  ,?<s E0-