docs: def get_fit(self, TrapFreq, WidthOfPeakToFit, A_Initial=0.1e10, Gamma_Initial=400, silent=False, MakeFig=True, show_fig=True):
          """
          Function that fits to a peak to the PSD to extract the 
          frequency, A factor and Gamma (damping) factor.
  
          Parameters
          ----------
          TrapFreq : float
              The approximate trapping frequency to use initially
              as the centre of the peak
          WidthOfPeakToFit : float
              The width of the peak to be fitted to. This limits the
              region that the fitting function can see in order to
              stop it from fitting to the wrong peak
          A_Initial : float, optional
              The initial value of the A parameter to use in fitting
          Gamma_Initial : float, optional
              The initial value of the Gamma parameter to use in fitting
          Silent : bool, optional
              Whether to print any output when running this function
              defaults to False
          MakeFig : bool, optional
              Whether to construct and return the figure object showing
              the fitting. defaults to True
          show_fig : bool, optional
              Whether to show the figure object when it has been created.
              defaults to True
  
          Returns
          -------
          A : uncertainties.ufloat
              Fitting constant A
              A = γ**2*2*Γ_0*(K_b*T_0)/(π*m)
              where:
              γ = conversionFactor
              Γ_0 = Damping factor due to environment
              π = pi
          OmegaTrap : uncertainties.ufloat
              The trapping frequency in the z axis (in angular frequency)
          Gamma : uncertainties.ufloat
              The damping factor Gamma = Γ = Γ_0 + δΓ
              where:
              Γ_0 = Damping factor due to environment
              δΓ = extra damping due to feedback or other effects
          fig : matplotlib.figure.Figure object
              figure object containing the plot
          ax : matplotlib.axes.Axes object
              axes with the data plotted of the:
              - initial data
              - smoothed data
              - initial fit
              - final fit
  
          """
          if MakeFig == True:
              Params, ParamsErr, fig, ax = fit_PSD(
                  self, WidthOfPeakToFit, TrapFreq, A_Initial, Gamma_Initial, MakeFig=MakeFig, show_fig=show_fig)
          else:
              Params, ParamsErr, _ , _ = fit_PSD(
                  self, WidthOfPeakToFit, TrapFreq, A_Initial, Gamma_Initial, MakeFig=MakeFig, show_fig=show_fig)
  
          if silent == False:
              print("\n")
              print("A: {} +- {}% ".format(Params[0],
                                           ParamsErr[0] / Params[0] * 100))
              print(
                  "Trap Frequency: {} +- {}% ".format(Params[1], ParamsErr[1] / Params[1] * 100))
              print(
                  "Big Gamma: {} +- {}% ".format(Params[2], ParamsErr[2] / Params[2] * 100))
  
          self.A = _uncertainties.ufloat(Params[0], ParamsErr[0])
          self.OmegaTrap = _uncertainties.ufloat(Params[1], ParamsErr[1])
          self.Gamma = _uncertainties.ufloat(Params[2], ParamsErr[2])
  
          
          if MakeFig == True:
              return self.A, self.OmegaTrap, self.Gamma, fig, ax
          else:
              return self.A, self.OmegaTrap, self.Gamma, None, None