BasicMinimumError.h

Go to the documentation of this file.

// @(#)root/minuit2:$Id$
// Authors: M. Winkler, F. James, L. Moneta, A. Zsenei   2003-2005
 
/**********************************************************************
 *                                                                    *
 * Copyright (c) 2005 LCG ROOT Math team,  CERN/PH-SFT                *
 *                                                                    *
 **********************************************************************/
 
#ifndef ROOT_Minuit2_BasicMinimumError
#define ROOT_Minuit2_BasicMinimumError
 
#include "Minuit2/MnConfig.h"
#include "Minuit2/MnMatrix.h"
#include "Minuit2/LaSum.h"
#include "Minuit2/StackAllocator.h"
 
namespace ROOT {
 
namespace Minuit2 {
 
// extern StackAllocator gStackAllocator;
 
/**
   Internal Class containing the error information on the
   estimated minimum :
   Error matrix + dcovar + additional flags for quality and validity checks
 */
 
class BasicMinimumError {
 
public:
   class MnNotPosDef {
   };
   class MnMadePosDef {
   };
   class MnHesseFailed {
   };
   class MnInvertFailed {
   };
 
public:
   BasicMinimumError(unsigned int n)
      : fMatrix(MnAlgebraicSymMatrix(n)), fDCovar(1.), fValid(false), fPosDef(false), fMadePosDef(false),
        fHesseFailed(false), fInvertFailed(false), fAvailable(false)
   {
   }
 
   BasicMinimumError(const MnAlgebraicSymMatrix &mat, double dcov)
      : fMatrix(mat), fDCovar(dcov), fValid(true), fPosDef(true), fMadePosDef(false), fHesseFailed(false),
        fInvertFailed(false), fAvailable(true)
   {
   }
 
   BasicMinimumError(const MnAlgebraicSymMatrix &mat, MnHesseFailed)
      : fMatrix(mat), fDCovar(1.), fValid(false), fPosDef(false), fMadePosDef(false), fHesseFailed(true),
        fInvertFailed(false), fAvailable(true)
   {
   }
 
   BasicMinimumError(const MnAlgebraicSymMatrix &mat, MnMadePosDef)
      : fMatrix(mat), fDCovar(1.), fValid(true), fPosDef(false), fMadePosDef(true), fHesseFailed(false),
        fInvertFailed(false), fAvailable(true)
   {
   }
 
   BasicMinimumError(const MnAlgebraicSymMatrix &mat, MnInvertFailed)
      : fMatrix(mat), fDCovar(1.), fValid(false), fPosDef(true), fMadePosDef(false), fHesseFailed(false),
        fInvertFailed(true), fAvailable(true)
   {
   }
 
   BasicMinimumError(const MnAlgebraicSymMatrix &mat, MnNotPosDef)
      : fMatrix(mat), fDCovar(1.), fValid(false), fPosDef(false), fMadePosDef(false), fHesseFailed(false),
        fInvertFailed(false), fAvailable(true)
   {
   }
 
   ~BasicMinimumError() {}
 
   BasicMinimumError(const BasicMinimumError &e)
      : fMatrix(e.fMatrix), fDCovar(e.fDCovar), fValid(e.fValid), fPosDef(e.fPosDef), fMadePosDef(e.fMadePosDef),
        fHesseFailed(e.fHesseFailed), fInvertFailed(e.fInvertFailed), fAvailable(e.fAvailable)
   {
   }
 
   BasicMinimumError &operator=(const BasicMinimumError &err)
   {
      fMatrix = err.fMatrix;
      fDCovar = err.fDCovar;
      fValid = err.fValid;
      fPosDef = err.fPosDef;
      fMadePosDef = err.fMadePosDef;
      fHesseFailed = err.fHesseFailed;
      fInvertFailed = err.fInvertFailed;
      fAvailable = err.fAvailable;
      return *this;
   }
 
   void *operator new(size_t nbytes) { return StackAllocatorHolder::Get().Allocate(nbytes); }
 
   void operator delete(void *p, size_t /*nbytes */) { StackAllocatorHolder::Get().Deallocate(p); }
 
   MnAlgebraicSymMatrix Matrix() const { return 2. * fMatrix; }
 
   const MnAlgebraicSymMatrix &InvHessian() const { return fMatrix; }
 
   MnAlgebraicSymMatrix Hessian() const;
 
   double Dcovar() const { return fDCovar; }
   bool IsAccurate() const { return fDCovar < 0.1; }
   bool IsValid() const { return fValid; }
   bool IsPosDef() const { return fPosDef; }
   bool IsMadePosDef() const { return fMadePosDef; }
   bool HesseFailed() const { return fHesseFailed; }
   bool InvertFailed() const { return fInvertFailed; }
   bool IsAvailable() const { return fAvailable; }
 
private:
   MnAlgebraicSymMatrix fMatrix;
   double fDCovar;
   bool fValid;
   bool fPosDef;
   bool fMadePosDef;
   bool fHesseFailed;
   bool fInvertFailed;
   bool fAvailable;
};
 
} // namespace Minuit2
 
} // namespace ROOT
 
#endif // ROOT_Minuit2_BasicMinimumError