code: def csd_array_multitaper(
      X,
      sfreq,
      t0=0,
      fmin=0,
      fmax=np.inf,
      tmin=None,
      tmax=None,
      ch_names=None,
      n_fft=None,
      bandwidth=None,
      adaptive=False,
      low_bias=True,
      projs=None,
      n_jobs=None,
      max_iter=250,
      *,
      verbose=None,
  ):
      """Estimate cross-spectral density from an array using a multitaper method.
  
      Parameters
      ----------
      X : array-like, shape (n_epochs, n_channels, n_times)
          The time series data consisting of n_epochs separate observations
          of signals with n_channels time-series of length n_times.
      sfreq : float
          Sampling frequency of observations.
      t0 : float
          Time of the first sample relative to the onset of the epoch, in
          seconds. Defaults to 0.
      fmin : float
          Minimum frequency of interest, in Hertz.
      fmax : float | np.inf
          Maximum frequency of interest, in Hertz.
      tmin : float | None
          Minimum time instant to consider, in seconds. If ``None`` start at
          first sample.
      tmax : float | None
          Maximum time instant to consider, in seconds. If ``None`` end at last
          sample.
      ch_names : list of str | None
          A name for each time series. If ``None`` (the default), the series will
          be named 'SERIES###'.
      n_fft : int | None
          Length of the FFT. If ``None``, the exact number of samples between
          ``tmin`` and ``tmax`` will be used.
      bandwidth : float | None
          The bandwidth of the multitaper windowing function in Hz.
      adaptive : bool
          Use adaptive weights to combine the tapered spectra into PSD.
      low_bias : bool
          Only use tapers with more than 90%% spectral concentration within
          bandwidth.
      projs : list of Projection | None
          List of projectors to store in the CSD object. Defaults to ``None``,
          which means no projectors are stored.
      %(n_jobs)s
      %(max_iter_multitaper)s
      %(verbose)s
  
      Returns
      -------
      csd : instance of CrossSpectralDensity
          The computed cross-spectral density.
  
      See Also
      --------
      csd_array_fourier
      csd_array_morlet
      csd_fourier
      csd_morlet
      csd_multitaper
      """
      X, times, tmin, tmax, fmin, fmax = _prepare_csd_array(
          X, sfreq, t0, tmin, tmax, fmin, fmax
      )
  
      # Slice X to the requested time window
      tstart = (
          None if tmin is None else np.searchsorted(times, tmin - 1e-10)
      )
      tstop = (
          None if tmax is None else np.searchsorted(times, tmax + 1e-10)
      )
      X = X[:, :, tstart:tstop]
      times = times[tstart:tstop]
      n_times = len(times)
      n_fft = n_times if n_fft is None else n_fft
  
      window_fun, eigvals, mt_adaptive = _compute_mt_params(
          n_times, sfreq, bandwidth, low_bias, adaptive
      )
  
      # Preparing frequencies of interest
      orig_frequencies = rfftfreq(n_fft, 1.0 / sfreq)
      freq_mask = (orig_frequencies > fmin) & (orig_frequencies < fmax)
      frequencies = orig_frequencies[freq_mask]
  
      if len(frequencies) == 0:
          raise ValueError(
              "No discrete fourier transform results within "
              "the given frequency window. Please widen either "
              "the frequency window or the time window"
          )
  
      # Compute the CSD
      return _execute_csd_function(
          X,
          times,
          frequencies,
          _csd_multitaper,
          params=[
              sfreq,
              n_times,
              window_fun,
              eigvals,
              freq_mask,
              n_fft,
              adaptive,
              max_iter,
          ],
          n_fft=n_fft,
          ch_names=ch_names,
          projs=projs,
          n_jobs=n_jobs,
          verbose=verbose,
      )
  
imports: import copy
  import numbers
  import numpy
  from scipy.fft import rfftfreq
  from .._fiff.pick import _picks_to_idx, pick_channels
  from ..parallel import parallel_func
  from ..time_frequency.multitaper import _compute_mt_params, _csd_from_mt, _mt_spectra, _psd_from_mt_adaptive
  from ..utils import ProgressBar, _check_fname, _import_h5io_funcs, _validate_type, copy_function_doc_to_method_doc, logger, verbose, warn
  from ..viz.misc import plot_csd
  from .tfr import EpochsTFR, _cwt_array, _get_nfft, morlet
label_desc: Use image node_id 9 for calling a global function with example usage: csd_array_multitaper(X, sfreq, t0, fmin, fmax, tmin, tmax, ch_names, n_fft, bandwidth, adaptive, low_bias, projs, n_jobs, max_iter) and returns: _execute_csd_function