SequentialMinimizer.h

Go to the documentation of this file.

#ifndef HiggsAnalysis_CombinedLimit_SequentialMinimizer_h
#define HiggsAnalysis_CombinedLimit_SequentialMinimizer_h

struct RooAbsReal;
struct RooRealVar;
#include <vector>
#include <memory>
#include <Math/Minimizer.h>

namespace cmsmath {

    struct MinimizerContext {
        MinimizerContext(const ROOT::Math::IMultiGenFunction *function) : func(function), x(func->NDim()), nCalls(0) {}
        // convenience methods
        double eval() const { nCalls++; return (*func)(&x[0]); }
        double setAndEval(unsigned int i, double xi) const { x[i] = xi; return eval(); }
        double cleanEval(unsigned int i, double xi) const { double x0 = x[i]; x[i] = xi; double y = eval(); x[i] = x0; return y; }
        // data, fixed
        const ROOT::Math::IMultiGenFunction * func;
        // data, mutable
        mutable std::vector<double> x;
        mutable unsigned int nCalls;
    };

    class OneDimMinimizer {
        public:
            OneDimMinimizer() : f_(0), idx_(0) {}
            OneDimMinimizer(const MinimizerContext &ctx, unsigned int idx) :
                f_(&ctx), idx_(idx) {}
            OneDimMinimizer(const MinimizerContext &ctx, unsigned int idx, double xmin, double xmax, double xstep, const std::string &name) : 
                f_(&ctx), idx_(idx), name_(name), xmin_(xmin), xmax_(xmax), xstep_(xstep) {}

            const std::string &  name() const { return name_; }
            const char        * cname() const { return name_.c_str(); }
            double max() const { return  xmax_; }
            double min() const { return  xmin_; }
            double step() const { return  xstep_; }

            bool isInit() const { return f_ != 0; }
            void init(const MinimizerContext &ctx, unsigned int idx, double xmin, double xmax, double xstep, const std::string &name) {
                f_ = &ctx; idx_ = idx; 
                xmin_ = xmin; xmax_ = xmax; xstep_ = xstep;
                name_ = name;
            }
            void initUnbound(const MinimizerContext &ctx, unsigned int idx, double xstep, const std::string &name) {
                init(ctx, idx, -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity(), xstep, name);
            }
            // out of line to avoid including TString everywhere
            void initDefault(const MinimizerContext &ctx, unsigned int idx) ;

            bool minimize(int steps=1, double ytol=0, double xtol = 0);

            enum ImproveRet { Unchanged = 2, Done = 1, NotDone = 0 };
            ImproveRet improve(int steps=1, double ytol=0, double xtol = 0, bool force=true);
            
            void moveTo(double x) ;
        private:
            // Function
            const MinimizerContext * f_;
            // Index of myself
            unsigned int idx_;
            // My name
            std::string name_;

            // Point (x and y)
            double xi_[3], yi_[3];

            // Bounds and step
            double xmin_, xmax_, xstep_;

            bool doloop(int steps, double ytol, double xtol) ;

            void seek() ;

            void reseek() ;

            void goldenBisection();

            bool parabolaStep();

            double parabolaFit();

            inline double &x() { return f_->x[idx_]; }
            inline double eval() { return f_->eval(); }
            inline double eval(double x) { return f_->cleanEval(idx_, x); }

            inline void assign(int to, int from) { xi_[to] = xi_[from]; yi_[to] = yi_[from]; }
    };

    class SequentialMinimizer : public ROOT::Math::Minimizer {
        public:
            SequentialMinimizer(const char *name=0) : ROOT::Math::Minimizer() {}

            virtual void Clear() ;

            virtual void SetFunction(const ROOT::Math::IMultiGenFunction & func) ; 

            virtual bool SetVariable(unsigned int ivar, const std::string & name, double val, double step) ; 

            virtual bool SetLimitedVariable(unsigned int ivar, const std::string & name, double val, double  step, double  lower, double  upper) ; 

            virtual bool SetFixedVariable(unsigned int ivar, const std::string & name, double val) ; 

            virtual  bool Minimize() ; 

            virtual double MinValue() const { return minValue_;  }

            virtual double Edm() const { return edm_; }

            virtual const double *  X() const { return & func_->x[0]; }

            virtual const double *  MinGradient() const { return 0; }  

            virtual unsigned int NCalls() const { return func_->nCalls; }    

            virtual unsigned int NDim() const { return nDim_; }

            virtual unsigned int NFree() const { return nFree_;   }

            virtual bool ProvidesError() const { return false; } 

            virtual const double * Errors() const { return 0; }

            virtual double CovMatrix(unsigned int i, unsigned int j) const { return 0; }

            // these have to be public for ROOT to handle
            enum State { Cleared, Ready, Active, Done, Fixed, Unknown };
            struct Worker : public OneDimMinimizer {
                Worker() : OneDimMinimizer(), state(Unknown) {}
                State state;
                int   nUnaffected; 
            };
        protected:
            bool minimize(int smallsteps=5);
            bool improve(int smallsteps=5);
            bool doFullMinim(); 

            std::auto_ptr<MinimizerContext> func_;
            unsigned int nDim_, nFree_;

            // status information
            double minValue_;            
            double edm_;

            // Workers
            std::vector<Worker> workers_;
            State state_;

            // ROOT::Math::Minimizer for strategy 2
            std::auto_ptr<ROOT::Math::Minimizer> fullMinimizer_;
            std::vector<int> subspaceIndices_;
                    
    };

} // namespace
#endif