Analysis::CalibrationDataFunctionContainer Class Reference

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

#include <CalibrationDataContainer.h>

Inheritance diagram for Analysis::CalibrationDataFunctionContainer:

Collaboration diagram for Analysis::CalibrationDataFunctionContainer:

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
	CalibrationDataFunctionContainer (const char *name="default")
virtual	~CalibrationDataFunctionContainer ()
virtual CalibrationStatus	getResult (const CalibrationDataVariables &x, double &result, TObject *obj=0, bool=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.
void	setLowerBound (int vartype, double bound)
	Set the lower bound of validity for the given variable.
void	setUpperBound (int vartype, double bound)
	Set the lower bound of validity for the given variable.
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::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
virtual void	computeVariableTypes ()
	cached
	ClassDef (CalibrationDataFunctionContainer, 1)

Private Attributes
TObject *	m_objStatistics
bool	m_restrict
	persistency not needed for this variable

Detailed Description

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

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

CalibrationDataFunctionContainer()

Analysis::CalibrationDataFunctionContainer::CalibrationDataFunctionContainer

(

const char *

name = "default"

)

~CalibrationDataFunctionContainer()

CalibrationDataFunctionContainer::~CalibrationDataFunctionContainer ( )

virtual

Definition at line 1566 of file CalibrationDataContainer.cxx.

{
}

Member Function Documentation

ClassDef()

Analysis::CalibrationDataFunctionContainer::ClassDef ( CalibrationDataFunctionContainer , 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 CalibrationDataFunctionContainer::computeVariableTypes ( )

privatevirtual

cached

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

Implements Analysis::CalibrationDataContainer.

Definition at line 1572 of file CalibrationDataContainer.cxx.

{
  // Determine which variable types are to be used.
  // This needs to be done only once per calibration object, as the results will be
  // cached (even if not persistified).
  // This method should normally only be used internally.
 
  if (! m_objResult) m_objResult = GetValue("result");
 
  std::string title(m_objResult->GetTitle());
  std::string::size_type pos = title.find(";");
  while (pos != std::string::npos && pos != title.size()) {
    title = title.substr(pos+1);
    pos = title.find(";");
    std::string var = title.substr(0, pos);
    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 CalibrationDataFunctionContainer::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);
}

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

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

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 CalibrationDataFunctionContainer::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.

Definition at line 1605 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 parametrisation rather than the original
  // one; in such cases it is possible to provide a pointer to this alternative parametrisation.
  //
  //     x:           input variables
  //     result:      result
  //     obj:         pointer to alternative results histogram
  if (!obj) {
    if (! m_objResult) m_objResult = GetValue("result");
    obj = m_objResult;
  }
  TF1* func = dynamic_cast<TF1*>(obj);
  if (! func) return Analysis::kError;
 
  // select the relevant kinematic variables
  CalibrationStatus status = computeVariables(x);
  result = func->EvalPar(m_vars);
 
  return status;
}

getStatUncertainty()

CalibrationStatus CalibrationDataFunctionContainer::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.

Definition at line 1675 of file CalibrationDataContainer.cxx.

{
  // Retrieve the statistical uncertainty for the given input variables.
  // The model that is assumed here is that statistical uncertainties follow from
  // a fit of the function to other information, and that the parameter covariance matrix
  // resulting from the fit are stored in a TMatrixDSym object identified by the
  // keyword "statistics". The effect of a change of fit parameters is then used to
  // evaluate the change in function value at the given co-ordinates.
  //
  //     x:           input variables
  //     result:      result
 
  if (! m_objResult) m_objResult = GetValue("result"); // ensure that the requested objects exist
  TF1* func = dynamic_cast<TF1*>(m_objResult);
  if (! func) {
    // std::cerr << "... unable to retrieve the result" << std::endl;
    return Analysis::kError;
  }
 
  if (! m_objStatistics) m_objStatistics = GetValue("statistics");
  //  m_objStatistics->Dump();
  TMatrixTSym<double>* cov = dynamic_cast<TMatrixTSym<double>*>(m_objStatistics);
  if (! cov) {
    // std::cerr << "... unable to retrieve the covariance matrix" << std::endl;
    return Analysis::kError;
  }
 
  // select the relevant kinematic variables
  CalibrationStatus status = computeVariables(x);
 
  // use a large value for "eps": this multiplies the uncertainties that
  // are expected to be associated with the parameters. Choosing a large
  // value expresses the fact that we are not primarily interested in the
  // parabolic behaviour at the minimum
  // const Double_t eps = 1.0;
  // test: set to 0.5
  const Double_t eps = 0.5;
 
  int npar = func->GetNpar();
  if (npar == 0) {
    result = 0.;
    return status;
  }
 
  TMatrixT<double> gradients(npar,1);
  for (int ipar = 0; ipar < npar; ++ipar) {
    gradients(ipar,0) = func->GradientPar(ipar, m_vars, eps);
  }
 
  // carry out the matrix multiplication
  TMatrixT<double> gradientsTransposed(TMatrixT<double>::kTransposed, gradients);
  //  std::cout << "parametricVariance: transposed gradients:";
  //  for (int ipar = 0; ipar < npar; ++ipar)
  //    std::cout << " " << gradients(0,ipar);
  //  std::cout << std::endl;
  TMatrixT<double> tmp1(*cov, TMatrixT<double>::kMult, gradients);
  //  std::cout << "parametricVariance: cov * gradients:";
  //  for (int ipar = 0; ipar < npar; ++ipar)
  //    std::cout << " " << tmp1(ipar,0);
  TMatrixT<double> tmp2(gradientsTransposed, TMatrixT<double>::kMult, tmp1);
 
  result = TMath::Sqrt(tmp2(0,0));
 
  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);
}

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 CalibrationDataFunctionContainer::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.

Definition at line 1633 of file CalibrationDataContainer.cxx.

{
  // Retrieve the uncertainty for the given input variables.
  // Note that the uncertainties returned will be symmetrised.
  //
  //     unc:         keyword indicating requested source of uncertainty. This should
  //                  correspond to one of the parametrisations 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 parametrisation
  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());
  TF1* func = dynamic_cast<TF1*>(obj);
  if (! func) return Analysis::kError;
 
  // select the relevant kinematic variables
  CalibrationStatus status = computeVariables(x);
 
  // the "first" and "second" entries are filled with the
  // "positive" and "negative" uncertainties, respectively.
  // Note: no "negative" uncertainties implemented as yet!
  result.first = func->EvalPar(m_vars);
  result.second = -result.first;
 
  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;
}

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

setLowerBound()

void Analysis::CalibrationDataFunctionContainer::setLowerBound ( int vartype, double bound )

inline

Set the lower bound of validity for the given variable.

Definition at line 438 of file CalibrationDataContainer.h.

{m_lowerBounds[vartype] = bound; }

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

setUpperBound()

void Analysis::CalibrationDataFunctionContainer::setUpperBound ( int vartype, double bound )

inline

Set the lower bound of validity for the given variable.

Definition at line 441 of file CalibrationDataContainer.h.

{m_upperBounds[vartype] = bound; }

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_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_objStatistics

TObject* Analysis::CalibrationDataFunctionContainer::m_objStatistics

private

Definition at line 445 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_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