[Math] Don't leak Minuit 2 implementation details to IFunction classes

The option to return external gradients in Minuit 2 internal space is
only used in RooFit, and these flags should not be present in math
function base classes. Refactor the code such that it's not needed.

Author: guitargeek

math/mathcore/inc/Math/IFunction.h

@@ -91,8 +91,6 @@ namespace ROOT {
          // if it inherits from ROOT::Math::IGradientFunctionMultiDim.
          virtual bool HasGradient() const { return false; }
 
-         virtual bool returnsInMinuit2ParameterSpace() const { return false; }
-
          /// Evaluate all the vector of function derivatives (gradient)  at a point x.
          /// Derived classes must re-implement it if more efficient than evaluating one at a time
          virtual void Gradient(const T *x, T *grad) const
@@ -103,17 +101,6 @@ namespace ROOT {
             }
          }
 
-         /// In some cases, the gradient algorithm will use information from the previous step, these can be passed
-         /// in with this overload. The `previous_*` arrays can also be used to return second derivative and step size
-         /// so that these can be passed forward again as well at the call site, if necessary.
-         virtual void GradientWithPrevResult(const T *x, T *grad, T *previous_grad, T *previous_g2, T *previous_gstep) const
-         {
-            unsigned int ndim = NDim();
-            for (unsigned int icoord  = 0; icoord < ndim; ++icoord) {
-               grad[icoord] = Derivative(x, icoord, previous_grad, previous_g2, previous_gstep);
-            }
-         }
-
          /// Optimized method to evaluate at the same time the function value and derivative at a point x.
          /// Often both value and derivatives are needed and it is often more efficient to compute them at the same time.
          /// Derived class should implement this method if performances play an important role and if it is faster to

math/minuit2/inc/Minuit2/FCNBase.h

@@ -113,6 +113,10 @@ class FCNBase {
    virtual bool HasGradient() const { return false; }
 
    virtual std::vector<double> Gradient(std::vector<double> const&) const { return {}; }
+
+   /// In some cases, the gradient algorithm will use information from the previous step, these can be passed
+   /// in with this overload. The `previous_*` arrays can also be used to return second derivative and step size
+   /// so that these can be passed forward again as well at the call site, if necessary.
    virtual std::vector<double> GradientWithPrevResult(std::vector<double> const& parameters, double * /*previous_grad*/,
                                                       double * /*previous_g2*/, double * /*previous_gstep*/) const
    {

math/minuit2/inc/Minuit2/Minuit2Minimizer.h

@@ -279,6 +279,9 @@ class Minuit2Minimizer : public ROOT::Math::Minimizer {
    /// return the minimizer state (containing values, step size , etc..)
    const ROOT::Minuit2::MnUserParameterState &State() { return fState; }
 
+   const ROOT::Minuit2::FCNBase *GetFCN() const { return fMinuitFCN; }
+   ROOT::Minuit2::FCNBase *GetFCN() { return fMinuitFCN; }
+
 protected:
    // protected function for accessing the internal Minuit2 object. Needed for derived classes
 
@@ -288,8 +291,6 @@ class Minuit2Minimizer : public ROOT::Math::Minimizer {
 
    void SetMinimizerType(ROOT::Minuit2::EMinimizerType type);
 
-   virtual const ROOT::Minuit2::FCNBase *GetFCN() const { return fMinuitFCN; }
-
    /// examine the minimum result
    bool ExamineMinimum(const ROOT::Minuit2::FunctionMinimum &min);
 

math/minuit2/src/Minuit2Minimizer.cxx

@@ -399,13 +399,7 @@ void Minuit2Minimizer::SetFunction(const ROOT::Math::IMultiGenFunction &func)
       if (hasGrad) {
          auto const &gradFunc = dynamic_cast<ROOT::Math::IMultiGradFunction const &>(func);
          auto lambdaGrad = [&gradFunc](double const *params, double *grad) { return gradFunc.Gradient(params, grad); };
-         auto lambdaGradWithPrevResult = [&gradFunc](const double *params, double *grad, double *previous_grad,
-                                                     double *previous_g2, double *previous_gstep) {
-            gradFunc.GradientWithPrevResult(params, grad, previous_grad, previous_g2, previous_gstep);
-         };
          adapter->SetGradientFunction(lambdaGrad);
-         adapter->SetGradWithPrevResultFunction(lambdaGradWithPrevResult);
-         adapter->SetReturnsInMinuit2ParameterSpace(gradFunc.returnsInMinuit2ParameterSpace());
       }
       fMinuitFCN = adapter;
    } else {

roofit/roofitcore/src/RooAbsMinimizerFcn.h

@@ -37,6 +37,8 @@ class RooAbsMinimizerFcn {
    RooAbsMinimizerFcn(RooArgList paramList, RooMinimizer *context);
    virtual ~RooAbsMinimizerFcn() = default;
 
+   virtual bool returnsInMinuit2ParameterSpace() const { return false; }
+
    /// Informs Minuit through its parameter_settings vector of RooFit parameter properties.
    bool synchronizeParameterSettings(std::vector<ROOT::Fit::ParameterSettings> &parameters, bool optConst);
    /// Like synchronizeParameterSettings, Synchronize informs Minuit through

roofit/roofitcore/src/RooMinimizer.cxx

@@ -67,6 +67,11 @@ automatic PDF optimization.
 #include <TGraph.h>
 #include <TMarker.h>
 
+#ifdef ROOFIT_MULTIPROCESS
+#include <Minuit2/Minuit2Minimizer.h>
+#include <Minuit2/FCNAdapter.h>
+#endif
+
 #include <fstream>
 #include <iostream>
 #include <stdexcept> // logic_error
@@ -1135,6 +1140,18 @@ void RooMinimizer::initMinimizer()
 {
    _minimizer = std::unique_ptr<ROOT::Math::Minimizer>(_config.CreateMinimizer());
    _minimizer->SetFunction(*getMultiGenFcn());
+#ifdef ROOFIT_MULTIPROCESS
+   if (_fcn->returnsInMinuit2ParameterSpace()) {
+      auto &rooFcn = dynamic_cast<RooFit::TestStatistics::MinuitFcnGrad &>(*_fcn);
+      auto &minim = dynamic_cast<ROOT::Minuit2::Minuit2Minimizer &>(*_minimizer);
+      auto &adapter = dynamic_cast<ROOT::Minuit2::FCNAdapter &>(*minim.GetFCN());
+      adapter.SetGradWithPrevResultFunction([&rooFcn](const double *params, double *grad, double *previous_grad,
+                                                      double *previous_g2, double *previous_gstep) {
+         rooFcn.GradientWithPrevResult(params, grad, previous_grad, previous_g2, previous_gstep);
+      });
+      adapter.SetReturnsInMinuit2ParameterSpace(true);
+   }
+#endif
    _minimizer->SetVariables(_config.ParamsSettings().begin(), _config.ParamsSettings().end());
 
    if (_cfg.setInitialCovariance) {

roofit/roofitcore/src/TestStatistics/MinuitFcnGrad.cxx

@@ -35,14 +35,6 @@ class MinuitGradFunctor : public ROOT::Math::IMultiGradFunction {
 
    void Gradient(const double *x, double *grad) const override { return _fcn.Gradient(x, grad); }
 
-   void GradientWithPrevResult(const double *x, double *grad, double *previous_grad, double *previous_g2,
-                               double *previous_gstep) const override
-   {
-      return _fcn.GradientWithPrevResult(x, grad, previous_grad, previous_g2, previous_gstep);
-   }
-
-   bool returnsInMinuit2ParameterSpace() const override { return _fcn.returnsInMinuit2ParameterSpace(); }
-
 private:
    double DoEval(const double *x) const override { return _fcn(x); }
 

roofit/roofitcore/src/TestStatistics/MinuitFcnGrad.h

@@ -37,8 +37,7 @@ class MinuitFcnGrad : public RooAbsMinimizerFcn {
    /// Overridden from RooAbsMinimizerFcn to include gradient strategy synchronization.
    bool Synchronize(std::vector<ROOT::Fit::ParameterSettings> &parameter_settings) override;
 
-   // used inside Minuit:
-   inline bool returnsInMinuit2ParameterSpace() const { return _gradient->usesMinuitInternalValues(); }
+   bool returnsInMinuit2ParameterSpace() const override { return _gradient->usesMinuitInternalValues(); }
 
    inline void setOptimizeConstOnFunction(RooAbsArg::ConstOpCode opcode, bool doAlsoTrackingOpt) override
    {