docs: def get_fit_auto(self, CentralFreq, MaxWidth=15000, MinWidth=500, WidthIntervals=500, MakeFig=True, show_fig=True, silent=False):
          """
          Tries a range of regions to search for peaks and runs the one with the least error
          and returns the parameters with the least errors.
  
          Parameters
          ----------
          CentralFreq : float
              The central frequency to use for the fittings.
          MaxWidth : float, optional
              The maximum bandwidth to use for the fitting of the peaks.
          MinWidth : float, optional
              The minimum bandwidth to use for the fitting of the peaks.
          WidthIntervals : float, optional
              The intervals to use in going between the MaxWidth and MinWidth.
          show_fig : bool, optional
              Whether to plot and show the final (best) fitting or not.
  
          Returns
          -------
          OmegaTrap : ufloat
              Trapping frequency
          A : ufloat
              A parameter
          Gamma : ufloat
              Gamma, the damping parameter
          fig : matplotlib.figure.Figure object
              The figure object created showing the PSD of the data 
              with the fit
          ax : matplotlib.axes.Axes object
              The axes object created showing the PSD of the data 
              with the fit
  
          """
          MinTotalSumSquaredError = _np.infty
          for Width in _np.arange(MaxWidth, MinWidth - WidthIntervals, -WidthIntervals):
              try:
                  OmegaTrap, A, Gamma,_ , _ \
                      = self.get_fit_from_peak(
                          CentralFreq - Width / 2,
                          CentralFreq + Width / 2,
                          silent=True,
                          MakeFig=False,
                          show_fig=False)
              except RuntimeError:
                  _warnings.warn("Couldn't find good fit with width {}".format(
                      Width), RuntimeWarning)
                  val = _uncertainties.ufloat(_np.NaN, _np.NaN)
                  OmegaTrap = val
                  A = val
                  Gamma = val
              TotalSumSquaredError = (
                  A.std_dev / A.n)**2 + (Gamma.std_dev / Gamma.n)**2 + (OmegaTrap.std_dev / OmegaTrap.n)**2
              #print("totalError: {}".format(TotalSumSquaredError))
              if TotalSumSquaredError < MinTotalSumSquaredError:
                  MinTotalSumSquaredError = TotalSumSquaredError
                  BestWidth = Width
          if silent != True:
              print("found best")
          try:
              OmegaTrap, A, Gamma, fig, ax \
                  = self.get_fit_from_peak(CentralFreq - BestWidth / 2,
                                           CentralFreq + BestWidth / 2,
                                           MakeFig=MakeFig,
                                           show_fig=show_fig,
                                           silent=silent)
          except UnboundLocalError:
              raise ValueError("A best width was not found, try increasing the number of widths tried by either decreasing WidthIntervals or MinWidth or increasing MaxWidth")
          OmegaTrap = self.OmegaTrap
          A = self.A
          Gamma = self.Gamma
          self.FTrap = OmegaTrap/(2*pi)
          return OmegaTrap, A, Gamma, fig, ax