docs: def get_ZXY_data(Data, zf, xf, yf, FractionOfSampleFreq=1,
                   zwidth=10000, xwidth=5000, ywidth=5000,
                   filterImplementation="filtfilt",
                   timeStart=None, timeEnd=None,
                   NPerSegmentPSD=1000000,
                   MakeFig=True, 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
      FractionOfSampleFreq : integer, optional
          The fraction of the sample frequency to sub-sample the data by.
          This sometimes needs to be done because a filter with the appropriate
          frequency response may not be generated using the sample rate at which
          the data was taken. Increasing this number means the x, y and z signals
          produced by this function will be sampled at a lower rate but a higher
          number means a higher chance that the filter produced will have a nice
          frequency response.
      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.
      filterImplementation : string, optional
          filtfilt or lfilter - use scipy.filtfilt or lfilter
          default: filtfilt
      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 / FractionOfSampleFreq
  
      if filterImplementation == "filtfilt":
          ApplyFilter = scipy.signal.filtfilt
      elif filterImplementation == "lfilter":
          ApplyFilter = scipy.signal.lfilter
      else:
          raise ValueError("filterImplementation must be one of [filtfilt, lfilter] you entered: {}".format(
              filterImplementation))
  
      input_signal = Data.voltage[StartIndex: EndIndex][0::FractionOfSampleFreq]
  
      bZ, aZ = make_butterworth_bandpass_b_a(zf, zwidth, SAMPLEFREQ)
      print("filtering Z")
      zdata = ApplyFilter(bZ, aZ, input_signal)
  
      if(_np.isnan(zdata).any()):
          raise ValueError(
              "Value Error: FractionOfSampleFreq must be higher, a sufficiently small sample frequency should be used to produce a working IIR filter.")
  
      bX, aX = make_butterworth_bandpass_b_a(xf, xwidth, SAMPLEFREQ)
      print("filtering X")
      xdata = ApplyFilter(bX, aX, input_signal)
  
      if(_np.isnan(xdata).any()):
          raise ValueError(
              "Value Error: FractionOfSampleFreq must be higher, a sufficiently small sample frequency should be used to produce a working IIR filter.")
  
      bY, aY = make_butterworth_bandpass_b_a(yf, ywidth, SAMPLEFREQ)
      print("filtering Y")
      ydata = ApplyFilter(bY, aY, input_signal)
  
      if(_np.isnan(ydata).any()):
          raise ValueError(
              "Value Error: FractionOfSampleFreq must be higher, a sufficiently small sample frequency should be used to produce a working IIR filter.")
  
      if MakeFig == True:        
          f, PSD = scipy.signal.welch(
              input_signal, SAMPLEFREQ, nperseg=NPerSegmentPSD)
          f_z, PSD_z = scipy.signal.welch(zdata, SAMPLEFREQ, nperseg=NPerSegmentPSD)
          f_y, PSD_y = scipy.signal.welch(ydata, SAMPLEFREQ, nperseg=NPerSegmentPSD)
          f_x, PSD_x = scipy.signal.welch(xdata, SAMPLEFREQ, nperseg=NPerSegmentPSD)
          fig, ax = _plt.subplots(figsize=properties["default_fig_size"])
          ax.plot(f, PSD)
          ax.plot(f_z, PSD_z, label="z")
          ax.plot(f_x, PSD_x, label="x")
          ax.plot(f_y, PSD_y, label="y")
          ax.legend(loc="best")
          ax.semilogy()
          ax.set_xlim([zf - zwidth, yf + ywidth])
      else:
          fig = None
          ax = None
      if show_fig == True:
          _plt.show()
      timedata = time[StartIndex: EndIndex][0::FractionOfSampleFreq]
      return zdata, xdata, ydata, timedata, fig, ax