Analysis::CalibrationDataHistogramContainer Class Reference

#include <CalibrationDataContainer.h>

Inheritance diagram for Analysis::CalibrationDataHistogramContainer:

Collaboration diagram for Analysis::CalibrationDataHistogramContainer:

Public Types
enum	CalibrationParametrization { kPt = 0, kEta = 1, kAbsEta = 2, kTagWeight = 3 }

Public Member Functions
	CalibrationDataHistogramContainer (const char *name="default")
virtual	~CalibrationDataHistogramContainer ()
virtual CalibrationStatus	getResult (const CalibrationDataVariables &x, double &result, TObject *obj=0, bool extrapolate=false)
	retrieve the calibration result. More...
virtual CalibrationStatus	getStatUncertainty (const CalibrationDataVariables &x, double &result)
	retrieve the calibration statistical uncertainty. More...
virtual CalibrationStatus	getUncertainty (const std::string &unc, const CalibrationDataVariables &x, UncertaintyResult &result, TObject *obj=0)
	retrieve the calibration uncertainty due to the given source. More...
bool	isBinCorrelated (const std::string &unc) const
	Indicate whether the given uncertainty is correlated from bin to bin or not (note that this function is to be used only for systematic uncertainties) More...
void	setUncorrelated (const std::string &unc)
	Indicate that the given uncertainty is to be treated uncorrelated from bin to bin (note that the default is for all systematic uncertainties to be treated as correlated) More...
void	setInterpolated (bool doInterpolate)
	Indicate whether results are to be interpolated between bins or not (this feature is thought to be useful mostly for MC efficiencies) More...
virtual bool	isInterpolated () const
	Indicate whether histogram interpolation is used or not. More...
virtual int	getTagWeightAxis ()
	Test whether this calibration object is one for "continuous" calibration (this has some subtle consequences for the treatment of bin-to-bin correlations). More...
virtual std::vector< double >	getBinBoundaries (unsigned int vartype)
	Retrieve the bin boundaries for the specified variable type (which should be a CalibrationParametrization enum). More...
virtual int	getEigenvectorReduction (unsigned int choice) const
	Retrieve the number of eigenvectors to be retained for the purpose of eigenvector variation reduction strategies. More...
std::vector< std::string >	listUncertainties () const
	retrieve the list of "uncertainties" accessible to this object. More...
CalibrationStatus	getUncertainties (const CalibrationDataVariables &x, std::map< std::string, Analysis::UncertaintyResult > &all)
	retrieve the list of "uncertainties" accessible to this object. More...
std::string	getComment () const
	retrieve the comments entered for this calibration, if any More...
std::string	getHadronisation () const
	retrieve the 'hadronisation reference' entered for this calibration, if any More...
std::string	getExcludedUncertainties () const
	retrieve the (semicolon-separated) set of uncertainties that are recommended for removal from the eigenvector decomposition More...
CalibrationStatus	getSystUncertainty (const CalibrationDataVariables &x, UncertaintyResult &result, TObject *obj=0)
	retrieve the calibration total systematic uncertainty More...
void	setResult (TObject *obj)
	insert the main object for this calibration More...
void	setComment (const std::string &text)
	insert the given text as comment for this calibration More...
void	setHadronisation (const std::string &text)
	insert the given text as the 'hadronisation reference' for this calibration More...
void	setExcludedUncertainties (const std::string &text)
	insert the set of uncertainties that are recommended for removal from the eigenvector decomposition. More...
void	setUncertainty (const std::string &unc, TObject *obj)
	insert the relevant object for the requested source of 'uncertainty' More...
void	restrictToRange (bool restrict)
	If true, this will restrict the variables used to be within the (specified) range of validity. More...
bool	isRangeRestricted () const
	allow the user to inspect the above information More...
double	getLowerBound (unsigned int vartype, bool extrapolate=false) const
	retrieve the lower bound of validity for the requested variable type More...
double	getUpperBound (unsigned int vartype, bool extrapolate=false) const
	retrieve the upper bound of validity for the requested variable type More...
std::vector< std::pair< double, double > >	getBounds ()
	allow the user to inspect the bounds of validity More...
std::vector< unsigned int >	getVariableTypes ()
	utility to retrieve variable types More...

Static Public Member Functions
static bool	isNearlyEqual (double a, double b)
	utility for comparison of doubles More...

Protected Member Functions
int	typeFromString (const std::string &key) const
	Connection between variable names (on histogram axes etc.) and variable 'types' as used in actual evaluations. More...
CalibrationStatus	computeVariables (const CalibrationDataVariables &x, bool extrapolate=false)
	Compute the variables to be used. More...

Protected Attributes
std::map< unsigned int, std::vector< double > >	m_binBoundaries
	Cache for bin boundary information. More...
std::vector< double >	m_lowerBounds
std::vector< double >	m_upperBounds
std::vector< double >	m_lowerBoundsExtrapolated
std::vector< double >	m_upperBoundsExtrapolated
	(possibly looser) lower validity bounds for extrapolation More...
TObject *	m_objResult
	(possibly looser) upper validity bounds for extrapolation More...
TObject *	m_objSystematics
	don't persistify More...
double	m_vars [MaxCalibrationVars]
	don't persistify More...
std::vector< unsigned int >	m_variables
	don't persistify More...

Private Member Functions
double	getInterpolatedResult (TH1 *hist) const
	Retrieve interpolated result (utility function) More...
double	getInterpolatedUncertainty (TH1 *hist) const
	Retrieve interpolated result (utility function) More...
void	checkBounds ()
	check the bounds of validity for this calibration object More...
virtual void	computeVariableTypes ()
	decode the 'uncertainty' objects' names to determine the relevant variable types More...
	ClassDef (CalibrationDataHistogramContainer, 2)

Private Attributes
THashList	m_uncorrelatedSyst
	no need to persistify More...
bool	m_interpolate
	If true, interpolate between bins rather than doing a straight bin-wise evaluation. More...
bool	m_restrict
	persistency not needed for this variable More...

Detailed Description

This is the class holding information for histogram-based calibration results.

Definition at line 247 of file CalibrationDataContainer.h.

Member Enumeration Documentation

CalibrationParametrization

enum Analysis::CalibrationDataContainer::CalibrationParametrization

inherited

The following enums are intended to contain the list of (kinematic or other) variables in terms of which results (and the corresponding uncertainties) are given. They are useful mainly for internal purposes, but the user may access them nevertheless.

Enumerator
kPt
kEta
kAbsEta
kTagWeight

Definition at line 63 of file CalibrationDataContainer.h.

                                    {
      kPt = 0,       // calibrated jet pt
      kEta = 1,      // jet eta
      kAbsEta = 2,   // jet |eta|
      kTagWeight = 3 // tagging output (relevant for "continuous" calibration)
    };

Constructor & Destructor Documentation

CalibrationDataHistogramContainer()

Analysis::CalibrationDataHistogramContainer::CalibrationDataHistogramContainer

(

const char *

name = "default"

)

~CalibrationDataHistogramContainer()

CalibrationDataHistogramContainer::~CalibrationDataHistogramContainer ( )

virtual

Definition at line 483 of file CalibrationDataContainer.cxx.

{
}

Member Function Documentation

checkBounds()

void CalibrationDataHistogramContainer::checkBounds ( )

private

check the bounds of validity for this calibration object

Definition at line 673 of file CalibrationDataContainer.cxx.

{
  // Determine the bounds of validity for this calibration object. If an "extrapolation"
  // uncertainty histogram exists, it is used to determine the (typically) looser bounds
  // of validity appropriate for extrapolation uncertainties.
 
  const TH1* hist = dynamic_cast<const TH1*>(m_objResult);
  if (!hist) {
    std::cerr << "in CalibrationDataHistogramContainer::checkBounds(): object type does not derive from TH1" << std::endl;
    return;
  } else if (hist->GetDimension() != int(m_variables.size())) {
    std::cerr << "in CalibrationDataHistogramContainer::checkBounds(): given number of variable types ("
          << m_variables.size() << ") doesn't match histogram dimension ("
          << hist->GetDimension() << ")!" << std::endl;
    return;
  }
  // if an extrapolation uncertainty histogram was provided, use this to determine a second set of validity bounds
  const TH1* hExtrapolate = dynamic_cast<const TH1*>(GetValue("extrapolation"));
  for (unsigned int t = 0; int(t) < hist->GetDimension(); ++t) {
    const TAxis* axis; const TAxis* axis2 = 0;
    switch (t) {
    case 0: axis = hist->GetXaxis(); if (hExtrapolate) axis2 = hExtrapolate->GetXaxis(); break;
    case 1: axis = hist->GetYaxis(); if (hExtrapolate) axis2 = hExtrapolate->GetYaxis(); break;
    default: axis = hist->GetZaxis(); if (hExtrapolate) axis2 = hExtrapolate->GetZaxis();
    }
    
    // for (unsigned int t = 0; t < m_variables.size(); ++t) {
    //   if (m_variables[t] > m_upperBounds.size()) {
    //  std::cerr << "in CalibrationDataHistogramContainer::checkBounds(): variable " << t << "type ("
    //        << m_variables[t] << "exceeds maximum type number (" << m_upperBounds.size() << ")!"
    //        << std::endl;
    //  return;
    //   }
    // }
    m_upperBounds[m_variables[t]] = axis->GetXmax();
    m_lowerBounds[m_variables[t]] = axis->GetXmin();
    m_upperBoundsExtrapolated[m_variables[t]] = (axis2) ? axis2->GetXmax() : m_upperBounds[m_variables[t]];
    m_lowerBoundsExtrapolated[m_variables[t]] = (axis2) ? axis2->GetXmin() : m_lowerBounds[m_variables[t]];
    // std::cout << "debug: min = " << m_lowerBounds[m_variables[t]] << ", max = " << m_upperBounds[m_variables[t]]
    //        << ", extrap min = " << m_lowerBoundsExtrapolated[m_variables[t]] << ", extrap max = "
    //        << m_upperBoundsExtrapolated[m_variables[t]] << std::endl;
  }
}

ClassDef()

Analysis::CalibrationDataHistogramContainer::ClassDef ( CalibrationDataHistogramContainer  , 2    )

private

computeVariables()

CalibrationStatus CalibrationDataContainer::computeVariables ( const CalibrationDataVariables &  x, bool  extrapolate = false  )

protectedinherited

Compute the variables to be used.

Parameters

x	user-supplied (kinematic or other) variables
extrapolate	set to "true" for the evaluation of extrapolation uncertainties

Returns

kSuccess, kRange, or kExtrapolatedRange, depending on the kinematic variables

Definition at line 307 of file CalibrationDataContainer.cxx.

{
  // Determine which variables are to be used, and insert them in a separate array (which is only used internally).
  // The return value is used to indicate whether any input co-ordinate was out of bounds; where a distinction
  // is made between being outside the extrapolation region (kExtrapolatedRange) or merely the calibration region
  // (kRange).
  // The "extrapolate" variable is used to flag whether an extrapolation uncertainty applies
  // (this should anyway occur only for histogram containers).
  // This is also the place where any computations are being done (e.g. jet pt values are divided by 1000
  // to convert them from MeV to GeV).
 
  // ensure that the variable types have been computed properly
  if (m_variables.size() == 0) computeVariableTypes();
 
  // also keep track of whether the variables are within bounds
  CalibrationStatus status(kSuccess);
 
  // std::cout << "computeVariables(): input jet pt: " << x.jetPt << ", eta " << x.jetEta << ", tag weight " << x.jetTagWeight << std::endl;
 
  for (unsigned int var = 0; var < m_variables.size(); ++var) {
    switch (m_variables[var]) {
    case kPt:
      // assume that the input values are given in MeV but the performance calibration in GeV!
      m_vars[var] = x.jetPt * 0.001;
      break;
    case kEta:
      m_vars[var] = x.jetEta;
      break;
    case kAbsEta:
      m_vars[var] = x.jetEta;
      if (m_vars[var] < 0) m_vars[var] *= -1.0;
      break;
    case kTagWeight:
      m_vars[var] = x.jetTagWeight;
    }
    if (m_vars[var] < getLowerBound(m_variables[var], extrapolate)) {
      if (status != kExtrapolatedRange) {
    status  = (extrapolate || (m_vars[var] < getLowerBound(m_variables[var], true))) ? kExtrapolatedRange : kRange;
    // std::cout << "computeVariables(): variable " << var << ", value: " << m_vars[var] << ", setting status to " << status << std::endl;
      }
      if (m_restrict) m_vars[var] = getLowerBound(m_variables[var], extrapolate) + rangeEpsilon;
    } else if (m_vars[var] >= getUpperBound(m_variables[var], extrapolate)) {
      if (status != kExtrapolatedRange) {
    status  = (extrapolate || (m_vars[var] >= getUpperBound(m_variables[var], true))) ? kExtrapolatedRange : kRange;
    // std::cout << "computeVariables(): variable " << var << ", value: " << m_vars[var] << ", extrapolate? " << extrapolate
    //        << ", upper bound: " << getUpperBound(m_variables[var],extrapolate)
    //    << " (extrapolation bound: " << getUpperBound(m_variables[var],true) << "), setting status to " << status << std::endl;
      }
      if (m_restrict) m_vars[var] = getUpperBound(m_variables[var], extrapolate) - rangeEpsilon;
    }
  }
 
  // std::cout << "computeVariables(): output variables: " << m_vars[0] << ", " << m_vars[1] << ", " << m_vars[2] << std::endl;
 
  return status;
}

computeVariableTypes()

void CalibrationDataHistogramContainer::computeVariableTypes ( )

privatevirtual

decode the 'uncertainty' objects' names to determine the relevant variable types

Implements Analysis::CalibrationDataContainer.

Reimplemented in Analysis::CalibrationDataMappedHistogramContainer.

Definition at line 490 of file CalibrationDataContainer.cxx.

{
  // Compute the variable types for this container object, using the histogram axis labels.
  // Valid axis labels can be found in the CalibrationDataContainer::typeFromString() method.
  // Note that only the "result" histogram is inspected; it is assumed that all
  // histograms provided use the same binning (a small exception is the "extrapolation"
  // uncertainty histogram, which may have additional bins beyond the usual validity bounds).
  //
  // This function will be called upon first usage, and its results cached internally.
  // It also calls checkBounds() to determine the validity bounds.
 
  // cache pointer to central values histogram
  if (! m_objResult) m_objResult = GetValue("result");
 
  // histograms need a special treatment, as the coordinate titles are not actually stored
  // with the title itself, but instead moved off to the axis titles...
  const TH1* hobj = dynamic_cast<const TH1*>(m_objResult);
  if (not hobj){
    std::cerr << "in CalibrationDataHistogramContainer::computeVariableTypes(): dynamic_cast failed\n";
    return;
  }
 
  int dims = hobj->GetDimension();
  for (int dim = 0; dim < dims; ++dim) {
    const TAxis* axis = 0;
    switch (dim) {
    case 0: axis = hobj->GetXaxis(); break;
    case 1: axis = hobj->GetYaxis(); break;
    default: axis = hobj->GetZaxis();
    }
    int vartype = typeFromString(axis->GetTitle());
    if (vartype < 0) {
      // Only flag the issue but otherwise take no action (assume non-argument use of a semicolon)
      std::cerr << "in CalibrationDataHistogramContainer::computeVariableTypes(): cannot construct variable type from name "
        << axis->GetTitle() << std::endl;
    } else {
      m_variables.push_back((unsigned int) vartype);
    }
  }
 
  // After doing this, we should always have a non-null vector!
  assert(m_variables.size() > 0);
 
  // also compute the validity bounds for this calibration object
  const_cast<CalibrationDataHistogramContainer*>(this)->checkBounds();
}

getBinBoundaries()

std::vector< double > CalibrationDataHistogramContainer::getBinBoundaries ( unsigned int  vartype )

virtual

Retrieve the bin boundaries for the specified variable type (which should be a CalibrationParametrization enum).

An empty vector will be returned if the specified variable is not actually used.

Reimplemented in Analysis::CalibrationDataMappedHistogramContainer.

Definition at line 952 of file CalibrationDataContainer.cxx.

{
  // Retrieve the bin boundaries for the specified variable type (which should be a CalibrationParametrization enum).
  // An empty vector will be returned if the specified variable is not actually used.
 
  // Ensure that the variable types have been computed at this point
  if (m_variables.size() == 0) computeVariableTypes();
 
  // Check whether the variable type is actually being used
  std::vector<double> boundaries;
  if (std::find(m_variables.begin(), m_variables.end(), vartype) == m_variables.end()) return boundaries;
 
  // use cached information if available
  std::map<unsigned int, std::vector<double> >::iterator it = m_binBoundaries.find(vartype);
  if (it != m_binBoundaries.end()) return it->second;
 
  // Retrieve the appropriate histogram axis
  if (! m_objResult) m_objResult = GetValue("result");
  const TH1* hobj = dynamic_cast<const TH1*>(m_objResult);
  const TAxis* axis = 0;
  if (m_variables[0] == vartype) axis = hobj->GetXaxis();
  else if (m_variables[1] == vartype) axis = hobj->GetYaxis();
  else axis = hobj->GetZaxis();
 
  // Retrieve the actual bin boundaries
  const TArrayD* bins = axis->GetXbins(); int nb = bins->GetSize();
  for (int b = 0; b < nb; ++b) boundaries.push_back(bins->At(b));
 
  m_binBoundaries[vartype] = boundaries;
  return boundaries;
}

getBounds()

std::vector< std::pair< double, double > > CalibrationDataContainer::getBounds ( )

inherited

allow the user to inspect the bounds of validity

Definition at line 391 of file CalibrationDataContainer.cxx.

{
  // List the validity bounds relevant to this container.
 
  // ensure that the variable types have been computed properly
  if (m_variables.size() == 0) computeVariableTypes();
 
  std::vector<std::pair<double, double> > bounds;
  for (unsigned int t = 0; t < m_lowerBounds.size() && t <= kAbsEta; ++t) {
    bounds.push_back(std::make_pair(m_lowerBounds[t], m_upperBounds[t]));
  }
  return bounds;
}

getComment()

std::string CalibrationDataContainer::getComment ( ) const

inherited

retrieve the comments entered for this calibration, if any

Definition at line 190 of file CalibrationDataContainer.cxx.

{
  // Retrieve the comments for this calibration (if any)
 
  TObject* obj = GetValue("comment");
  if (! obj) return std::string("");
  TObjString* s = dynamic_cast<TObjString*>(obj);
  if (! s ) return std::string("");
  return std::string(s->GetName());
}

getEigenvectorReduction()

int CalibrationDataHistogramContainer::getEigenvectorReduction ( unsigned int  choice ) const

virtual

Retrieve the number of eigenvectors to be retained for the purpose of eigenvector variation reduction strategies.

Parameters

choice

specification of the reduction option (integer corresponding to the CalibrationDataInterfaceROOT::EVReductionStrategy enum)

Returns

number of eigenvector variations to be retained; -1 if the required information is lacking

Definition at line 986 of file CalibrationDataContainer.cxx.

{
  TObject* obj = GetValue("ReducedSets");
  if (! obj) return -1;
  TVectorT<double>* v = dynamic_cast<TVectorT<double>* >(obj);
  if (! (v && v->GetNoElements() > int(choice)) ) return -1;
  return int((*v)[choice]);
}

getExcludedUncertainties()

std::string CalibrationDataContainer::getExcludedUncertainties ( ) const

inherited

retrieve the (semicolon-separated) set of uncertainties that are recommended for removal from the eigenvector decomposition

Definition at line 217 of file CalibrationDataContainer.cxx.

{
  // Retrieve the (semicolon-separated) set of uncertainties that are recommended for removal from the eigenvector decomposition (if any)
  const static std::string null("");
 
  TObject* obj = GetValue("excluded_set");
  if (! obj) return null;
  TObjString* s = dynamic_cast<TObjString*>(obj);
  if (! s ) return null;
  return std::string(s->GetName());
}

getHadronisation()

std::string CalibrationDataContainer::getHadronisation ( ) const

inherited

retrieve the 'hadronisation reference' entered for this calibration, if any

Definition at line 203 of file CalibrationDataContainer.cxx.

{
  // Retrieve the hadronisation reference for this calibration (if any)
  const static std::string null("");
 
  TObject* obj = GetValue("MChadronisation");
  if (! obj) return null;
  TObjString* s = dynamic_cast<TObjString*>(obj);
  if (! s ) return null;
  return std::string(s->GetName());
}

getInterpolatedResult()

double CalibrationDataHistogramContainer::getInterpolatedResult ( TH1 *  hist ) const

private

Retrieve interpolated result (utility function)

Definition at line 760 of file CalibrationDataContainer.cxx.

{
  // Small utility function (intended for internal use only) for the retrieval of interpolated results
 
  switch (hist->GetDimension()) {
  case 3:
    return hist->Interpolate(m_vars[0], m_vars[1], m_vars[2]);
  case 2:
    return hist->Interpolate(m_vars[0], m_vars[1]);
  case 1:
  default:
    return hist->Interpolate(m_vars[0]);
  }
}

getInterpolatedUncertainty()

double CalibrationDataHistogramContainer::getInterpolatedUncertainty ( TH1 *  hist ) const

private

Retrieve interpolated result (utility function)

Definition at line 777 of file CalibrationDataContainer.cxx.

{
  TAxis* xAxis = hist->GetXaxis();
  TAxis* yAxis = 0; TAxis* zAxis = 0;
  Double_t x0,x1,y0,y1;
 
  Int_t ndim = hist->GetDimension();
  if (ndim == 1) {
    // Code copied from TH1::Interpolate()
 
    Int_t xbin = hist->FindBin(m_vars[0]);
 
    if(m_vars[0] <= hist->GetBinCenter(1)) {
      return hist->GetBinError(1);
    } else if(m_vars[0] >= hist->GetBinCenter(hist->GetNbinsX())) {
      return hist->GetBinError(hist->GetNbinsX());
    }
 
    if(m_vars[0] <= hist->GetBinCenter(xbin)) {
      y0 = hist->GetBinError(xbin-1);
      x0 = hist->GetBinCenter(xbin-1);
      y1 = hist->GetBinError(xbin);
      x1 = hist->GetBinCenter(xbin);
    } else {
      y0 = hist->GetBinError(xbin);
      x0 = hist->GetBinCenter(xbin);
      y1 = hist->GetBinError(xbin+1);
      x1 = hist->GetBinCenter(xbin+1);
    }
    return y0 + (m_vars[0]-x0)*((y1-y0)/(x1-x0));
 
  } else if (ndim == 2) {
 
    // Code copied from TH2::Interpolate()
 
    Double_t f=0;
    x1 = y1 = 0;
    Double_t x2=0,y2=0;
    Double_t dx,dy;
    yAxis = hist->GetYaxis();
    Int_t bin_x = xAxis->FindBin(m_vars[0]);
    Int_t bin_y = yAxis->FindBin(m_vars[1]);
    if (bin_x<1 || bin_x>hist->GetNbinsX() || bin_y<1 || bin_y>hist->GetNbinsY()) {
      Error("Interpolate","Cannot interpolate outside histogram domain.");
      return 0;
    }
    // Int_t quadrant = 0; // CCW from UR 1,2,3,4
    // which quadrant of the bin (bin_P) are we in?
    dx = xAxis->GetBinUpEdge(bin_x)-m_vars[0];
    dy = yAxis->GetBinUpEdge(bin_y)-m_vars[1];
    if (dx<=xAxis->GetBinWidth(bin_x)/2 && dy<=yAxis->GetBinWidth(bin_y)/2) {
      // quadrant = 1; // upper right
      x1 = xAxis->GetBinCenter(bin_x);
      y1 = yAxis->GetBinCenter(bin_y);
      x2 = xAxis->GetBinCenter(bin_x+1);
      y2 = yAxis->GetBinCenter(bin_y+1);
    } else if (dx>xAxis->GetBinWidth(bin_x)/2 && dy<=yAxis->GetBinWidth(bin_y)/2) {
      // quadrant = 2; // upper left
      x1 = xAxis->GetBinCenter(bin_x-1);
      y1 = yAxis->GetBinCenter(bin_y);
      x2 = xAxis->GetBinCenter(bin_x);
      y2 = yAxis->GetBinCenter(bin_y+1);
    } else if (dx>xAxis->GetBinWidth(bin_x)/2 && dy>yAxis->GetBinWidth(bin_y)/2) {
      // quadrant = 3; // lower left
      x1 = xAxis->GetBinCenter(bin_x-1);
      y1 = yAxis->GetBinCenter(bin_y-1);
      x2 = xAxis->GetBinCenter(bin_x);
      y2 = yAxis->GetBinCenter(bin_y);
    } else {
      // quadrant = 4; // lower right
      x1 = xAxis->GetBinCenter(bin_x);
      y1 = yAxis->GetBinCenter(bin_y-1);
      x2 = xAxis->GetBinCenter(bin_x+1);
      y2 = yAxis->GetBinCenter(bin_y);
    }
    Int_t bin_x1 = xAxis->FindBin(x1);
    if(bin_x1<1) bin_x1=1;
    Int_t bin_x2 = xAxis->FindBin(x2);
    if(bin_x2>hist->GetNbinsX()) bin_x2=hist->GetNbinsX();
    Int_t bin_y1 = yAxis->FindBin(y1);
    if(bin_y1<1) bin_y1=1;
    Int_t bin_y2 = yAxis->FindBin(y2);
    if(bin_y2>hist->GetNbinsY()) bin_y2=hist->GetNbinsY();
    Int_t bin_q22 = hist->GetBin(bin_x2,bin_y2);
    Int_t bin_q12 = hist->GetBin(bin_x1,bin_y2);
    Int_t bin_q11 = hist->GetBin(bin_x1,bin_y1);
    Int_t bin_q21 = hist->GetBin(bin_x2,bin_y1);
    Double_t q11 = hist->GetBinError(bin_q11);
    Double_t q12 = hist->GetBinError(bin_q12);
    Double_t q21 = hist->GetBinError(bin_q21);
    Double_t q22 = hist->GetBinError(bin_q22);
    Double_t d = 1.0*(x2-x1)*(y2-y1);
    f = 1.0*q11/d*(x2-m_vars[0])*(y2-m_vars[1])
      + 1.0*q21/d*(m_vars[0]-x1)*(y2-m_vars[1])
      + 1.0*q12/d*(x2-m_vars[0])*(m_vars[1]-y1)
      + 1.0*q22/d*(m_vars[0]-x1)*(m_vars[1]-y1);
    return f;
 
  } else {
 
    // Copied from TH3::Interpolate()
 
    yAxis = hist->GetYaxis();
    zAxis = hist->GetZaxis();
 
    Int_t ubx = xAxis->FindBin(m_vars[0]);
    if ( m_vars[0] < xAxis->GetBinCenter(ubx) ) ubx -= 1;
    Int_t obx = ubx + 1;
 
    Int_t uby = yAxis->FindBin(m_vars[1]);
    if ( m_vars[1] < yAxis->GetBinCenter(uby) ) uby -= 1;
    Int_t oby = uby + 1;
 
    Int_t ubz = zAxis->FindBin(m_vars[2]);
    if ( m_vars[2] < zAxis->GetBinCenter(ubz) ) ubz -= 1;
    Int_t obz = ubz + 1;
 
 
    //    if ( IsBinUnderflow(GetBin(ubx, uby, ubz)) ||
    //         IsBinOverflow (GetBin(obx, oby, obz)) ) {
    if (ubx <=0 || uby <=0 || ubz <= 0 ||
    obx > xAxis->GetNbins() || oby > yAxis->GetNbins() || obz > zAxis->GetNbins() ) {
    }
 
    Double_t xw = xAxis->GetBinCenter(obx) - xAxis->GetBinCenter(ubx);
    Double_t yw = yAxis->GetBinCenter(oby) - yAxis->GetBinCenter(uby);
    Double_t zw = zAxis->GetBinCenter(obz) - zAxis->GetBinCenter(ubz);
 
    Double_t xd = (m_vars[0] - xAxis->GetBinCenter(ubx)) / xw;
    Double_t yd = (m_vars[1] - yAxis->GetBinCenter(uby)) / yw;
    Double_t zd = (m_vars[2] - zAxis->GetBinCenter(ubz)) / zw;
 
 
    Double_t v[] = { hist->GetBinError( ubx, uby, ubz ), hist->GetBinError( ubx, uby, obz ),
             hist->GetBinError( ubx, oby, ubz ), hist->GetBinError( ubx, oby, obz ),
             hist->GetBinError( obx, uby, ubz ), hist->GetBinError( obx, uby, obz ),
             hist->GetBinError( obx, oby, ubz ), hist->GetBinError( obx, oby, obz ) };
 
 
    Double_t i1 = v[0] * (1 - zd) + v[1] * zd;
    Double_t i2 = v[2] * (1 - zd) + v[3] * zd;
    Double_t j1 = v[4] * (1 - zd) + v[5] * zd;
    Double_t j2 = v[6] * (1 - zd) + v[7] * zd;
 
 
    Double_t w1 = i1 * (1 - yd) + i2 * yd;
    Double_t w2 = j1 * (1 - yd) + j2 * yd;
 
 
    Double_t result = w1 * (1 - xd) + w2 * xd;
 
   return result;
  };
}

getLowerBound()

double CalibrationDataContainer::getLowerBound ( unsigned int  vartype, bool  extrapolate = false  ) const

inherited

retrieve the lower bound of validity for the requested variable type

Parameters

vartype	variable type
extrapolate	true only if an extrapolation uncertainty is requested

Definition at line 366 of file CalibrationDataContainer.cxx.

{
  // Utility function returning the lower validity bound for the given variable type.
  // The "extrapolate" variable flags whether normal validity bounds are to be used,
  // or instead those relevant for the extrapolation uncertainty.
 
  double minDefault = (vartype == kAbsEta || vartype == kPt) ? 0 : -std::numeric_limits<double>::max();
  if (! (vartype < m_lowerBounds.size())) return minDefault;
  return extrapolate ? m_lowerBoundsExtrapolated[vartype] : m_lowerBounds[vartype];
}

getResult()

CalibrationStatus CalibrationDataHistogramContainer::getResult ( const CalibrationDataVariables &  x, double &  result, TObject *  obj = 0, bool  extrapolate = false  )

virtual

retrieve the calibration result.

Parameters

x	user-supplied (kinematic or other) variables
result	requested result
obj	object holding the requested result (it will be computed if not provided)
extrapolate	flag that extrapolation applies (should only be relevant when using eigenvector variations)

Returns

status code (see above)

Implements Analysis::CalibrationDataContainer.

Reimplemented in Analysis::CalibrationDataMappedHistogramContainer.

Definition at line 539 of file CalibrationDataContainer.cxx.

{
  // Retrieve the central value for the given input variables. There are cases where
  // it may be useful to provide an alternative histogram rather than the original
  // one; in such cases (notably used with eigenvector variations) it is possible to
  // provide a pointer to this alternative histogram.
  //
  //     x:           input variables
  //     result:      result
  //     obj:         pointer to alternative results histogram
  //     extrapolate: set to true if bounds checking is to be carried out to looser
  //                  validity bounds as relevant for extrapolation uncertainties
  if (!obj) {
    if (! m_objResult) {
      m_objResult = GetValue("result");
    }
    obj = m_objResult;
  }
  TH1* hist = dynamic_cast<TH1*>(obj);
  if (! hist) return Analysis::kError;
 
  // select the relevant kinematic variables
  CalibrationStatus status = computeVariables(x, extrapolate);
  // find the relevant "global" bin.
  // Note the limitation: at most three dimensions are supported.
  // TH1::FindFixBin() will ignore the variables not needed.
  // Note: FindFixBin() is only available in "recent" ROOT versions (FindBin() is appropriate for older versions)
  // (otherwise we need to rely on the ResetBit(TH1::kCanRebin) method having been used)
  if (m_interpolate) {
    result = getInterpolatedResult(hist);
  } else {
    Int_t bin = hist->FindFixBin(m_vars[0], m_vars[1], m_vars[2]);
    result = hist->GetBinContent(bin);
  }
 
  return status;
}

getStatUncertainty()

CalibrationStatus CalibrationDataHistogramContainer::getStatUncertainty ( const CalibrationDataVariables &  x, double &  result  )

virtual

retrieve the calibration statistical uncertainty.

Parameters

x	user-supplied (kinematic or other) variables
result	requested statistical uncertainty

Returns

status code (see above) Note the changed signature compared to getUncertainty(), getResult() etc.: this is because the statistical uncertainty computation always needs the result object, and only in case of the function interface also the covariance matrix

Implements Analysis::CalibrationDataContainer.

Reimplemented in Analysis::CalibrationDataMappedHistogramContainer.

Definition at line 582 of file CalibrationDataContainer.cxx.

{
  // Retrieve the statistical uncertainty for the given input variables.
  //
  //     x:           input variables
  //     result:      result
 
  if (! m_objResult) {
    m_objResult = GetValue("result");
  }
  TH1* hist = dynamic_cast<TH1*>(m_objResult);
  if (! hist) {
    std::cout << " getStatUncertainty error: no (valid) central values object!" << std::endl;
    return Analysis::kError;
  }
 
  // select the relevant kinematic variables
  CalibrationStatus status = computeVariables(x);
  // find the relevant "global" bin.
  // Note the limitation: at most three dimensions are supported.
  // TH1::FindFixBin() will ignore the variables not needed.
  // Note: FindFixBin() is only available in "recent" ROOT versions (FindBin() is appropriate for older versions)
  // (otherwise we need to rely on the ResetBit(TH1::kCanRebin) method having been used)
  if (m_interpolate) {
    // interpolating the uncertainties doesn't seem very sensible..
    result = getInterpolatedUncertainty(hist);
  } else {
    Int_t bin = hist->FindFixBin(m_vars[0], m_vars[1], m_vars[2]);
    // Int_t bin = findBin(hist, false);
    result = hist->GetBinError(bin);
  }
 
  return status;
}

getSystUncertainty()

CalibrationStatus CalibrationDataContainer::getSystUncertainty ( const CalibrationDataVariables &  x, UncertaintyResult &  result, TObject *  obj = 0  )

inherited

retrieve the calibration total systematic uncertainty

See also

getUncertainty()

Definition at line 101 of file CalibrationDataContainer.cxx.

{
  // short-hand for the total systematic uncertainty retrieval.
  // For "normal" usage (retrieval of central values and total uncertainties), the total systematic
  // uncertainty object needs to be accessed frequently. In order to avoid nee
 
  // cache the pointer to the "systematics" object (to avoid string comparisons)
  if (!obj) {
    if (! m_objSystematics) {
      m_objSystematics = GetValue("systematics");
    }
    obj = m_objSystematics;
  }
  return getUncertainty("systematics", x, result, obj);
}

getTagWeightAxis()

int CalibrationDataHistogramContainer::getTagWeightAxis ( )

virtual

Test whether this calibration object is one for "continuous" calibration (this has some subtle consequences for the treatment of bin-to-bin correlations).

The return value will be -1 in case this is not a "continuous" calibration object, and the axis number (0 for X, 1 for Y, 2 for Z) otherwise.

Reimplemented in Analysis::CalibrationDataMappedHistogramContainer.

Definition at line 935 of file CalibrationDataContainer.cxx.

{
  // Test whether this calibration object is one for "continuous" calibration
  // (this has some subtle consequences for the treatment of bin-to-bin correlations).
  // The return value will be -1 in case this is not a "continuous" calibration object,
  // and the axis number (0 for X, 1 for Y, 2 for Z) otherwise.
 
  // Ensure that the variable types have been computed at this point
  if (m_variables.size() == 0) computeVariableTypes();
 
  for (unsigned int type = 0; type < m_variables.size(); ++type)
    if (m_variables[type] == kTagWeight) return int(type);
  return -1;
}

getUncertainties()

CalibrationStatus CalibrationDataContainer::getUncertainties ( const CalibrationDataVariables &  x, std::map< std::string, Analysis::UncertaintyResult > &  all  )

inherited

retrieve the list of "uncertainties" accessible to this object.

A few uncertainty names are predetermined: "result", "comment", "statistics", "systematics". Individual sources of systematic uncertainty can be added by the user.

Definition at line 137 of file CalibrationDataContainer.cxx.

{
  // Retrieve all uncertainties for this calibration.
 
  CalibrationStatus mycode(Analysis::kSuccess);
  UncertaintyResult result;
 
  // first treat the "result" entry separately
  double single_result;
  CalibrationStatus code = getResult(x, single_result);
  if (code == Analysis::kError) {
    std::cerr << "in CalibrationDataContainer::getUncertainties(): error retrieving result!" << std::endl;
    return code;
  }
  else if (code != Analysis::kSuccess) mycode = code;
  result.first = single_result;
  result.second = 0;
  all[std::string("result")] = result;
 
  // similar for the "statistics" entry
  code = getStatUncertainty(x, single_result);
  if (code == Analysis::kError) {
    std::cerr << "in CalibrationDataContainer::getUncertainties(): error retrieving stat. uncertainty!" << std::endl;
    return code;
  }
  else if (code != Analysis::kSuccess) mycode = code;
  result.first  =  single_result;
  result.second = -single_result;
  all[std::string("statistics")] = result;
 
  // then cycle through the other (systematic) uncertainties
  TIter it(GetTable());
  while (TPair* pair = (TPair*) it()) {
    std::string spec(pair->Key()->GetName());
    // ignore these specific entries
    if (spec == "comment" || spec == "result" || spec == "statistics" || spec == "MChadronisation" || spec == "excluded_set") continue;
    code = getUncertainty(spec, x, result, pair->Value());
    // we should never be finding any errors
    if (code == Analysis::kError) {
      std::cerr << "in CalibrationDataContainer::getUncertainties(): error retrieving named uncertainty "
        << spec << "!" << std::endl;
      return code;
    }
    // this assumes that non-success codes are likely to be correlated between uncertainty sources
    else if (code != Analysis::kSuccess) mycode = code;
    all[spec] = result;
  }
  return mycode;
}

getUncertainty()

CalibrationStatus CalibrationDataHistogramContainer::getUncertainty ( const std::string &  unc, const CalibrationDataVariables &  x, UncertaintyResult &  result, TObject *  obj = 0  )

virtual

retrieve the calibration uncertainty due to the given source.

Parameters

x	user-supplied (kinematic or other) variables
unc	uncertainty specification
result	requested uncertainty (for both positive and negative variation, if available)
obj	object holding the requested uncertainty information (it will be computed if not provided)

Returns

status code (see above)

Implements Analysis::CalibrationDataContainer.

Reimplemented in Analysis::CalibrationDataMappedHistogramContainer.

Definition at line 622 of file CalibrationDataContainer.cxx.

{
  // Retrieve the uncertainty for the given input variables.
  //
  //     unc:         keyword indicating requested source of uncertainty. This should
  //                  correspond to one of the histograms added explicitly as a systematic
  //                  uncertainty or the keyword "statistics" (statistical uncertainties are
  //                  accessed differently, see method getStatUncertainty()).
  //     x:           input variables
  //     result:      result
  //     obj:         pointer to alternative or cached histogram
 
  if (unc == "statistics") {
    // treat statistical uncertainties separately (they are stored with the actual result)
    double res;
    CalibrationStatus code = getStatUncertainty(x, res);
    if (code == Analysis::kError) return code;
    result.first =   res;
    result.second = -res;
    return code;
  }
 
  if (!obj) obj = GetValue(unc.c_str());
  TH1* hist = dynamic_cast<TH1*>(obj);
  if (! hist) return Analysis::kError;
 
  // select the relevant kinematic variables
  CalibrationStatus status = computeVariables(x, (unc == "extrapolation") );
 
  if (m_interpolate) {
    result.first = getInterpolatedResult(hist);
    // symmetrise the uncertainty (as there is no code to interpolate the bin errors)
    result.second = -result.first;
  } else {
    // TH1::FindFixBin() will ignore the variables not needed.
    // Note: FindFixBin() is only available in "recent" ROOT versions (FindBin() is appropriate for older versions)
    // (otherwise we need to rely on the ResetBit(TH1::kCanRebin) method having been used)
    Int_t bin = hist->FindFixBin(m_vars[0], m_vars[1], m_vars[2]);
    // the "first" and "second" entries are filled with the
    // "positive" and "negative" uncertainties, respectively.
    result.first = hist->GetBinContent(bin);
    result.second = hist->GetBinError(bin);
  }
 
  return status;
}

getUpperBound()

double CalibrationDataContainer::getUpperBound ( unsigned int  vartype, bool  extrapolate = false  ) const

inherited

retrieve the upper bound of validity for the requested variable type

Parameters

vartype	variable type
extrapolate	true only if an extrapolation uncertainty is requested

Definition at line 379 of file CalibrationDataContainer.cxx.

{
  // Utility function returning the upper validity bound for the given variable type.
  // The "extrapolate" variable flags whether normal validity bounds are to be used,
  // or instead those relevant for the extrapolation uncertainty.
 
  if (! (vartype < m_lowerBounds.size())) return std::numeric_limits<double>::max();
  return extrapolate ? m_upperBoundsExtrapolated[vartype] : m_upperBounds[vartype];
}

getVariableTypes()

std::vector< unsigned int > CalibrationDataContainer::getVariableTypes ( )

inherited

utility to retrieve variable types

Definition at line 408 of file CalibrationDataContainer.cxx.

{
  // List the variable types used for this calibration object.
  // The meaning of the types is encapsulated by the CalibrationParametrization enum.
 
  // ensure that the variable types have been computed properly
  if (m_variables.size() == 0) computeVariableTypes();
 
  return m_variables;
}

isBinCorrelated()

bool CalibrationDataHistogramContainer::isBinCorrelated

(

const std::string &

unc

)

const

Indicate whether the given uncertainty is correlated from bin to bin or not (note that this function is to be used only for systematic uncertainties)

Definition at line 719 of file CalibrationDataContainer.cxx.

{
  // Indicate whether the given uncertainty is correlated from bin to bin or not
  //  (note that this function is to be used only for _systematic_ uncertainties)
  return (m_uncorrelatedSyst.FindObject(unc.c_str()) == 0);
}

isInterpolated()

bool CalibrationDataHistogramContainer::isInterpolated ( ) const

virtual

Indicate whether histogram interpolation is used or not.

Reimplemented in Analysis::CalibrationDataMappedHistogramContainer.

Definition at line 751 of file CalibrationDataContainer.cxx.

{
  // Indicate whether histogram interpolation is used or not.
 
  return m_interpolate;
}

isNearlyEqual()

bool CalibrationDataContainer::isNearlyEqual ( double  a, double  b  )

staticinherited

utility for comparison of doubles

Definition at line 1744 of file CalibrationDataContainer.cxx.

                                                          {
  // Simple utility function testing whether two double values are sufficiently similar.
  // The test carried out is on their relative difference, which should be within a given tolerance.
 
  static const double tolerance = 1.e-8;
 
  double diff = a - b;
  double ref = std::fabs(a) + std::fabs(b);
  return (ref == 0 || std::fabs(diff) < tolerance*ref);
}

isRangeRestricted()

bool Analysis::CalibrationDataContainer::isRangeRestricted ( ) const

inlineinherited

allow the user to inspect the above information

Definition at line 162 of file CalibrationDataContainer.h.

{ return m_restrict; }

listUncertainties()

std::vector< std::string > CalibrationDataContainer::listUncertainties ( ) const

inherited

retrieve the list of "uncertainties" accessible to this object.

A few uncertainty names are predetermined: "result", "comment", "statistics", "systematics". Individual sources of systematic uncertainty can be added by the user.

Definition at line 120 of file CalibrationDataContainer.cxx.

{
  // Retrieve the list of uncertainties for this calibration.
  // Note that this is an un-pruned list: it contains also entries that
  // are not proper uncertainties (e.g. "result", "comment")
 
  std::vector<std::string> uncertainties;
  TIter it(GetTable());
  while (TPair* pair = (TPair*) it()) {
    std::string spec(pair->Key()->GetName());
    uncertainties.push_back(spec);
  }
  return uncertainties;
}

restrictToRange()

void Analysis::CalibrationDataContainer::restrictToRange ( bool  restrict )

inlineinherited

If true, this will restrict the variables used to be within the (specified) range of validity.

Note that this is a policy decision and as such not intrinsic to the data; but it is cumbersome to carry this information around everywhere.

Definition at line 159 of file CalibrationDataContainer.h.

{ m_restrict = restrict; }

setComment()

void CalibrationDataContainer::setComment ( const std::string &  text )

inherited

insert the given text as comment for this calibration

Definition at line 255 of file CalibrationDataContainer.cxx.

{
  // Insert (or replace) the comment field. This needs to be handled somewhat
  // specially as TString itself doesn't inherit from TObject.
  //
  //    text:       comment field (will be converted to TObjString)
 
  if (TPair* p = (TPair*) FindObject("comment")) DeleteEntry(p->Key());
  Add(new TObjString("comment"), new TObjString(text.c_str()));
}

setExcludedUncertainties()

void CalibrationDataContainer::setExcludedUncertainties ( const std::string &  text )

inherited

insert the set of uncertainties that are recommended for removal from the eigenvector decomposition.

Parameters

text	semicolon-separated list of uncertainties

Definition at line 280 of file CalibrationDataContainer.cxx.

{
  // Insert (or replace) the (semicolon-separated) list of uncertainties that are recommended to be excluded from the eigenvector decomposition
  //
  //    text:       the (semicolon-separated) list of uncertainties in string form (will be converted to TObjString)
 
  if (TPair* p = (TPair*) FindObject("excluded_set")) DeleteEntry(p->Key());
  Add(new TObjString("excluded_set"), new TObjString(text.c_str()));
}

setHadronisation()

void CalibrationDataContainer::setHadronisation ( const std::string &  text )

inherited

insert the given text as the 'hadronisation reference' for this calibration

Definition at line 268 of file CalibrationDataContainer.cxx.

{
  // Insert (or replace) the hadronisation reference.
  //
  //    text:       hadronisation reference in string form (will be converted to TObjString)
 
  if (TPair* p = (TPair*) FindObject("MChadronisation")) DeleteEntry(p->Key());
  Add(new TObjString("MChadronisation"), new TObjString(text.c_str()));
}

setInterpolated()

void CalibrationDataHistogramContainer::setInterpolated

(

bool

doInterpolate

)

Indicate whether results are to be interpolated between bins or not (this feature is thought to be useful mostly for MC efficiencies)

Definition at line 740 of file CalibrationDataContainer.cxx.

{
  // Indicate whether results are to be interpolated between bins or not
  // (this feature is thought to be useful mostly for MC efficiencies).
  // The default is not to use any interpolation.
 
  m_interpolate = doInterpolate;
}

setResult()

void CalibrationDataContainer::setResult ( TObject *  obj )

inherited

insert the main object for this calibration

Definition at line 244 of file CalibrationDataContainer.cxx.

{
  // Specialization of the setUncertainty() method: insert the calibration result
  //
  //     obj:       object to be entered (needs to inherit from TObject)
 
  setUncertainty(std::string("result"), obj);
}

setUncertainty()

void CalibrationDataContainer::setUncertainty ( const std::string &  unc, TObject *  obj  )

inherited

insert the relevant object for the requested source of 'uncertainty'

Definition at line 231 of file CalibrationDataContainer.cxx.

{
  // Insert (or replace) the given object at the position indicated by the given index.
  //
  //     unc:       uncertainty index
  //     obj:       object to be entered (needs to inherit from TObject)
 
  if (TPair* p = (TPair*) FindObject(unc.c_str())) DeleteEntry(p->Key());
  Add(new TObjString(unc.c_str()), obj);
}

setUncorrelated()

void CalibrationDataHistogramContainer::setUncorrelated

(

const std::string &

unc

)

Indicate that the given uncertainty is to be treated uncorrelated from bin to bin (note that the default is for all systematic uncertainties to be treated as correlated)

Definition at line 728 of file CalibrationDataContainer.cxx.

{
  // Indicate that the given uncertainty is to be treated uncorrelated from bin to bin
  // (the default is for all systematic uncertainties to be treated as correlated).
  // This method is not normall intended to be used during physics analysis; this
  // information is written to and read back from the calibration file.
 
  m_uncorrelatedSyst.Add(new TObjString(unc.c_str()));
}

typeFromString()

int CalibrationDataContainer::typeFromString ( const std::string &  key ) const

protectedinherited

Connection between variable names (on histogram axes etc.) and variable 'types' as used in actual evaluations.

Normal result values are positive (or 0); a negative return value indicates that the string is not known)

Definition at line 292 of file CalibrationDataContainer.cxx.

{
  // Small utility function collecting the correspondence between axis labels and (integer) variable indices.
  // In case of an unknown label, a negative number will be returned to flag the issue.
 
  if      (key == "eta") return kEta;
  else if (key == "abseta") return kAbsEta;
  else if (key == "pt") return kPt;
  else if (key == "tagweight") return kTagWeight;
  // return value for unknown keywords
  else return -1;
}

Member Data Documentation

m_binBoundaries

std::map<unsigned int, std::vector<double> > Analysis::CalibrationDataHistogramContainer::m_binBoundaries

protected

Cache for bin boundary information.

Definition at line 291 of file CalibrationDataContainer.h.

m_interpolate

bool Analysis::CalibrationDataHistogramContainer::m_interpolate

private

If true, interpolate between bins rather than doing a straight bin-wise evaluation.

Definition at line 299 of file CalibrationDataContainer.h.

m_lowerBounds

std::vector<double> Analysis::CalibrationDataContainer::m_lowerBounds

protectedinherited

Definition at line 210 of file CalibrationDataContainer.h.

m_lowerBoundsExtrapolated

std::vector<double> Analysis::CalibrationDataContainer::m_lowerBoundsExtrapolated

protectedinherited

Definition at line 213 of file CalibrationDataContainer.h.

m_objResult

TObject* Analysis::CalibrationDataContainer::m_objResult

protectedinherited

(possibly looser) upper validity bounds for extrapolation

cached variables for code speed-up

Definition at line 217 of file CalibrationDataContainer.h.

m_objSystematics

TObject* Analysis::CalibrationDataContainer::m_objSystematics

protectedinherited

don't persistify

Definition at line 218 of file CalibrationDataContainer.h.

m_restrict

bool Analysis::CalibrationDataContainer::m_restrict

privateinherited

persistency not needed for this variable

specifies whether the performance evaluation is to be done strictly within the range of validity

Definition at line 230 of file CalibrationDataContainer.h.

m_uncorrelatedSyst

THashList Analysis::CalibrationDataHistogramContainer::m_uncorrelatedSyst

private

no need to persistify

list here the systematic uncertainties that are not correlated from bin to bin

Definition at line 296 of file CalibrationDataContainer.h.

m_upperBounds

std::vector<double> Analysis::CalibrationDataContainer::m_upperBounds

protectedinherited

Definition at line 211 of file CalibrationDataContainer.h.

m_upperBoundsExtrapolated

std::vector<double> Analysis::CalibrationDataContainer::m_upperBoundsExtrapolated

protectedinherited

(possibly looser) lower validity bounds for extrapolation

Definition at line 214 of file CalibrationDataContainer.h.

m_variables

std::vector<unsigned int> Analysis::CalibrationDataContainer::m_variables

protectedinherited

don't persistify

specification of variable type per object (result / uncertainty)

Definition at line 223 of file CalibrationDataContainer.h.

m_vars

double Analysis::CalibrationDataContainer::m_vars[MaxCalibrationVars]

protectedinherited

don't persistify

Definition at line 220 of file CalibrationDataContainer.h.

---

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

• CalibrationDataContainer.h
• CalibrationDataContainer.cxx