docs: def dqdv(voltage, capacity, voltage_resolution=None, capacity_resolution=None,
           voltage_fwhm=0.01, pre_smoothing=True, diff_smoothing=False,
           post_smoothing=True, post_normalization=True,
           interpolation_method=None, gaussian_order=None, gaussian_mode=None, gaussian_cval=None,
           gaussian_truncate=None, points_pr_split=None, savgol_filter_window_divisor_default=None,
           savgol_filter_window_order=None, max_points=None, **kwargs):
  
      """Convenience functions for creating dq-dv data from given capacity
      and voltage data.
  
      Args:
          voltage: nd.array or pd.Series
          capacity: nd.array or pd.Series
          voltage_resolution: used for interpolating voltage data (e.g. 0.005)
          capacity_resolution: used for interpolating capacity data
          voltage_fwhm: used for setting the post-processing gaussian sigma
          pre_smoothing: set to True for pre-smoothing (window)
          diff_smoothing: set to True for smoothing during differentiation (window)
          post_smoothing: set to True for post-smoothing (gaussian)
          post_normalization: set to True for normalising to capacity
          interpolation_method: scipy interpolation method
          gaussian_order: int
          gaussian_mode: mode
          gaussian_cval:
          gaussian_truncate:
          points_pr_split: only used when investigating data using splits
          savgol_filter_window_divisor_default: used for window smoothing
          savgol_filter_window_order: used for window smoothing
          max_points: restricting to max points in vector (capacity-selected)
  
      Returns: voltage, dqdv
  
      Notes:
          PEC data (Helge)
              pre_smoothing = False
              diff_smoothing = False
              pos_smoothing = False
              voltage_resolution = 0.005
          PEC data (Preben)
              ...
          Arbin data (IFE)
              ...
      """
  
      converter = Converter(**kwargs)
      logging.debug("dqdv - starting")
      logging.debug("dqdv - created Converter obj")
      converter.pre_smoothing = pre_smoothing
      converter.post_smoothing = post_smoothing
      converter.smoothing = diff_smoothing
      converter.normalize = post_normalization
      converter.voltage_fwhm = voltage_fwhm
      logging.debug(f"converter.pre_smoothing: {converter.pre_smoothing}")
      logging.debug(f"converter.post_smoothing: {converter.post_smoothing}")
      logging.debug(f"converter.smoothing: {converter.smoothing}")
      logging.debug(f"converter.normalise: {converter.normalize}")
      logging.debug(f"converter.voltage_fwhm: {converter.voltage_fwhm}")
  
      if voltage_resolution is not None:
          converter.voltage_resolution = voltage_resolution
  
      if capacity_resolution is not None:
          converter.capacity_resolution = capacity_resolution
  
      if savgol_filter_window_divisor_default is not None:
          converter.savgol_filter_window_divisor_default = savgol_filter_window_divisor_default
  
          logging.debug(f"converter.savgol_filter_window_divisor_default: "
                        f"{converter.savgol_filter_window_divisor_default}")
  
      if savgol_filter_window_order is not None:
          converter.savgol_filter_window_order = savgol_filter_window_order
  
          logging.debug(f"converter.savgol_filter_window_order: "
                        f"{converter.savgol_filter_window_order}")
  
      if gaussian_mode is not None:
          converter.gaussian_mode = gaussian_mode
  
      if gaussian_order is not None:
          converter.gaussian_order = gaussian_order
  
      if gaussian_truncate is not None:
          converter.gaussian_truncate = gaussian_truncate
  
      if gaussian_cval is not None:
          converter.gaussian_cval = gaussian_cval
  
      if interpolation_method is not None:
          converter.interpolation_method = interpolation_method
  
      if points_pr_split is not None:
          converter.points_pr_split = points_pr_split
  
      if max_points is not None:
          converter.max_points = max_points
  
      converter.set_data(capacity, voltage)
      converter.inspect_data()
      converter.pre_process_data()
      converter.increment_data()
      converter.post_process_data()
  
      return converter.voltage_processed, converter.incremental_capacity