docs: def plot_phase_space_sns(self, freq, ConvFactor, PeakWidth=10000, FractionOfSampleFreq=1, kind="hex", timeStart=None, timeEnd =None, PointsOfPadding=500, units="nm", logscale=False, cmap=None, marginalColor=None, gridsize=200, show_fig=True, ShowPSD=False, alpha=0.5, *args, **kwargs):
          """
          Plots the phase space of a peak in the PSD.
          
          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.
          kind : string, optional
              kind of plot to draw - pass to jointplot from seaborne
          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.
          units : string, optional
              Units of position to plot on the axis - defaults to nm
          cmap : matplotlib.colors.ListedColormap, optional
              cmap to use for plotting the jointplot
          marginalColor : string, optional
              color to use for marginal plots
          gridsize : int, optional
              size of the grid to use with kind="hex"
          show_fig : bool, optional
              Whether to show the figure before exiting the function
              Defaults to True.
          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.
  
          Returns
          -------
          fig : matplotlib.figure.Figure object
              figure object containing the phase space plot
          JP : seaborn.jointplot object
              joint plot object containing the phase space plot
          """
          if cmap == None:
              if logscale == True:
                  cmap = properties['default_log_cmap']
              else:
                  cmap = properties['default_linear_cmap']
          
          unit_prefix = units[:-1]
  
          _, PosArray, VelArray = self.calc_phase_space(freq, ConvFactor, PeakWidth=PeakWidth, FractionOfSampleFreq=FractionOfSampleFreq, timeStart=timeStart, timeEnd=timeEnd, PointsOfPadding=PointsOfPadding, ShowPSD=ShowPSD)
  
          _plt.close('all')
          
          PosArray = unit_conversion(PosArray, unit_prefix) # converts m to units required (nm by default)
          VelArray = unit_conversion(VelArray, unit_prefix) # converts m/s to units required (nm/s by default)
          
          VarPos = _np.var(PosArray)
          VarVel = _np.var(VelArray)
          MaxPos = _np.max(PosArray)
          MaxVel = _np.max(VelArray)
          if MaxPos > MaxVel / (2 * pi * freq):
              _plotlimit = MaxPos * 1.1
          else:
              _plotlimit = MaxVel / (2 * pi * freq) * 1.1
  
          print("Plotting Phase Space")
  
          if marginalColor == None:
              try:
                  marginalColor = tuple((cmap.colors[len(cmap.colors)/2][:-1]))
              except AttributeError:
                  try:
                      marginalColor = cmap(2)
                  except:
                      marginalColor = properties['default_base_color']
  
          if kind == "hex":    # gridsize can only be passed if kind="hex"
              JP1 = _sns.jointplot(_pd.Series(PosArray[1:], name="$z$ ({}) \n filepath=%s".format(units) % (self.filepath)),
                                   _pd.Series(VelArray / (2 * pi * freq), name="$v_z$/$\omega$ ({})".format(units)),
                                   stat_func=None,
                                   xlim=[-_plotlimit, _plotlimit],
                                   ylim=[-_plotlimit, _plotlimit],
                                   size=max(properties['default_fig_size']),
                                   kind=kind,
                                   marginal_kws={'hist_kws': {'log': logscale},},
                                   cmap=cmap,
                                   color=marginalColor,
                                   gridsize=gridsize,
                                   alpha=alpha,
                                   *args,
                                   **kwargs,
              )
          else:
              JP1 = _sns.jointplot(_pd.Series(PosArray[1:], name="$z$ ({}) \n filepath=%s".format(units) % (self.filepath)),
                                       _pd.Series(VelArray / (2 * pi * freq), name="$v_z$/$\omega$ ({})".format(units)),
                                   stat_func=None,
                                   xlim=[-_plotlimit, _plotlimit],
                                   ylim=[-_plotlimit, _plotlimit],
                                   size=max(properties['default_fig_size']),
                                   kind=kind,
                                   marginal_kws={'hist_kws': {'log': logscale},},
                                   cmap=cmap,
                                   color=marginalColor,
                                   alpha=alpha,                                
                                   *args,
                                   **kwargs,
              )
  
          fig = JP1.fig
          
          if show_fig == True:
              print("Showing Phase Space")
              _plt.show()
              
          return fig, JP1