Analysis::CalibrationDataMappedHistogramContainer Class Reference

This is the class holding information for histogram-based calibration results, in cases where 'irregular' binning is used (e.g., if the binning in one variable depends on another variable), or where the dimensionality becomes too high for even 3D histograms (so that a mapping is needed to use THx). More...

#include <CalibrationDataContainer.h>

Inheritance diagram for Analysis::CalibrationDataMappedHistogramContainer:

Collaboration diagram for Analysis::CalibrationDataMappedHistogramContainer:

Classes
class	Bin
	Helper class for the specification of custom binning. More...

Public Types
enum	CalibrationParametrization { kPt = 0 , kEta = 1 , kAbsEta = 2 , kTagWeight = 3 }
	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. More...

Public Member Functions
	CalibrationDataMappedHistogramContainer (const char *name="default")
virtual	~CalibrationDataMappedHistogramContainer ()
virtual CalibrationStatus	getResult (const CalibrationDataVariables &x, double &result, TObject *obj=0, bool extrapolate=false)
	retrieve the calibration result.
virtual CalibrationStatus	getStatUncertainty (const CalibrationDataVariables &x, double &result)
	retrieve the calibration statistical uncertainty.
virtual CalibrationStatus	getUncertainty (const std::string &unc, const CalibrationDataVariables &x, UncertaintyResult &result, TObject *obj=0)
	retrieve the calibration uncertainty due to the given source.
virtual bool	isInterpolated () const
	Indicate whether histogram interpolation is used or not.
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).
void	setMappedVariables (const std::vector< std::string > &variables)
	Set (by hand) the variables that will be mapped onto a single histogram axis.
const std::vector< std::string > &	getMappedVariables () const
	List which variables get mapped onto a single histogram axis.
virtual std::vector< double >	getBinBoundaries (unsigned int vartype)
	Retrieve the bin boundaries for the specified variable type (which should be a CalibrationParametrization enum).
unsigned int	addBin (const Bin &bin)
	Add mapping bin.
unsigned int	getNMappedBins () const
	return the number of mapped bins
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)
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)
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)
virtual int	getEigenvectorReduction (unsigned int choice) const
	Retrieve the number of eigenvectors to be retained for the purpose of eigenvector variation reduction strategies.
std::vector< std::string >	listUncertainties () const
	retrieve the list of "uncertainties" accessible to this object.
CalibrationStatus	getUncertainties (const CalibrationDataVariables &x, std::map< std::string, Analysis::UncertaintyResult > &all)
	retrieve the list of "uncertainties" accessible to this object.
std::string	getComment () const
	retrieve the comments entered for this calibration, if any
std::string	getHadronisation () const
	retrieve the 'hadronisation reference' entered for this calibration, if any
std::string	getExcludedUncertainties () const
	retrieve the (semicolon-separated) set of uncertainties that are recommended for removal from the eigenvector decomposition
CalibrationStatus	getSystUncertainty (const CalibrationDataVariables &x, UncertaintyResult &result, TObject *obj=0)
	retrieve the calibration total systematic uncertainty
void	setResult (TObject *obj)
	insert the main object for this calibration
void	setComment (const std::string &text)
	insert the given text as comment for this calibration
void	setHadronisation (const std::string &text)
	insert the given text as the 'hadronisation reference' for this calibration
void	setExcludedUncertainties (const std::string &text)
	insert the set of uncertainties that are recommended for removal from the eigenvector decomposition.
void	setUncertainty (const std::string &unc, TObject *obj)
	insert the relevant object for the requested source of 'uncertainty'
void	restrictToRange (bool restrict)
	If true, this will restrict the variables used to be within the (specified) range of validity.
bool	isRangeRestricted () const
	allow the user to inspect the above information
double	getLowerBound (unsigned int vartype, bool extrapolate=false) const
	retrieve the lower bound of validity for the requested variable type
double	getUpperBound (unsigned int vartype, bool extrapolate=false) const
	retrieve the upper bound of validity for the requested variable type
std::vector< std::pair< double, double > >	getBounds ()
	allow the user to inspect the bounds of validity
std::vector< unsigned int >	getVariableTypes ()
	utility to retrieve variable types

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

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.
CalibrationStatus	computeVariables (const CalibrationDataVariables &x, bool extrapolate=false)
	compute the variables to be used for the given 'uncertainty'

Protected Attributes
std::map< unsigned int, std::vector< double > >	m_binBoundaries
	Cache for bin boundary information.
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
TObject *	m_objResult
	(possibly looser) upper validity bounds for extrapolation
TObject *	m_objSystematics
	don't persistify
double	m_vars [MaxCalibrationVars]
	don't persistify
std::vector< unsigned int >	m_variables
	don't persistify

Private Member Functions
Int_t	findBin ()
	don't persistify
Int_t	findMappedBin (const double *x)
void	checkBounds ()
	check the bounds of validity for this calibration object
virtual void	computeVariableTypes ()
	decode the 'uncertainty' objects' names to determine the relevant variable types
	ClassDef (CalibrationDataMappedHistogramContainer, 1)
double	getInterpolatedResult (TH1 *hist) const
	Retrieve interpolated result (utility function)
double	getInterpolatedUncertainty (TH1 *hist) const
	Retrieve interpolated result (utility function)

Private Attributes
std::vector< std::string >	m_mapped
	mapped variables.
unsigned int	m_beginMapped
	starting position of mapped variables
std::vector< Bin >	m_bins
	don't persistify
unsigned int	m_lastBin
THashList	m_uncorrelatedSyst
	no need to persistify
bool	m_interpolate
	If true, interpolate between bins rather than doing a straight bin-wise evaluation.
bool	m_restrict
	persistency not needed for this variable

Detailed Description

This is the class holding information for histogram-based calibration results, in cases where 'irregular' binning is used (e.g., if the binning in one variable depends on another variable), or where the dimensionality becomes too high for even 3D histograms (so that a mapping is needed to use THx).

Using this class instead of the 'regular' histogram container will imply a performance penalty, as bin numberings are not assumed to feature any regularity.

Definition at line 335 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

CalibrationDataMappedHistogramContainer()

Analysis::CalibrationDataMappedHistogramContainer::CalibrationDataMappedHistogramContainer

(

const char *

name = "default"

)

~CalibrationDataMappedHistogramContainer()

CalibrationDataMappedHistogramContainer::~CalibrationDataMappedHistogramContainer ( )

virtual

Definition at line 1024 of file CalibrationDataContainer.cxx.

{
}

Member Function Documentation

addBin()

unsigned int CalibrationDataMappedHistogramContainer::addBin

(

const Bin &

bin

)

Add mapping bin.

The return value is the bin number.

Definition at line 1284 of file CalibrationDataContainer.cxx.

{
  // Add a bin to the present list
  // Note the absence of a -1 in the return value: this is because ROOT's histogram axes start counting from 1
 
  m_bins.push_back(bin);
  return m_bins.size();
}

checkBounds()

void CalibrationDataMappedHistogramContainer::checkBounds ( )

private

check the bounds of validity for this calibration object

Definition at line 1090 of file CalibrationDataContainer.cxx.

{
  // Check the bounds of validity for this calibration object.
  // See the CalibrationDataHistogramContainer::checkBounds() method. The difference is
  // that the 'mapped' dimensions need to be handled separately (this is carried out by
  // looping over the mapped bins and inspecting each bin's validity bounds individually).
  // Note that extrapolation uncertainties are not covered at this point.
 
  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_mapped.size()) - 1 != int(m_variables.size())) {
    std::cerr << "in CalibrationDataMappedHistogramContainer::checkBounds(): given number of variable types ("
          << m_variables.size() << ") doesn't match (mapped) histogram dimension ("
          << hist->GetDimension() + m_mapped.size() - 1 << ")!" << std::endl;
    return;
  }
 
  // Carry out the only cross-check that's possible for the binning: check that the dimensionality
  // for all bins matches the number of variables specified for the mapping
  for (unsigned int bin = 0; bin < m_bins.size(); ++bin)
    assert(m_bins[bin].getDimension() == m_mapped.size());
 
  for (unsigned int t = 0, t2 = 0; int(t) < hist->GetDimension(); ++t) {
    const TAxis* axis = 0;
    switch (t) {
    case 0: axis = hist->GetXaxis(); break;
    case 1: axis = hist->GetYaxis(); break;
    default: axis = hist->GetZaxis();
    }
 
    // Special case for the mapped dimension: here the only thing that can be done is to
    // cycle through all Bins and inspect the boundaries of each bin manually.
    if (t == m_beginMapped) {
      for (unsigned int mapped = 0; mapped < m_mapped.size(); ++mapped) {
    for (unsigned int bin = 0; bin < m_bins.size(); ++bin) {
      double amax = m_bins[bin].getUpperBound(mapped), amin = m_bins[bin].getLowerBound(mapped);
      if (bin == 0 || amax > m_upperBounds[m_variables[t2]]) m_upperBounds[m_variables[t2]] = amax;
      if (bin == 0 || amin < m_lowerBounds[m_variables[t2]]) m_lowerBounds[m_variables[t2]] = amin;
    }
    ++t2;
      }
    } else {
      // 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;
      //   }
      // }
      double amax = axis->GetXmax(), amin = axis->GetXmin();
      if (amax < m_upperBounds[m_variables[t2]]) m_upperBounds[m_variables[t2]] = amax;
      if (amin > m_lowerBounds[m_variables[t2]]) m_lowerBounds[m_variables[t2]] = amin;
      ++t2;
    }
  }
}

ClassDef()

Analysis::CalibrationDataMappedHistogramContainer::ClassDef ( CalibrationDataMappedHistogramContainer , 1  )

private

computeVariables()

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

protectedinherited

compute the variables to be used for the given 'uncertainty'

Parameters

x	user-supplied (kinematic or other) variables
unc	given source of uncertainty (can also be the central value)

Returns

false if the given variables are outside the parametrisation's validity range 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 CalibrationDataMappedHistogramContainer::computeVariableTypes ( )

privatevirtual

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

Reimplemented from Analysis::CalibrationDataHistogramContainer.

Definition at line 1030 of file CalibrationDataContainer.cxx.

{
  // Compute the variable types for this container object.
  // The computation differs from that used for the parent CalibrationDataHistogramContainer
  // class, as also the 'mapped' variables (the variables that are mapped onto a single histogram
  // axis) need to be accounted for properly. This is handled as a special case.
 
  // 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 CalibrationDataMappedHistogramContainer::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();
    }
    std::string var(axis->GetTitle());
    if (var == "mapped") {
      // Special case: mapped variables, so make sure to specify the original variables (not the mapped ones).
      // Note that the code here assumes that the mapping is identical for all objects..
      for (unsigned int m = 0; m < m_mapped.size(); ++m) {
    int vartype = typeFromString(m_mapped[m]);
    // this check should never fail; therefore, bail out if this does happen
    assert (! (vartype < 0));
    m_variables.push_back((unsigned int)vartype);
      }
      // In this case, also flag _where_ in the resulting list of variables the mapping starts
      m_beginMapped = dim;
    } else {
      int vartype = typeFromString(var);
      if (vartype < 0) {
    // Only flag the issue but otherwise take no action (assume non-argument use of a semicolon)
    std::cerr << "in CalibrationDataMappedHistogramContainer::computeVariableTypes(): cannot construct variable type from name "
          << var << 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<CalibrationDataMappedHistogramContainer*>(this)->checkBounds();
}

findBin()

Int_t CalibrationDataMappedHistogramContainer::findBin ( )

private

don't persistify

find the bin number corresponding to the input variables

Definition at line 1326 of file CalibrationDataContainer.cxx.

{
  // Find the bin corresponding to the computed variables (the computation is assumed to have just
  // taken place and resulted in the m_vars array having been filled appropriately)
 
  Int_t mapped[3] = {0};
  const TH1* hist = dynamic_cast<const TH1*>(m_objResult);
  if (not hist){
    std::cerr << "CalibrationDataMappedHistogramContainer::findBin(): dynamic cast failed\n";
    return 0;
  }
  Int_t ndim = hist->GetDimension();
  // Push the mapped variables onto an array.
  // Since we derive from TH1 this need never be more than 3 elements long.
  for (unsigned int dim = 0; dim < (unsigned int) ndim; ++dim) {
    if (dim == m_beginMapped) {
      if ((mapped[dim] = findMappedBin(&(m_vars[dim]))) < 0) return -1;
    } else {
      const TAxis* axis = 0;
      switch (dim) {
      case 0: axis = hist->GetXaxis(); break;
      case 1: axis = hist->GetYaxis(); break;
      default: axis = hist->GetZaxis();
      }
      mapped[dim] = axis->FindFixBin((dim < m_beginMapped) ? m_vars[dim] : m_vars[dim+m_mapped.size()-1]);
    }
  }
  return hist->GetBin(mapped[0], mapped[1], mapped[2]);
}

findMappedBin()

Int_t CalibrationDataMappedHistogramContainer::findMappedBin ( const double * x )

private

Definition at line 1305 of file CalibrationDataContainer.cxx.

{
  // Find the mapped bin corresponding to the variables used for the mapping
 
  if (m_bins[m_lastBin].contains(x)) return m_lastBin + 1; // First check quickly whether the last bin (cached) matches
 
  // Search the whole array for a match
  for (unsigned int bin = 0; bin < m_bins.size(); ++bin)
    if (m_bins[bin].contains(x)) {
      m_lastBin = bin;
      return m_lastBin + 1;
    }
  std::cerr << "CalibrationDataMappedHistogramContainer::findMappedBin(): unable to find bin for mapping variables:";
  for (unsigned int d = 0; d < m_mapped.size(); ++d) std::cerr << "\t" << x[d];
  std::cerr << std::endl;
  // -1 means invalid..
  return -1;
}

getBinBoundaries()

std::vector< double > CalibrationDataMappedHistogramContainer::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 from Analysis::CalibrationDataHistogramContainer.

Definition at line 1358 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();
 
  // 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;
 
  // Check whether the variable type is actually being used
  std::vector<double> boundaries;
  int var = -1;
  for (unsigned int v = 0; v < m_variables.size(); ++v)
    if (m_variables[v] == vartype) var = (int) v;
  if (var == -1) return boundaries;
 
  // Retrieve the appropriate histogram axis
  if (! m_objResult) m_objResult = GetValue("result");
  const TH1* hobj = dynamic_cast<const TH1*>(m_objResult);
 
  if (var >= int(m_beginMapped) && var < int(m_beginMapped + m_mapped.size())) {
    // Special case of a mapped variable. In this case, test all Bins for their boundaries
    unsigned int mapped = var - m_beginMapped;
    for (unsigned int bin = 0; bin < m_bins.size(); ++bin) {
      double binBoundaries[2];
      binBoundaries[0] = m_bins[bin].getLowerBound(mapped);
      binBoundaries[1] = m_bins[bin].getUpperBound(mapped); 
      // Insert the bin boundaries, if not already present (the test is whether the relative difference
      // is smaller than 1e-8)
      if (boundaries.size() == 0) {
    boundaries.push_back(binBoundaries[0]); boundaries.push_back(binBoundaries[1]);
      } else {
    for (unsigned int ib = 0; ib < 2; ++ib) {
      double newvalue = binBoundaries[ib];
      bool done = false;
      for (std::vector<double>::iterator it = boundaries.begin(); it != boundaries.end(); ++it) {
        if (isNearlyEqual(newvalue, *it)) {
          // consider this value to have been inserted already
          done = true; break;
        } else if (newvalue < *it) {
          // the interesting case: insert the new value
          boundaries.insert(it, newvalue);
          done = true; break;
        }
      }
      // last case: new value is larger than any of the values in the array so far
      if (! done) boundaries.push_back(newvalue);
    }
      }
    }
  } else {
    // Normal case:
    unsigned int dim = (var < int(m_beginMapped)) ? var : var + 1 - m_mapped.size();
    const TAxis* axis = 0;
    switch (dim) {
    case 0: axis = hobj->GetXaxis(); break;
    case 1: axis = hobj->GetYaxis(); break;
    default: 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

virtualinherited

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

privateinherited

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

privateinherited

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];
}

getMappedVariables()

const std::vector< std::string > & CalibrationDataMappedHistogramContainer::getMappedVariables

(

)

const

List which variables get mapped onto a single histogram axis.

Definition at line 1275 of file CalibrationDataContainer.cxx.

{
  // List which variables get mapped onto a single histogram axis
 
  return m_mapped;
}

getNMappedBins()

unsigned int CalibrationDataMappedHistogramContainer::getNMappedBins

(

)

const

return the number of mapped bins

Definition at line 1295 of file CalibrationDataContainer.cxx.

{
  // Return the number of mapped bins
  // Note the absence of a -1 in the return value: this is because ROOT's histogram axes start counting from 1
 
  return m_bins.size();
}

getResult()

CalibrationStatus CalibrationDataMappedHistogramContainer::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)

Reimplemented from Analysis::CalibrationDataHistogramContainer.

Definition at line 1152 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.
  // The method here differs from CalibrationDataHistogramContainer::getResult()
  // since histogram interpolation does not make sense for mapped bins.
  //
  //     x:           input variables
  //     result:      result
  //     obj:         pointer to alternative results histogram
 
  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);
  // find the relevant "global" bin and retrieve its contents
  result = hist->GetBinContent(findBin());
 
  return status;
}

getStatUncertainty()

CalibrationStatus CalibrationDataMappedHistogramContainer::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

Reimplemented from Analysis::CalibrationDataHistogramContainer.

Definition at line 1185 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) return Analysis::kError;
 
  // select the relevant kinematic variables
  CalibrationStatus status = computeVariables(x);
  // find the relevant "global" bin and retrieve its contents
  result = hist->GetBinError(findBin());
 
  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 CalibrationDataMappedHistogramContainer::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 from Analysis::CalibrationDataHistogramContainer.

Definition at line 1249 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.
 
  for (unsigned int type = 0; type < m_variables.size(); ++type)
    if (m_variables[type] == kTagWeight) {
      int hist_type = int(type);
      return (hist_type > int(m_beginMapped)) ? hist_type - m_mapped.size() + 1 : hist_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 CalibrationDataMappedHistogramContainer::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)

Reimplemented from Analysis::CalibrationDataHistogramContainer.

Definition at line 1209 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
 
  // treat statistical uncertainties separately (they are stored with the actual result)
  if (unc == "statistics") {
    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);
  // find the relevant "global" bin and retrieve its contents
  Int_t bin = findBin();
  result.first = hist->GetBinError(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

inherited

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()

virtual bool Analysis::CalibrationDataMappedHistogramContainer::isInterpolated ( ) const

inlinevirtual

Indicate whether histogram interpolation is used or not.

Not applicable here.

Reimplemented from Analysis::CalibrationDataHistogramContainer.

Definition at line 346 of file CalibrationDataContainer.h.

{ return false; }

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()) {
    
    uncertainties.emplace_back(pair->Key()->GetName());
  }
  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 )

inherited

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;
}

setMappedVariables()

void CalibrationDataMappedHistogramContainer::setMappedVariables

(

const std::vector< std::string > &

variables

)

Set (by hand) the variables that will be mapped onto a single histogram axis.

Definition at line 1266 of file CalibrationDataContainer.cxx.

{
  // Set (by hand) the variables that will be mapped onto a single histogram axis
 
  m_mapped = variables;
}

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 )

inherited

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_beginMapped

unsigned int Analysis::CalibrationDataMappedHistogramContainer::m_beginMapped

private

starting position of mapped variables

Definition at line 399 of file CalibrationDataContainer.h.

m_binBoundaries

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

protectedinherited

Cache for bin boundary information.

Definition at line 291 of file CalibrationDataContainer.h.

m_bins

std::vector<Bin> Analysis::CalibrationDataMappedHistogramContainer::m_bins

private

don't persistify

calibration bins

Definition at line 402 of file CalibrationDataContainer.h.

m_interpolate

bool Analysis::CalibrationDataHistogramContainer::m_interpolate

privateinherited

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

Definition at line 299 of file CalibrationDataContainer.h.

m_lastBin

unsigned int Analysis::CalibrationDataMappedHistogramContainer::m_lastBin

private

Definition at line 404 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_mapped

std::vector<std::string> Analysis::CalibrationDataMappedHistogramContainer::m_mapped

private

mapped variables.

These have to be specified when creating the object, for there is no way to transmit this information otherwise.

Definition at line 396 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

privateinherited

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