docs: def calc_phase_space(self, freq, ConvFactor, PeakWidth=10000, FractionOfSampleFreq=1, timeStart=None, timeEnd =None, PointsOfPadding=500, ShowPSD=False):
          """
          Calculates the position and velocity (in m) for use in plotting the phase space distribution.
  
          Parameters
          ----------
          freq : float
              The frequenecy of the peak (Trapping frequency of the dimension of interest)
          ConvFactor : float (or ufloat)
              The conversion factor between Volts and Meters
          PeakWidth : float, optional
              The width of the peak. Defaults to 10KHz
          FractionOfSampleFreq : int, optional
              The fraction of the sample freq to use to filter the data.
              Defaults to 1.
          timeStart : float, optional
              Starting time for data from which to calculate the phase space.
              Defaults to start of time data.
          timeEnd : float, optional
              Ending time for data from which to calculate the phase space.
              Defaults to start of time data.
          PointsOfPadding : float, optional
              How many points of the data at the beginning and end to disregard for plotting
              the phase space, to remove filtering artifacts. Defaults to 500
          ShowPSD : bool, optional
              Where to show the PSD of the unfiltered and the filtered signal used 
              to make the phase space plot. Defaults to False.
          *args, **kwargs : optional
              args and kwargs passed to qplots.joint_plot
  
  
          Returns
          -------
          time : ndarray
              time corresponding to position and velocity
          PosArray : ndarray
              Array of position of the particle in time
          VelArray : ndarray
              Array of velocity of the particle in time
          """
          _, Pos, fig, ax = self.filter_data(
              freq, FractionOfSampleFreq, PeakWidth, MakeFig=ShowPSD, show_fig=ShowPSD, timeStart=timeStart, timeEnd=timeEnd)
          time = self.time.get_array()
          if timeStart != None:
              StartIndex = _np.where(time == take_closest(time, timeStart))[0][0]
          else:
              StartIndex = 0
          if timeEnd != None:
              EndIndex = _np.where(time == take_closest(time, timeEnd))[0][0]
          else:
              EndIndex = -1
              
          Pos = Pos[PointsOfPadding : -PointsOfPadding+1]
          time = time[StartIndex:EndIndex][::FractionOfSampleFreq][PointsOfPadding : -PointsOfPadding+1]
          
          if type(ConvFactor) == _uncertainties.core.Variable:
              conv = ConvFactor.n
          else:
              conv = ConvFactor
          PosArray = Pos / conv # converts V to m
          VelArray = _np.diff(PosArray) * (self.SampleFreq / FractionOfSampleFreq) # calcs velocity (in m/s) by differtiating position
          return time, PosArray, VelArray