Analysis::CalibrationDataContainer Class Reference

#include <CalibrationDataContainer.h>

Inheritance diagram for Analysis::CalibrationDataContainer:

Collaboration diagram for Analysis::CalibrationDataContainer:

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

Public Member Functions
	CalibrationDataContainer (const char *name="default")
virtual	~CalibrationDataContainer ()
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...
virtual CalibrationStatus	getResult (const CalibrationDataVariables &x, double &result, TObject *obj=0, bool extrapolate=false)=0
	retrieve the calibration result. More...
virtual CalibrationStatus	getStatUncertainty (const CalibrationDataVariables &x, double &result)=0
	retrieve the calibration statistical uncertainty. More...
CalibrationStatus	getSystUncertainty (const CalibrationDataVariables &x, UncertaintyResult &result, TObject *obj=0)
	retrieve the calibration total systematic uncertainty More...
virtual CalibrationStatus	getUncertainty (const std::string &unc, const CalibrationDataVariables &x, UncertaintyResult &result, TObject *obj=0)=0
	retrieve the calibration uncertainty due to the given source. 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...
virtual void	computeVariableTypes ()=0
	decode the 'uncertainty' objects' names to determine the relevant variable types More...

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 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
	ClassDef (CalibrationDataContainer, 1)

Private Attributes
bool	m_restrict
	persistency not needed for this variable More...

Detailed Description

This is the interface for the objects to be stored in the calibration ROOT file. The base class inherits from a TMap, the idea bing that the map's keys are TObjString objects while the values are the objects of interest. The keys are meant to provide access in a flexible manner.

Definition at line 51 of file CalibrationDataContainer.h.

Member Enumeration Documentation

CalibrationParametrization

enum Analysis::CalibrationDataContainer::CalibrationParametrization

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

CalibrationDataContainer()

Analysis::CalibrationDataContainer::CalibrationDataContainer

(

const char *

name = "default"

)

~CalibrationDataContainer()

CalibrationDataContainer::~CalibrationDataContainer ( )

virtual

Definition at line 95 of file CalibrationDataContainer.cxx.

{
}

Member Function Documentation

ClassDef()

Analysis::CalibrationDataContainer::ClassDef ( CalibrationDataContainer  , 1    )

private

computeVariables()

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

protected

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

virtual void Analysis::CalibrationDataContainer::computeVariableTypes ( )

protectedpure virtual

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

Implemented in Analysis::CalibrationDataFunctionContainer, Analysis::CalibrationDataMappedHistogramContainer, and Analysis::CalibrationDataHistogramContainer.

getBounds()

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

(

)

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

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

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

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

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

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

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

Implemented in Analysis::CalibrationDataFunctionContainer, Analysis::CalibrationDataMappedHistogramContainer, and Analysis::CalibrationDataHistogramContainer.

getStatUncertainty()

virtual CalibrationStatus Analysis::CalibrationDataContainer::getStatUncertainty ( const CalibrationDataVariables &  x, double &  result  )

pure 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

Implemented in Analysis::CalibrationDataFunctionContainer, Analysis::CalibrationDataMappedHistogramContainer, and Analysis::CalibrationDataHistogramContainer.

getSystUncertainty()

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

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
	)

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

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

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

Implemented in Analysis::CalibrationDataFunctionContainer, Analysis::CalibrationDataMappedHistogramContainer, and Analysis::CalibrationDataHistogramContainer.

getUpperBound()

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

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

(

)

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  )

static

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

inline

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

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 )

inline

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

)

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

)

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

)

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

setResult()

void CalibrationDataContainer::setResult

(

TObject *

obj

)

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
	)

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

typeFromString()

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

protected

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

protected

Definition at line 210 of file CalibrationDataContainer.h.

m_lowerBoundsExtrapolated

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

protected

Definition at line 213 of file CalibrationDataContainer.h.

m_objResult

TObject* Analysis::CalibrationDataContainer::m_objResult

protected

(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

protected

don't persistify

Definition at line 218 of file CalibrationDataContainer.h.

m_restrict

bool Analysis::CalibrationDataContainer::m_restrict

private

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

protected

Definition at line 211 of file CalibrationDataContainer.h.

m_upperBoundsExtrapolated

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

protected

(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

protected

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]

protected

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