ROOT logo
/*****************************************************************************
 * Project: RooFit                                                           *
 * Package: RooFitCore                                                       *
 *    File: $Id: RooFitResult.h,v 1.28 2007/05/11 09:11:30 verkerke Exp $
 * Authors:                                                                  *
 *   WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu       *
 *   DK, David Kirkby,    UC Irvine,         dkirkby@uci.edu                 *
 *                                                                           *
 * Copyright (c) 2000-2005, Regents of the University of California          *
 *                          and Stanford University. All rights reserved.    *
 *                                                                           *
 * Redistribution and use in source and binary forms,                        *
 * with or without modification, are permitted according to the terms        *
 * listed in LICENSE (http://roofit.sourceforge.net/license.txt)             *
 *****************************************************************************/
#ifndef ROO_FIT_RESULT
#define ROO_FIT_RESULT

#include "Riosfwd.h"
#include "RooAbsArg.h"
#include "RooPrintable.h"
#include "RooDirItem.h"
#include "RooArgList.h"

#include "RVersion.h"
#include "TMatrixFfwd.h"
#include "TMatrixDSym.h"
#include "TRootIOCtor.h"

#include <vector>
#include <string>
#include <map>

class RooArgSet ;
class RooAbsPdf ;
class RooPlot;
class TObject ;
class TH2 ;
typedef RooArgSet* pRooArgSet ;

class RooFitResult : public TNamed, public RooPrintable, public RooDirItem {
public:
 
  // Constructors, assignment etc.
  RooFitResult(const char* name=0, const char* title=0) ;
  RooFitResult(const RooFitResult& other) ;   			     
  virtual TObject* Clone(const char* newname = 0) const { 
    RooFitResult* r =  new RooFitResult(*this) ; 
    if (newname && *newname) r->SetName(newname) ; 
    return r ; 
  }
  virtual TObject* clone() const { return new RooFitResult(*this); }   
  virtual ~RooFitResult() ;

  static RooFitResult* lastMinuitFit(const RooArgList& varList=RooArgList()) ;

  // Printing interface (human readable)
  virtual void printValue(ostream& os) const ;
  virtual void printName(ostream& os) const ;
  virtual void printTitle(ostream& os) const ;
  virtual void printClassName(ostream& os) const ;
  virtual void printArgs(ostream& os) const ;
  void printMultiline(ostream& os, Int_t contents, Bool_t verbose=kFALSE, TString indent="") const ;

  inline virtual void Print(Option_t *options= 0) const {
    // Printing interface
    printStream(defaultPrintStream(),defaultPrintContents(options),defaultPrintStyle(options));
  }

  virtual Int_t defaultPrintContents(Option_t* opt) const ;
  virtual StyleOption defaultPrintStyle(Option_t* opt) const ;

  RooAbsPdf* createHessePdf(const RooArgSet& params) const ;

  // Accessors
  inline Int_t status() const {
    // Return MINUIT status code
    return _status ;     
  }

  inline UInt_t numStatusHistory() const { return _statusHistory.size() ; }
  Int_t statusCodeHistory(UInt_t icycle) ;
  const char* statusLabelHistory(UInt_t icycle) ;

  inline Int_t covQual() const { 
    // Return MINUIT quality code of covariance matrix
    return _covQual ; 
  }
  inline Int_t numInvalidNLL() const { 
    // Return number of NLL evaluations with problems
    return _numBadNLL ; 
  }
  inline Double_t edm() const { 
    // Return estimated distance to minimum
    return _edm ; 
  }
  inline Double_t minNll() const { 
    // Return minimized -log(L) value
    return _minNLL ; 
  }
  inline const RooArgList& constPars() const { 
    // Return list of constant parameters
    return *_constPars ; 
  }
  inline const RooArgList& floatParsInit() const { 
    // Return list of floating parameters before fit
    return *_initPars ; 
  } 
  inline const RooArgList& floatParsFinal() const { 
    // Return list of floarting parameters after fit
    return *_finalPars ; 
  } 

  TH2* correlationHist(const char* name = "correlation_matrix") const ;

  Double_t correlation(const RooAbsArg& par1, const RooAbsArg& par2) const {
    // Return correlation between par1 and par2
    return correlation(par1.GetName(),par2.GetName()) ;
  }
  const RooArgList* correlation(const RooAbsArg& par) const {
    // Return pointer to list of correlations of all parameters with par
    return correlation(par.GetName()) ;
  }

  Double_t correlation(const char* parname1, const char* parname2) const ;
  const RooArgList* correlation(const char* parname) const ;

  
  const TMatrixDSym& covarianceMatrix() const ;
  const TMatrixDSym& correlationMatrix() const ;
  TMatrixDSym reducedCovarianceMatrix(const RooArgList& params) const ;
  TMatrixDSym conditionalCovarianceMatrix(const RooArgList& params) const ;


  // Global correlation accessors
  Double_t globalCorr(const RooAbsArg& par) { return globalCorr(par.GetName()) ; }
  Double_t globalCorr(const char* parname) ;
  const RooArgList* globalCorr() ;


  // Add objects to a 2D plot
  inline RooPlot *plotOn(RooPlot *frame, const RooAbsArg &par1, const RooAbsArg &par2,
			 const char *options= "ME") const {
    // Plot error ellipse in par1 and par2 on frame
    return plotOn(frame,par1.GetName(),par2.GetName(),options);
  }
  RooPlot *plotOn(RooPlot *plot, const char *parName1, const char *parName2,
		  const char *options= "ME") const;

  // Generate random perturbations of the final parameters using the covariance matrix
  const RooArgList& randomizePars() const;

  Bool_t isIdentical(const RooFitResult& other, Double_t tol=5e-5, Double_t tolCorr=1e-4, Bool_t verbose=kTRUE) const ;

  void SetName(const char *name) ;
  void SetNameTitle(const char *name, const char* title) ;

protected:
  
  friend class RooMinuit ;
  friend class RooMinimizer ;
  friend class RooNag ;
  void setCovarianceMatrix(TMatrixDSym& V) ; 
  void setConstParList(const RooArgList& list) ;
  void setInitParList(const RooArgList& list) ;
  void setFinalParList(const RooArgList& list) ;
  inline void setMinNLL(Double_t val) { _minNLL = val ; }
  inline void setEDM(Double_t val) { _edm = val ; }
  inline void setStatus(Int_t val) { _status = val ; }
  inline void setCovQual(Int_t val) { _covQual = val ; }
  inline void setNumInvalidNLL(Int_t val) { _numBadNLL=val ; }
  void fillCorrMatrix() ;
  void fillCorrMatrix(const std::vector<double>& globalCC, const TMatrixDSym& corrs, const TMatrixDSym& covs) ;
  void fillLegacyCorrMatrix() const ;
  void setStatusHistory(std::vector<std::pair<std::string,int> >& hist) { _statusHistory = hist ; }

  Double_t correlation(Int_t row, Int_t col) const;
  Double_t covariance(Int_t row, Int_t col) const;

  Int_t    _status ;          // MINUIT status code
  Int_t    _covQual ;         // MINUIT quality code of covariance matrix
  Int_t    _numBadNLL ;       // Number calls with bad (zero,negative) likelihood 
  Double_t _minNLL ;          // NLL at minimum
  Double_t _edm ;             // Estimated distance to minimum
  RooArgList* _constPars ;    // List of constant parameters
  RooArgList* _initPars ;     // List of floating parameters with initial values
  RooArgList* _finalPars ;    // List of floating parameters with final values

  mutable RooArgList* _globalCorr ;   //! List of global correlation coefficients
  mutable TList       _corrMatrix ;   //! Correlation matrix (list of RooArgLists)

  mutable RooArgList *_randomPars; //! List of floating parameters with most recent random perturbation applied
  mutable TMatrixF* _Lt;            //! triangular matrix used for generate random perturbations

  TMatrixDSym* _CM ;  // Correlation matrix 
  TMatrixDSym* _VM ;  // Covariance matrix 
  TVectorD* _GC ;     // Global correlation coefficients 

  std::vector<std::pair<std::string,int> > _statusHistory ; // History of status codes
  
  ClassDef(RooFitResult,5) // Container class for fit result
};

#endif
 RooFitResult.h:1
 RooFitResult.h:2
 RooFitResult.h:3
 RooFitResult.h:4
 RooFitResult.h:5
 RooFitResult.h:6
 RooFitResult.h:7
 RooFitResult.h:8
 RooFitResult.h:9
 RooFitResult.h:10
 RooFitResult.h:11
 RooFitResult.h:12
 RooFitResult.h:13
 RooFitResult.h:14
 RooFitResult.h:15
 RooFitResult.h:16
 RooFitResult.h:17
 RooFitResult.h:18
 RooFitResult.h:19
 RooFitResult.h:20
 RooFitResult.h:21
 RooFitResult.h:22
 RooFitResult.h:23
 RooFitResult.h:24
 RooFitResult.h:25
 RooFitResult.h:26
 RooFitResult.h:27
 RooFitResult.h:28
 RooFitResult.h:29
 RooFitResult.h:30
 RooFitResult.h:31
 RooFitResult.h:32
 RooFitResult.h:33
 RooFitResult.h:34
 RooFitResult.h:35
 RooFitResult.h:36
 RooFitResult.h:37
 RooFitResult.h:38
 RooFitResult.h:39
 RooFitResult.h:40
 RooFitResult.h:41
 RooFitResult.h:42
 RooFitResult.h:43
 RooFitResult.h:44
 RooFitResult.h:45
 RooFitResult.h:46
 RooFitResult.h:47
 RooFitResult.h:48
 RooFitResult.h:49
 RooFitResult.h:50
 RooFitResult.h:51
 RooFitResult.h:52
 RooFitResult.h:53
 RooFitResult.h:54
 RooFitResult.h:55
 RooFitResult.h:56
 RooFitResult.h:57
 RooFitResult.h:58
 RooFitResult.h:59
 RooFitResult.h:60
 RooFitResult.h:61
 RooFitResult.h:62
 RooFitResult.h:63
 RooFitResult.h:64
 RooFitResult.h:65
 RooFitResult.h:66
 RooFitResult.h:67
 RooFitResult.h:68
 RooFitResult.h:69
 RooFitResult.h:70
 RooFitResult.h:71
 RooFitResult.h:72
 RooFitResult.h:73
 RooFitResult.h:74
 RooFitResult.h:75
 RooFitResult.h:76
 RooFitResult.h:77
 RooFitResult.h:78
 RooFitResult.h:79
 RooFitResult.h:80
 RooFitResult.h:81
 RooFitResult.h:82
 RooFitResult.h:83
 RooFitResult.h:84
 RooFitResult.h:85
 RooFitResult.h:86
 RooFitResult.h:87
 RooFitResult.h:88
 RooFitResult.h:89
 RooFitResult.h:90
 RooFitResult.h:91
 RooFitResult.h:92
 RooFitResult.h:93
 RooFitResult.h:94
 RooFitResult.h:95
 RooFitResult.h:96
 RooFitResult.h:97
 RooFitResult.h:98
 RooFitResult.h:99
 RooFitResult.h:100
 RooFitResult.h:101
 RooFitResult.h:102
 RooFitResult.h:103
 RooFitResult.h:104
 RooFitResult.h:105
 RooFitResult.h:106
 RooFitResult.h:107
 RooFitResult.h:108
 RooFitResult.h:109
 RooFitResult.h:110
 RooFitResult.h:111
 RooFitResult.h:112
 RooFitResult.h:113
 RooFitResult.h:114
 RooFitResult.h:115
 RooFitResult.h:116
 RooFitResult.h:117
 RooFitResult.h:118
 RooFitResult.h:119
 RooFitResult.h:120
 RooFitResult.h:121
 RooFitResult.h:122
 RooFitResult.h:123
 RooFitResult.h:124
 RooFitResult.h:125
 RooFitResult.h:126
 RooFitResult.h:127
 RooFitResult.h:128
 RooFitResult.h:129
 RooFitResult.h:130
 RooFitResult.h:131
 RooFitResult.h:132
 RooFitResult.h:133
 RooFitResult.h:134
 RooFitResult.h:135
 RooFitResult.h:136
 RooFitResult.h:137
 RooFitResult.h:138
 RooFitResult.h:139
 RooFitResult.h:140
 RooFitResult.h:141
 RooFitResult.h:142
 RooFitResult.h:143
 RooFitResult.h:144
 RooFitResult.h:145
 RooFitResult.h:146
 RooFitResult.h:147
 RooFitResult.h:148
 RooFitResult.h:149
 RooFitResult.h:150
 RooFitResult.h:151
 RooFitResult.h:152
 RooFitResult.h:153
 RooFitResult.h:154
 RooFitResult.h:155
 RooFitResult.h:156
 RooFitResult.h:157
 RooFitResult.h:158
 RooFitResult.h:159
 RooFitResult.h:160
 RooFitResult.h:161
 RooFitResult.h:162
 RooFitResult.h:163
 RooFitResult.h:164
 RooFitResult.h:165
 RooFitResult.h:166
 RooFitResult.h:167
 RooFitResult.h:168
 RooFitResult.h:169
 RooFitResult.h:170
 RooFitResult.h:171
 RooFitResult.h:172
 RooFitResult.h:173
 RooFitResult.h:174
 RooFitResult.h:175
 RooFitResult.h:176
 RooFitResult.h:177
 RooFitResult.h:178
 RooFitResult.h:179
 RooFitResult.h:180
 RooFitResult.h:181
 RooFitResult.h:182
 RooFitResult.h:183
 RooFitResult.h:184
 RooFitResult.h:185
 RooFitResult.h:186
 RooFitResult.h:187
 RooFitResult.h:188
 RooFitResult.h:189
 RooFitResult.h:190
 RooFitResult.h:191
 RooFitResult.h:192
 RooFitResult.h:193
 RooFitResult.h:194
 RooFitResult.h:195
 RooFitResult.h:196
 RooFitResult.h:197
 RooFitResult.h:198
 RooFitResult.h:199
 RooFitResult.h:200
 RooFitResult.h:201
 RooFitResult.h:202
 RooFitResult.h:203
 RooFitResult.h:204