root/Minuit2/MinosError.h

0001 // @(#)root/minuit2:$Id$
0002 // Authors: M. Winkler, F. James, L. Moneta, A. Zsenei   2003-2005
0003
0004 /**********************************************************************
0005  *                                                                    *
0006  * Copyright (c) 2005 LCG ROOT Math team,  CERN/PH-SFT                *
0007  *                                                                    *
0008  **********************************************************************/
0009
0010 #ifndef ROOT_Minuit2_MinosError
0011 #define ROOT_Minuit2_MinosError
0012
0013 #include "Minuit2/MnCross.h"
0014 #include <utility>
0015
0016 namespace ROOT {
0017
0018 namespace Minuit2 {
0019
0020 //____________________________________________________________________________________
0021 /**
0022    Class holding the result of Minos (lower and upper values) for a specific parameter
0023  */
0024
0025 class MinosError {
0026
0027 public:
0028    MinosError() : fParameter(0), fMinParValue(0.), fUpper(MnCross()), fLower(MnCross()) {}
0029
0030    MinosError(unsigned int par, double value, const MnCross &low, const MnCross &up)
0031       : fParameter(par), fMinParValue(value), fUpper(up), fLower(low)
0032    {
0033    }
0034
0035    MinosError(const MinosError &err)
0036       : fParameter(err.fParameter), fMinParValue(err.fMinParValue), fUpper(err.fUpper), fLower(err.fLower)
0037    {
0038    }
0039
0040    MinosError &operator=(const MinosError &) = default;
0041
0042    MinosError &operator()(const MinosError &err)
0043    {
0044       fParameter = err.fParameter;
0045       fMinParValue = err.fMinParValue;
0046       fUpper = err.fUpper;
0047       fLower = err.fLower;
0048       return *this;
0049    }
0050
0051    std::pair<double, double> operator()() const { return std::pair<double, double>(Lower(), Upper()); }
0052    double Lower() const
0053    {
0054       if (AtLowerLimit())
0055          return LowerState().Parameter(Parameter()).LowerLimit() - fMinParValue;
0056       if (LowerValid()) {
0057          // Minos error is   value - error - aopt * error  where aopt is MnCross.Value()
0058          // If value - error is below the limit, error must be truncated at limit
0059          double err = LowerState().Error(Parameter());
0060          // error is truncated if over the limit
0061          if (LowerState().Parameter(Parameter()).HasLowerLimit())
0062             err = std::min(err, fMinParValue - LowerState().Parameter(Parameter()).LowerLimit());
0063          return -1. * err * (1. + fLower.Value());
0064       }
0065       // return Hessian Error in case is invalid
0066       return -LowerState().Error(Parameter());
0067    }
0068    double Upper() const
0069    {
0070       if (AtUpperLimit())
0071          return UpperState().Parameter(Parameter()).UpperLimit() - fMinParValue;
0072       if (UpperValid()) {
0073          // Minos error is   value + error + aopt * error  where aopt is MnCross.Value()
0074          // If value + error is over the limit,  err must be truncated at limit
0075          double err = UpperState().Error(Parameter());
0076          if (UpperState().Parameter(Parameter()).HasUpperLimit())
0077             err = std::min(err, UpperState().Parameter(Parameter()).UpperLimit() - fMinParValue);
0078          return err * (1. + fUpper.Value());
0079       }
0080       // return Hessian Error in case is invalid
0081       return UpperState().Error(Parameter());
0082    }
0083    unsigned int Parameter() const { return fParameter; }
0084    const MnUserParameterState &LowerState() const { return fLower.State(); }
0085    const MnUserParameterState &UpperState() const { return fUpper.State(); }
0086    bool IsValid() const { return fLower.IsValid() && fUpper.IsValid(); }
0087    bool LowerValid() const { return fLower.IsValid(); }
0088    bool UpperValid() const { return fUpper.IsValid(); }
0089    bool AtLowerLimit() const { return fLower.AtLimit(); }
0090    bool AtUpperLimit() const { return fUpper.AtLimit(); }
0091    bool AtLowerMaxFcn() const { return fLower.AtMaxFcn(); }
0092    bool AtUpperMaxFcn() const { return fUpper.AtMaxFcn(); }
0093    bool LowerNewMin() const { return fLower.NewMinimum(); }
0094    bool UpperNewMin() const { return fUpper.NewMinimum(); }
0095    unsigned int NFcn() const { return fUpper.NFcn() + fLower.NFcn(); }
0096    // return parameter value at the minimum
0097    double Min() const { return fMinParValue; }
0098
0099 private:
0100    unsigned int fParameter;
0101    double fMinParValue;
0102    MnCross fUpper;
0103    MnCross fLower;
0104 };
0105
0106 } // namespace Minuit2
0107
0108 } // namespace ROOT
0109
0110 #endif // ROOT_Minuit2_MinosError