Perform MINUIT fits in one or two dimensions. More...

#include <Fit.h>

Inheritance diagram for ana::Fitter:

Classes
struct	SeedPt

Public Types
enum	Verbosity { kQuiet, kVerbose }

enum	Precision { kFast = 0, kNormal = 1, kCareful = 2, kGradDesc = 3, kAlgoMask = 3, kIncludeSimplex = 4, kIncludeHesse = 8, kIncludeMinos = 16 }

Public Member Functions
void	SetPrecision (Precision prec)

	Fitter (const IExperiment expt, std::vector< const IFitVar > vars, std::vector< const ISyst * > systs={}, Precision prec=kNormal)

double	Fit (osc::IOscCalcAdjustable seed, SystShifts &bestSysts=junkShifts, const std::map< const IFitVar , std::vector< double >> &seedPts={}, const std::vector< SystShifts > &systSeedPts={}, Verbosity verb=kVerbose) const

double	Fit (osc::IOscCalcAdjustable *seed, SystShifts &systSeed, Verbosity verb) const
	Variant with no seedPts. More...

double	Fit (osc::IOscCalcAdjustable *seed, Verbosity verb) const
	Variant with no seedPts and no systematics result returned. More...

double	Fit (SystShifts &systSeed, Verbosity verb=kVerbose) const
	Variant with no oscillations - useful for ND fits. More...

TMatrixDSym *	GetCovariance ()
	Return the fit covariance. More...

int	GetCovarianceStatus ()
	covariance matrix status (0 = not valid, 1 approximate, 2, full but made pos def, 3 accurate and not pos def) More...

std::vector< std::string >	GetParamNames ()
	Return the fit names. More...

std::vector< double >	GetPreFitValues ()
	Return the prefit values. More...

std::vector< double >	GetPreFitErrors ()
	Return the prefit errors. More...

std::vector< double >	GetPostFitValues ()
	Return the postfit values. More...

std::vector< double >	GetPostFitErrors ()
	Return the postfit errors. More...

std::vector< std::pair< double, double > >	GetMinosErrors ()
	Return the minos errors. More...

int	GetNFCN ()
	Return number of function calls. More...

double	GetEDM ()
	Return edm form the fit. More...

bool	GetIsValid ()
	Say whether the fit was good. More...

SystShifts	GetSystShifts () const

virtual double	DoEval (const double *pars) const override
	Evaluate the log-likelihood, as required by MINUT interface. More...

virtual unsigned int	NDim () const override

Fitter *	Clone () const override

Protected Member Functions
std::vector< SeedPt >	ExpandSeeds (const std::map< const IFitVar *, std::vector< double >> &seedPts, std::vector< SystShifts > systSeedPts) const

std::unique_ptr < ROOT::Math::Minimizer >	FitHelperSeeded (osc::IOscCalcAdjustable *seed, SystShifts &systSeed, Verbosity verb) const
	Helper for FitHelper. More...

double	FitHelper (osc::IOscCalcAdjustable seed, SystShifts &bestSysts, const std::map< const IFitVar , std::vector< double >> &seedPts, std::vector< SystShifts > systSeedPts, Verbosity verb) const
	Helper for Fit. More...

void	DecodePars (const double *pars) const
	Updates mutable fCalc and fShifts. More...

Protected Attributes
const IExperiment *	fExpt

std::vector< const IFitVar * >	fVars

std::vector< const ISyst * >	fSysts

Precision	fPrec = kNormal

osc::IOscCalcAdjustable *	fCalc

SystShifts	fShifts

int	fNEval = 0

int	fNEvalGrad = 0

int	fNEvalFiniteDiff = 0

double	fEdm = -1

bool	fIsValid = false

TMatrixDSym *	fCovar

bool	fCovarStatus

std::vector< std::string >	fParamNames

std::vector< double >	fPreFitValues

std::vector< double >	fPreFitErrors

std::vector< double >	fPostFitValues

std::vector< double >	fPostFitErrors

std::vector< std::pair< double, double > >	fMinosErrors

std::vector< std::pair< double, double > >	fTempMinosErrors

Detailed Description

Perform MINUIT fits in one or two dimensions.

Definition at line 37 of file Fit.h.

Member Enumeration Documentation

enum ana::Fitter::Precision

Enumerator
kFast
kNormal
kCareful
kGradDesc
kAlgoMask
kIncludeSimplex
kIncludeHesse
kIncludeMinos

Definition at line 42 of file Fit.h.

                   {
       // You must select one of these. The first three codes match the settings
       // used by migrad. The fourth is a custom minimizer.
       kFast = 0,
       kNormal = 1,
       kCareful = 2,
       kGradDesc = 3,
       // Allow bitmask operations to extract these first four options
       kAlgoMask = 3,
       // You may optionally specify this (eg kNormal | kIncludeSimplex) to
       // improve the chances of escaping from invalid minima
       kIncludeSimplex = 4,
       // You may optionally specify these to improve the final error estimates
       kIncludeHesse = 8,
       kIncludeMinos = 16
     };

enum ana::Fitter::Verbosity

Enumerator
kQuiet
kVerbose

Definition at line 40 of file Fit.h.

40 {kQuiet, kVerbose};

ana::Fitter::kVerbose

Definition: Fit.h:40

ana::Fitter::kQuiet

Definition: Fit.h:40

Constructor & Destructor Documentation

ana::Fitter::Fitter	(	const IExperiment *	expt,
		std::vector< const IFitVar * >	vars,
		std::vector< const ISyst * >	systs = `{}`,
		Precision	prec = `kNormal`
	)

Definition at line 53 of file Fit.cxx.

     : fExpt(expt), fVars(vars), fSysts(systs), fPrec(prec), fCalc(0),
       fCovar(0), fCovarStatus(-1)
   {
   }

Member Function Documentation

Fitter* ana::Fitter::Clone ( ) const

inlineoverride

Definition at line 140 of file Fit.h.

     {
       std::cout << "Fitter::Clone() not implemented" << std::endl;
       abort();
     }

void ana::Fitter::DecodePars ( const double * pars ) const

protected

Updates mutable fCalc and fShifts.

Definition at line 338 of file Fit.cxx.

   {
     for(unsigned int i = 0; i < fVars.size(); ++i){
       const double val = pars[i];
       if(isnan(val) || isinf(val)){
         std::cout << "Fitter::DecodePars(). Minuit wants to set " << fVars[i]->ShortName() << " = " << val << ". Will ignore it and hope for the best." << std::endl;
         // To debug this problem uncomment this abort and run in gdb
         // abort();
       }
       else{
         fVars[i]->SetValue(fCalc, val);
       }
     }
     for(unsigned int j = 0; j < fSysts.size(); ++j){
       const double val = pars[fVars.size()+j];
       if(isnan(val) || isinf(val)){
         std::cout << "Fitter::DecodePars(). Minuit wants to set " << fSysts[j]->ShortName() << " = " << val << ". Will ignore it and hope for the best." << std::endl;
         // To debug this problem uncomment this abort and run in gdb
         // abort();
       }
       else{
         fShifts.SetShift(fSysts[j], val);
       }
     }
   }

double ana::Fitter::DoEval ( const double * pars ) const

overridevirtual

Evaluate the log-likelihood, as required by MINUT interface.

Definition at line 365 of file Fit.cxx.

   {
     ++fNEval;
 
     DecodePars(pars); // Updates fCalc and fShifts
 
     // Have to re-fetch the values because DecodePars() will have truncated
     // values to the physical range where necessary.
     double penalty = 0;
     for(unsigned int i = 0; i < fVars.size(); ++i){
       const double x = pars[i];
       if(isinf(x) || isnan(x)) continue; // DecodePars() should have warned
       penalty += fVars[i]->Penalty(x, fCalc);
     }
     for(unsigned int j = 0; j < fSysts.size(); ++j){
       const double x = pars[fVars.size()+j];
       if(isinf(x) || isnan(x)) continue; // DecodePars() should have warned
       penalty += fSysts[j]->Penalty(x);
     }
 
     if(fNEval%1000 == 0) std::cout << fNEval << ": EXPT chi2 = " << fExpt->ChiSq(fCalc, fShifts) << "; penalty = " << penalty << std::endl;
     return fExpt->ChiSq(fCalc, fShifts) + penalty;
   }

std::vector< Fitter::SeedPt > ana::Fitter::ExpandSeeds	(	const std::map< const IFitVar *, std::vector< double >> &	seedPts,
		std::vector< SystShifts >	systSeedPts
	)		const

protected

Definition at line 64 of file Fit.cxx.

   {
     std::vector<SeedPt> ret;
     ret.push_back(SeedPt());
 
     for(auto it: seedPts){
       // For every variable, duplicate every entry in ret with the value set to
       // each possibility.
       const IFitVar* fv = it.first;
       std::vector<SeedPt> newret;
       for(double val: it.second){
         for(SeedPt pt: ret){
           pt.fitvars[fv] = val;
           newret.push_back(pt);
         }
       } // end for val
       ret = newret;
     } // end for it
 
     // Now duplicate as many times as required for the syst seeds
     if(!systSeedPts.empty()){
       std::vector<SeedPt> newret;
       for(const SystShifts& s: systSeedPts){
         for(SeedPt pt: ret){
           pt.shift = s;
           newret.push_back(pt);
         }
       }
       ret = newret;
     }
 
     return ret;
   }

double ana::Fitter::Fit	(	osc::IOscCalcAdjustable *	seed,
		SystShifts &	bestSysts = `junkShifts`,
		const std::map< const IFitVar *, std::vector< double >> &	seedPts = `{}`,
		const std::vector< SystShifts > &	systSeedPts = `{}`,
		Verbosity	verb = `kVerbose`
	)		const

Parameters

[out]	seed	Seed parameter and output best-fit point
[out]	bestSysts	Best systematics result returned here
	seedPts	Set each var to each of the values. Try all combinations. Beware of combinatorical explosion...
	systSeedPts	If non-empty, try fit starting at each of these
	verb	If quiet, no printout

Returns: -2x the log-likelihood of the best-fit point

Definition at line 276 of file Fit.cxx.

   {
     // Fits with no osc calc shouldn't be trying to optimize any
     // oscilation parameters...
     assert(seed || fVars.empty());
 
     for(const auto& it: seedPts){
       if(std::find(fVars.begin(), fVars.end(), it.first) == fVars.end()){
         std::cout << "ERROR Fitter::Fit() trying to seed '"
                   << it.first->ShortName()
                   << "' which is not part of the fit." << std::endl;
          abort();
       }
     }
     for(const auto& it: systSeedPts){
       for(const ISyst* s: it.ActiveSysts()){
         if(std::find(fSysts.begin(), fSysts.end(), s) == fSysts.end()){
           std::cout << "ERROR Fitter::Fit() trying to seed '"
                     << s->ShortName()
                     << "' which is not part of the fit." << std::endl;
           abort();
         }
       }
     }
 
     if(verb == kVerbose){
       std::cout << "Finding best fit for";
       for(const IFitVar* v: fVars) std::cout << " " << v->ShortName();
       for(const ISyst* s: fSysts) std::cout << " " << s->ShortName();
       std::cout << "..." << std::endl;
     }
 
     // Do all the actual work. This wrapper function is just so we can have
     // better control of printing.
     const double chi = FitHelper(seed, bestSysts, seedPts, systSeedPts, verb);
 
     if(verb == kVerbose){
       std::cout << "Best fit";
       for(const IFitVar* v: fVars){
         std::cout << ", " << v->ShortName() << " = " << v->GetValue(seed);
       }
       for(const ISyst* s: fSysts){
         std::cout << ", " << s->ShortName() << " = " << bestSysts.GetShift(s);
       }
       std::cout << ", LL = " << chi << std::endl;
 
       std::cout << "  found with " << fNEval << " evaluations of the likelihood";
       if(fNEvalFiniteDiff > 0)
         std::cout << " (" << fNEvalFiniteDiff << " to evaluate gradients numerically)";
       if(fNEvalGrad > 0)
         std::cout << " and " << fNEvalGrad << " evaluations of the gradient";
       std::cout << std::endl;
     }
 
     return chi;
   }

double ana::Fitter::Fit	(	osc::IOscCalcAdjustable *	seed,
		SystShifts &	systSeed,
		Verbosity	verb
	)		const

inline

Variant with no seedPts.

Definition at line 79 of file Fit.h.

     {
       return Fit(seed, systSeed, {}, std::vector<SystShifts>(1, systSeed), verb);
     }

double ana::Fitter::Fit	(	osc::IOscCalcAdjustable *	seed,
		Verbosity	verb
	)		const

inline

Variant with no seedPts and no systematics result returned.

Definition at line 87 of file Fit.h.

     {
       return Fit(seed, junkShifts, {}, {}, verb);
     }

double ana::Fitter::Fit	(	SystShifts &	systSeed,
		Verbosity	verb = `kVerbose`
	)		const

inline

Variant with no oscillations - useful for ND fits.

Definition at line 94 of file Fit.h.

     {
       return Fit(0, systSeed, {}, std::vector<SystShifts>(1, systSeed), verb);
     }

double ana::Fitter::FitHelper	(	osc::IOscCalcAdjustable *	seed,
		SystShifts &	bestSysts,
		const std::map< const IFitVar *, std::vector< double >> &	seedPts,
		std::vector< SystShifts >	systSeedPts,
		Verbosity	verb
	)		const

protected

Helper for Fit.

Definition at line 176 of file Fit.cxx.

   {
     const std::vector<SeedPt> pts = ExpandSeeds(seedPts, systSeedPts);
     double minchi = 1e10;
     std::vector<double> bestFitPars, bestSystPars;
 
     for(const SeedPt& pt: pts){
       osc::IOscCalcAdjustable *seed = initseed->Copy();
 
       for(auto it: pt.fitvars) it.first->SetValue(seed, it.second);
 
       // Need to deal with parameters that are not fit values!
       SystShifts shift = pt.shift;
 
       // Need to copy over syst values into the seed for this fit 
       // that were in the input syst shifts, but are not being fit for, 
       // and therefore not part of the seedPts list
       for(auto s: bestSysts.ActiveSysts()) {
         auto fit_systs = shift.ActiveSysts();
         if(std::find(fit_systs.begin(), fit_systs.end(), s) == fit_systs.end()) {
           shift.SetShift(s, bestSysts.GetShift(s));
         }
       }
 
       std::unique_ptr<ROOT::Math::Minimizer> thisMin =
           FitHelperSeeded(seed, shift, verb);
 
       // Check whether this is the best minimum we've found so far
       if (thisMin->MinValue() < minchi) {
         minchi = thisMin->MinValue();
 
         // Need to do Prefit here too...
         fParamNames    .clear();
         fPreFitValues  .clear();
         fPreFitErrors  .clear();
         fPostFitValues .clear();
         fPostFitErrors .clear();
         fMinosErrors   .clear();
         fMinosErrors   = fTempMinosErrors;
 
         // Save pre-fit info
         // In principle, these can change with the seed, so have to save them here...
         for(const IFitVar* v: fVars){
           const double val = v->GetValue(seed);
           fParamNames  .push_back(v->ShortName());
           fPreFitValues.push_back(val);
           fPreFitErrors.push_back(val ? val/2 : .1);
         }
         for(const ISyst* s: fSysts){
           const double val = shift.GetShift(s);
           fParamNames  .push_back(s->ShortName());
           fPreFitValues.push_back(val);
           fPreFitErrors.push_back(1);
         }
 
         // Now save postfit
         fPostFitValues = std::vector<double>(thisMin->X(), thisMin->X()+thisMin->NDim());
         fPostFitErrors = std::vector<double>(thisMin->Errors(), thisMin->Errors()+thisMin->NDim());
 
         fEdm = thisMin->Edm();
         fIsValid = !thisMin->Status();
 
         delete fCovar;
         fCovar = new TMatrixDSym(thisMin->NDim());
 
         for(unsigned int row = 0; row < thisMin->NDim(); ++row){
           for(unsigned int col = 0; col < thisMin->NDim(); ++col){
             (*fCovar)(row, col) = thisMin->CovMatrix(row, col);
           }
         }
 
         // Store the best fit values of all the parameters we know are being varied.
         for(unsigned int i = 0; i < fVars.size(); ++i)
           bestFitPars.push_back(fPostFitValues[i]);
         for(unsigned int j = 0; j < fSysts.size(); ++j)
           bestSystPars.push_back(fPostFitValues[fVars.size()+j]);
       }
       delete seed;
     }
 
     // Stuff the results of the actual best fit back into the seeds
     for(unsigned int i = 0; i < fVars.size(); ++i)
       fVars[i]->SetValue(initseed, bestFitPars[i]);
     for(unsigned int i = 0; i < fSysts.size(); ++i)
       bestSysts.SetShift(fSysts[i], bestSystPars[i]);
 
     return minchi;
   }

std::unique_ptr< ROOT::Math::Minimizer > ana::Fitter::FitHelperSeeded	(	osc::IOscCalcAdjustable *	seed,
		SystShifts &	systSeed,
		Verbosity	verb
	)		const

protected

Helper for FitHelper.

Definition at line 102 of file Fit.cxx.

   {
     // Why, when this is called for each seed?
     fCalc = seed;
     fShifts = systSeed;
 
     if(fPrec & kIncludeSimplex) std::cout << "Simplex option specified but not implemented. Ignored." << std::endl;
     if((fPrec & kAlgoMask) == kGradDesc){
       std::cout << "GradDesc option specified but not implemented. Abort." << std::endl;
       abort();
     }
 
     std::unique_ptr<ROOT::Math::Minimizer> mnMin(
         ROOT::Math::Factory::CreateMinimizer("Minuit2", "Combined"));
     mnMin->SetStrategy(int(fPrec & kAlgoMask));
     mnMin->SetMaxFunctionCalls(1E8);
     mnMin->SetMaxIterations(1E8);
 
     for(const IFitVar* v: fVars){
       const double val = v->GetValue(seed);
       // name, value, error
       mnMin->SetVariable(mnMin->NFree(), v->ShortName(), val, val ? fabs(val/2) : .1);
       fParamNames.push_back(v->ShortName());
       fPreFitValues.push_back(val);
       fPreFitErrors.push_back(val ? val/2 : .1);
     }
     // One way this can go wrong is if two variables have the same ShortName
     assert(mnMin->NFree() == fVars.size());
     for(const ISyst*s: fSysts){
       const double val = systSeed.GetShift(s);
       // name, value, error
       mnMin->SetVariable(mnMin->NFree(), s->ShortName(), val, 1);
       fParamNames.push_back(s->ShortName());
       fPreFitValues.push_back(val);
       fPreFitErrors.push_back(1);
     }
     // One way this can go wrong is if two variables have the same ShortName
     assert(mnMin->NFree() == fVars.size()+fSysts.size());
 
     mnMin->SetFunction(*this);
 
     if(verb == Verbosity::kQuiet) mnMin->SetPrintLevel(0);
 
     if(!mnMin->Minimize()){
       std::cout << "*** ERROR: minimum is not valid ***" << std::endl;
       std::cout << "*** Precision: " << mnMin->Precision() << std::endl;
 
       std::cout << "-- Stopped at: \n";
       for(uint i = 0; i < mnMin->NFree(); ++i){
         std::cout << "\t" << mnMin->VariableName(i) << " = " << mnMin->X()[i] << "\n";
       }
     }
 
     if (fPrec & kIncludeHesse){
       std::cout << "It's Hesse o'clock" << std::endl;
       mnMin->Hesse();
     }
 
     if (fPrec & kIncludeMinos){
       std::cout << "It's minos time" << std::endl;
       fTempMinosErrors.clear();
       for (uint i = 0; i < mnMin->NDim(); ++i){
         double errLow = 0, errHigh = 0;
         mnMin->GetMinosError(i, errLow, errHigh);
         std::cout << i << "/" << mnMin->NDim() << " " << fParamNames[i] << ": " << errLow << ", +" << errHigh << " (" << mnMin->Errors()[i] << ")" << std::endl;
         fTempMinosErrors.push_back(std::make_pair(errLow,errHigh));
       }      
     }
 
     return mnMin;
   }

TMatrixDSym* ana::Fitter::GetCovariance ( )

inline

Return the fit covariance.

Definition at line 100 of file Fit.h.

100 { return this->fCovar;}

ana::Fitter::fCovar

TMatrixDSym * fCovar

Definition: Fit.h:186

int ana::Fitter::GetCovarianceStatus ( )

inline

covariance matrix status (0 = not valid, 1 approximate, 2, full but made pos def, 3 accurate and not pos def)

Definition at line 103 of file Fit.h.

103 {return this->fCovarStatus;}

ana::Fitter::fCovarStatus

bool fCovarStatus

Definition: Fit.h:187

double ana::Fitter::GetEDM ( )

inline

Return edm form the fit.

Definition at line 127 of file Fit.h.

127 {return this->fEdm;}

ana::Fitter::fEdm

double fEdm

Definition: Fit.h:184

bool ana::Fitter::GetIsValid ( )

inline

Say whether the fit was good.

Definition at line 130 of file Fit.h.

130 {return this->fIsValid;}

ana::Fitter::fIsValid

bool fIsValid

Definition: Fit.h:185

std::vector<std::pair<double,double> > ana::Fitter::GetMinosErrors ( )

inline

Return the minos errors.

Definition at line 121 of file Fit.h.

121 { return this->fMinosErrors;}

ana::Fitter::fMinosErrors

std::vector< std::pair< double, double > > fMinosErrors

Definition: Fit.h:193

int ana::Fitter::GetNFCN ( )

inline

Return number of function calls.

Definition at line 124 of file Fit.h.

124 {return this->fNEval;}

ana::Fitter::fNEval

int fNEval

Definition: Fit.h:179

std::vector<std::string> ana::Fitter::GetParamNames ( )

inline

Return the fit names.

Definition at line 106 of file Fit.h.

106 { return this->fParamNames;}

ana::Fitter::fParamNames

std::vector< std::string > fParamNames

Definition: Fit.h:188

std::vector<double> ana::Fitter::GetPostFitErrors ( )

inline

Return the postfit errors.

Definition at line 118 of file Fit.h.

118 { return this->fPostFitErrors;}

ana::Fitter::fPostFitErrors

std::vector< double > fPostFitErrors

Definition: Fit.h:192

std::vector<double> ana::Fitter::GetPostFitValues ( )

inline

Return the postfit values.

Definition at line 115 of file Fit.h.

115 { return this->fPostFitValues;}

ana::Fitter::fPostFitValues

std::vector< double > fPostFitValues

Definition: Fit.h:191

std::vector<double> ana::Fitter::GetPreFitErrors ( )

inline

Return the prefit errors.

Definition at line 112 of file Fit.h.

112 { return this->fPreFitErrors;}

ana::Fitter::fPreFitErrors

std::vector< double > fPreFitErrors

Definition: Fit.h:190

std::vector<double> ana::Fitter::GetPreFitValues ( )

inline

Return the prefit values.

Definition at line 109 of file Fit.h.

109 { return this->fPreFitValues;}

ana::Fitter::fPreFitValues

std::vector< double > fPreFitValues

Definition: Fit.h:189

SystShifts ana::Fitter::GetSystShifts ( ) const

inline

Definition at line 132 of file Fit.h.

132 {return fShifts;}

ana::Fitter::fShifts

SystShifts fShifts

Definition: Fit.h:177

virtual unsigned int ana::Fitter::NDim ( ) const

inlineoverridevirtual

Definition at line 138 of file Fit.h.

138 {return fVars.size()+fSysts.size();}

ana::Fitter::fVars

std::vector< const IFitVar * > fVars

Definition: Fit.h:173

ana::Fitter::fSysts

std::vector< const ISyst * > fSysts

Definition: Fit.h:174

void ana::Fitter::SetPrecision ( Precision prec )

Definition at line 270 of file Fit.cxx.

   {
     fPrec = prec;
   }

Member Data Documentation

osc::IOscCalcAdjustable* ana::Fitter::fCalc

mutableprotected

Definition at line 176 of file Fit.h.

TMatrixDSym* ana::Fitter::fCovar

mutableprotected

Definition at line 186 of file Fit.h.

bool ana::Fitter::fCovarStatus

mutableprotected

Definition at line 187 of file Fit.h.

double ana::Fitter::fEdm = -1

mutableprotected

Definition at line 184 of file Fit.h.

const IExperiment* ana::Fitter::fExpt

protected

Definition at line 172 of file Fit.h.

bool ana::Fitter::fIsValid = false

mutableprotected

Definition at line 185 of file Fit.h.

std::vector<std::pair<double, double> > ana::Fitter::fMinosErrors

mutableprotected

Definition at line 193 of file Fit.h.

int ana::Fitter::fNEval = 0

mutableprotected

Definition at line 179 of file Fit.h.

int ana::Fitter::fNEvalFiniteDiff = 0

mutableprotected

Definition at line 181 of file Fit.h.

int ana::Fitter::fNEvalGrad = 0

mutableprotected

Definition at line 180 of file Fit.h.

std::vector<std::string> ana::Fitter::fParamNames

mutableprotected

Definition at line 188 of file Fit.h.

std::vector<double> ana::Fitter::fPostFitErrors

mutableprotected

Definition at line 192 of file Fit.h.

std::vector<double> ana::Fitter::fPostFitValues

mutableprotected

Definition at line 191 of file Fit.h.

Precision ana::Fitter::fPrec = kNormal

protected

Definition at line 175 of file Fit.h.

std::vector<double> ana::Fitter::fPreFitErrors

mutableprotected

Definition at line 190 of file Fit.h.

std::vector<double> ana::Fitter::fPreFitValues

mutableprotected

Definition at line 189 of file Fit.h.

SystShifts ana::Fitter::fShifts

mutableprotected

Definition at line 177 of file Fit.h.

std::vector<const ISyst*> ana::Fitter::fSysts

protected

Definition at line 174 of file Fit.h.

std::vector<std::pair<double, double> > ana::Fitter::fTempMinosErrors

mutableprotected

Definition at line 194 of file Fit.h.

std::vector<const IFitVar*> ana::Fitter::fVars

protected

Definition at line 173 of file Fit.h.

The documentation for this class was generated from the following files:

Classes

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation