I want to use TMinuit2 to fit some straight tracks (I assume it’s better than TMinuit), but all legacy code I can get are using TMinuit instead of TMinuit2, so here I have two questions:

Is TMinuit2 better than TMinuit? (even only in some cases)

Is there any example for how to use TMinuit2 comparing with doing the same thing with TMinuit?

Thanks for the post.
Minuit served us very well for a long time. However, ROOT is transitioning to the Minuit2 minimizer, that builds on the experience of Minuit and, only because of that, aims to be better than that.
I would perhps start by pointing you to ROOT: Minuit2

And I have another question, in the Fitting function I need to use some extra information instead of fitting parameters, I made it a class and Fitting function is a member function so that it can access the member parameter in the class, but when write ROOT::Math::Functor functionRT(&FittingFunctionRT, 4); I got this:

error: must explicitly qualify name of member function when taking its address

then I added the namespace ROOT::Math::Functor functionRT(&TrackFitMinimizer::FittingFunctionRT, 4); I got this error:

Functor.h:121:14: error: called object type 'double (TrackFitMinimizer::*)(const double *)' is not a function or function pointer
return fFunc(x);

Thank you, I understood about the error, and can you please tell more details about the functions I mentioned before? What are the difference of them? And Do I need to set the second one when using TMinuit2?

For creating the Functor class from a non-static member function, you need to pass a pointer to the class itself, in order to get its data, and the member function pointer. Here is an example of using the Functor class from Mathematical libraries - ROOT

#include "Math/Functor.h"
class MyFunction {
public:
double operator()(const double *x) const
{
return x[0]+x[1];
}
double Eval(const double * x) const
{
return x[0]+x[1];
}
};
double freeFunction(const double * x ) {
return x[0]+x[1];
}
int main() {
// Test directly calling the function object.
MyFunction myf;
// Test from a free function pointer.
ROOT::Math::Functor f1(&freeFunction,2);
// Test from function object.
ROOT::Math::Functor f2(myf,2);
// Test from a member function.
ROOT::Math::Functor f3(&myf,&MyFunction::Eval,2);
double x[] = {1,2};
cout << f1(x) << endl;
cout << f2(x) << endl;
cout << f3(x) << endl;
return 0;
}

Then for doing the minimization you should not use the TMinuit2 class. This is a legacy and deprecated class, that has a signature similar to TMinuit. For minimising a function, you should use the minimiser interface, as described in this tutorial: ROOT: tutorials/fit/NumericalMinimization.C File Reference.

Minuit and Minuit2 do not have a limit on the maximum number of iterations but on the number of function calls. Normally, if not computing the Hessian but computing numerical derivatives you have something like: