docs: def get_ZXY_data_IFFT(Data, zf, xf, yf,
                        zwidth=10000, xwidth=5000, ywidth=5000,
                        timeStart=None, timeEnd=None,
                        show_fig=True):
      """
      Given a Data object and the frequencies of the z, x and y peaks (and some
      optional parameters for the created filters) this function extracts the
      individual z, x and y signals (in volts) by creating IIR filters and filtering
      the Data.
  
      Parameters
      ----------
      Data : DataObject
          DataObject containing the data for which you want to extract the
          z, x and y signals.
      zf : float
          The frequency of the z peak in the PSD
      xf : float
          The frequency of the x peak in the PSD
      yf : float
          The frequency of the y peak in the PSD
      zwidth : float, optional
          The width of the pass-band of the IIR filter to be generated to
          filter Z.
      xwidth : float, optional
          The width of the pass-band of the IIR filter to be generated to
          filter X.
      ywidth : float, optional
          The width of the pass-band of the IIR filter to be generated to
          filter Y.
      timeStart : float, optional
          Starting time for filtering
      timeEnd : float, optional
          Ending time for filtering
      show_fig : bool, optional
          If True - plot unfiltered and filtered PSD for z, x and y.
          If False - don't plot anything
  
      Returns
      -------
      zdata : ndarray
          Array containing the z signal in volts with time.
      xdata : ndarray
          Array containing the x signal in volts with time.
      ydata : ndarray
          Array containing the y signal in volts with time.
      timedata : ndarray
          Array containing the time data to go with the z, x, and y signal.
      """
      if timeStart == None:
          timeStart = Data.timeStart
      if timeEnd == None:
          timeEnd = Data.timeEnd
  
      time = Data.time.get_array()
  
      StartIndex = _np.where(time == take_closest(time, timeStart))[0][0]
      EndIndex = _np.where(time == take_closest(time, timeEnd))[0][0]
  
      SAMPLEFREQ = Data.SampleFreq
  
      input_signal = Data.voltage[StartIndex: EndIndex]
  
      zdata = IFFT_filter(input_signal, SAMPLEFREQ, zf -
                          zwidth / 2, zf + zwidth / 2)
  
      xdata = IFFT_filter(input_signal, SAMPLEFREQ, xf -
                          xwidth / 2, xf + xwidth / 2)
  
      ydata = IFFT_filter(input_signal, SAMPLEFREQ, yf -
                          ywidth / 2, yf + ywidth / 2)
  
      if show_fig == True:
          NPerSegment = len(Data.time)
          if NPerSegment > 1e7:
              NPerSegment = int(1e7)
          f, PSD = scipy.signal.welch(
              input_signal, SAMPLEFREQ, nperseg=NPerSegment)
          f_z, PSD_z = scipy.signal.welch(zdata, SAMPLEFREQ, nperseg=NPerSegment)
          f_y, PSD_y = scipy.signal.welch(ydata, SAMPLEFREQ, nperseg=NPerSegment)
          f_x, PSD_x = scipy.signal.welch(xdata, SAMPLEFREQ, nperseg=NPerSegment)
          _plt.plot(f, PSD)
          _plt.plot(f_z, PSD_z, label="z")
          _plt.plot(f_x, PSD_x, label="x")
          _plt.plot(f_y, PSD_y, label="y")
          _plt.legend(loc="best")
          _plt.xlim([zf - zwidth, yf + ywidth])
          _plt.xlabel('Frequency (Hz)')
          _plt.ylabel(r'$S_{xx}$ ($V^2/Hz$)')
          _plt.semilogy()
          _plt.title("filepath = %s" % (Data.filepath))
          _plt.show()
  
      timedata = time[StartIndex: EndIndex]
      return zdata, xdata, ydata, timedata