Analysis::CalibrationDataEigenVariations Class Reference

#include <CalibrationDataEigenVariations.h>

Inheritance diagram for Analysis::CalibrationDataEigenVariations:

Collaboration diagram for Analysis::CalibrationDataEigenVariations:

Public Types
typedef std::set< size_t >	IndexSet
typedef std::set< IndexSet >	IndexSuperSet

Public Member Functions
	CalibrationDataEigenVariations (const std::string &cdipath, const std::string &tagger, const std::string &wp, const std::string &jetcollection, CalibrationDataHistogramContainer *cnt, bool excludeRecommendedUncertaintySet=false, bool base=true)
	normal constructor.
virtual	~CalibrationDataEigenVariations ()
void	excludeNamedUncertainty (const std::string &name, CalibrationDataContainer *cnt)
	exclude the source of uncertainty indicated by name from eigenvector calculations
virtual void	initialize (double min_variance=1.0E-20)
	carry out the eigenvector computations.
void	removeVariations (const IndexSet &set)
	remove all variations in the given set
void	removeVariations (const IndexSuperSet &set)
	remove all variations in any of the given sets
void	mergeVariationsFrom (const size_t &index)
	merge all variations starting from the given index
void	mergeVariations (const IndexSet &set)
	merge all variations in the given set
void	mergeVariations (const IndexSuperSet &set)
	merge all variations in any of the given sets
unsigned int	getNumberOfNamedVariations () const
	retrieve the number of named variations
std::vector< std::string >	listNamedVariations () const
	list the named variations
unsigned int	getNamedVariationIndex (const std::string &name) const
	retrieve the integer index corresponding to the named variation.
unsigned int	getNumberOfEigenVariations ()
	retrieve the number of eigenvector variations
bool	getEigenvectorVariation (unsigned int variation, TH1 *&up, TH1 *&down)
	obtain the "up" and "down" variations for the given eigenvector number.
bool	getNamedVariation (const std::string &name, TH1 *&up, TH1 *&down)
	obtain the "up" and "down" variations for the named uncertainty.
bool	getNamedVariation (unsigned int nameIndex, TH1 *&up, TH1 *&down)
	obtain the "up" and "down" variations for the source uncertainty pointed to by the given index (which is assumed to correspond to the value retrieved using getNamedVariationIndex()).
bool	isExtrapolationVariation (unsigned int nameIndex) const
	flag whether the given index corresponds to an extrapolation variation
virtual TMatrixDSym	getEigenCovarianceMatrix ()
	also provide (some) access to the underlying information: covariance matrix corresponding to eigenvector variations
TMatrixDSym	getEigenCovarianceMatrixFromVariations ()
	covariance matrix corresponding to eigenvector variations constructed from the eigen-variation
TMatrixD	getJacobianReductionMatrix ()
	matrix to remove unecessary rows and columns from covariance
bool	EigenVectorRecomposition (const std::string &label, std::map< std::string, std::map< std::string, float > > &coefficientMap)
	Eigenvector recomposition method.
void	setVerbose (bool)

Protected Attributes
bool	m_initialized
	flag whether the initialization has been carried out
bool	m_validate
std::map< std::string, unsigned int >	m_namedIndices
	named variations
std::vector< std::pair< TH1 *, TH1 * > >	m_named
int	m_namedExtrapolation
	named variation index for the special case of extrapolation uncertainties
std::vector< std::pair< TH1 *, TH1 * > >	m_eigen
	eigenvector variations
bool	m_statVariations
	indicate whether statistical uncertainties are stored as variations
std::string	m_cdipath
	@ data members needed for eigenvector method
std::string	m_taggername
std::string	m_wp
std::string	m_jetauthor
double	m_totalvariance
double	m_capturedvariance
bool	m_verbose

Private Attributes
CalibrationDataHistogramContainer *	m_cnt
	container object containing the basic information

Detailed Description

Definition at line 27 of file CalibrationDataEigenVariations.h.

Member Typedef Documentation

IndexSet

typedef std::set<size_t> Analysis::CalibrationDataEigenVariations::IndexSet

Definition at line 29 of file CalibrationDataEigenVariations.h.

IndexSuperSet

typedef std::set<IndexSet> Analysis::CalibrationDataEigenVariations::IndexSuperSet

Definition at line 30 of file CalibrationDataEigenVariations.h.

Constructor & Destructor Documentation

CalibrationDataEigenVariations()

Analysis::CalibrationDataEigenVariations::CalibrationDataEigenVariations	(	const std::string &	cdipath,
		const std::string &	tagger,
		const std::string &	wp,
		const std::string &	jetcollection,
		CalibrationDataHistogramContainer *	cnt,
		bool	excludeRecommendedUncertaintySet = false,
		bool	base = true )

normal constructor.

The second argument, if true, will attempt to retrieve a 'recommended' set of uncertainties to be excluded from EV decomposition

~CalibrationDataEigenVariations()

CalibrationDataEigenVariations::~CalibrationDataEigenVariations ( )

virtual

Definition at line 355 of file CalibrationDataEigenVariations.cxx.

{
  // delete all variation histograms owned by us
  for (vector<pair<TH1*, TH1*> >::iterator it = m_eigen.begin(); it != m_eigen.end(); ++it) {
    delete it->first;
    delete it->second;
  }
 
  for (vector<pair<TH1*, TH1*> >::iterator it = m_named.begin(); it != m_named.end(); ++it) {
      delete it->first;
      delete it->second;
  }
}

Member Function Documentation

EigenVectorRecomposition()

bool CalibrationDataEigenVariations::EigenVectorRecomposition	(	const std::string &	label,
		std::map< std::string, std::map< std::string, float > > &	coefficientMap )

Eigenvector recomposition method.

Definition at line 1109 of file CalibrationDataEigenVariations.cxx.

{
  // Calculating eigen vector recomposition coefficient map and pass to
  // user by reference. Return true if method success. Return false and
  // will not modify coefficientMap if function failed.
  //
  //     label:          flavour label
  //     coefficientMap: (reference to) coefficentMap which will be used as return value.
 
  if (! m_initialized) initialize();
 
  std::vector<TH1*> originSF_hvec;
  std::vector<TH1*> eigenSF_hvec;
 
  // Retrieving information for calculation
  std::vector<string>fullUncList = m_cnt->listUncertainties();
  std::vector<string> uncList;
  for (unsigned int t = 0; t < fullUncList.size(); ++t) {
    // entries that should never be included
    if (fullUncList[t] == "comment" || fullUncList[t] == "result" || fullUncList[t] == "combined" || 
        fullUncList[t] == "statistics" || fullUncList[t] == "systematics" || fullUncList[t] == "MCreference" || 
        fullUncList[t] == "MChadronisation" || fullUncList[t] == "extrapolation" || fullUncList[t] == "ReducedSets" || 
        fullUncList[t] == "excluded_set") continue;
 
    // entries that can be excluded if desired
    if (m_namedIndices.find(fullUncList[t]) != m_namedIndices.end()) continue;
    
    TH1* hunc = dynamic_cast<TH1*>(m_cnt->GetValue(fullUncList[t].c_str()));
    if (not hunc){
      std::cerr<<"CalibrationDataEigenVariations::EigenVectorRecomposition: dynamic cast failed\n";
      continue;
    }
 
    Int_t nx = hunc->GetNbinsX();
    Int_t ny = hunc->GetNbinsY();
    Int_t nz = hunc->GetNbinsZ();
    Int_t bin = 0;
    bool retain = false; // Retain the histogram?
 
    // discard empty histograms
    // Read all bins without underflow&overflow
    for(Int_t binx = 1; binx <= nx; binx++)
      for(Int_t biny = 1; biny <= ny; biny++)
    for(Int_t binz = 1; binz <= nz; binz++){
      bin = hunc->GetBin(binx, biny, binz);  
      if (fabs(hunc->GetBinContent(bin)) > 1E-20){
        retain = true;
        break;
      }
    }// end hist bin for-loop
    if (!retain){
      if (m_verbose) std::cout<<"Eigenvector Recomposition: Empty uncertainty "<<fullUncList.at(t)<<" is discarded."<<std::endl;
      continue; // discard the vector
    }
 
    uncList.push_back(fullUncList.at(t));
    originSF_hvec.push_back(hunc);
  }
 
  TH1* nom = dynamic_cast<TH1*>(m_cnt->GetValue("result")); // Nominal SF hist
  if (not nom){
     if (m_verbose) std::cout<<"Eigenvector Recomposition: dynamic cast failed\n";
     return false;
  }
  int dim = nom->GetDimension();
  Int_t nx = nom->GetNbinsX();
  Int_t ny = nom->GetNbinsY();
  Int_t nz = nom->GetNbinsZ();
  Int_t nbins = nx;
  if(dim > 1) nbins *= ny;
  if(dim > 2) nbins *= nz;
  TMatrixD matSF(uncList.size(), nbins);
  Int_t col = 0; // mark the column number
  // Fill the Delta SF Matrix
  for(unsigned int i = 0; i < uncList.size(); i++){
    col = 0;
    // Loop all bins except underflow&overflow bin
    for(int binz = 1; binz <= nz; binz++)
      for(int biny = 1; biny <= ny; biny++)
    for(int binx = 1; binx <= nx; binx++){
      Int_t bin = originSF_hvec.at(i)->GetBin(binx, biny, binz);
      TMatrixDRow(matSF,i)[col] = originSF_hvec[i]->GetBinContent(bin);
      col++;
    }
  }
 
  // get eigen vectors of scale factors. Note that this is not the original eigen-vector.
  int nEigen = getNumberOfEigenVariations();
  TH1* up = nullptr;
  TH1* down = nullptr;
  for (int i = 0; i < nEigen; i++){
    if (!getEigenvectorVariation(i, up, down)){
       std::cerr<<"EigenVectorRecomposition: Error on retrieving eigenvector "<<i<<std::endl;
      return false;
    }
    //Need uncertainty value so subtract central calibration here.
    up->Add(nom, -1);
    eigenSF_hvec.push_back(up);
  }
  TMatrixD matEigen(nEigen, nbins);
 
  // Fill the Eigen Matrix
  for(int i = 0; i < nEigen; i++){
    col = 0;
    // Read 300 bins without underflow&overflow
    for(int binz = 1; binz <= nz; binz++)
      for(int biny = 1; biny <= ny; biny++)
    for(int binx = 1; binx <= nx; binx++){
      Int_t bin = eigenSF_hvec.at(i)->GetBin(binx, biny, binz);
      TMatrixDRow(matEigen,i)[col] = eigenSF_hvec[i]->GetBinContent(bin);
      col++;
    }
  }
 
  // Sanity check:
  TMatrixD matEigenOriginal = matEigen;
  TMatrixD matEigenTranspose = matEigen;
  matEigenTranspose = matEigenTranspose.T();
  TMatrixD matOriginalTimesTranspose = matEigenOriginal*matEigenTranspose;
  TMatrixD matEigenInvert = matEigenTranspose*matOriginalTimesTranspose.Invert();
  //(matEigenOriginal*matEigenInvert).DrawClone("colz"); // This should give us an identity matrix
 
  TMatrixD matCoeff = matSF*matEigenInvert;
  int nRows = matCoeff.GetNrows();
  int nCols = matCoeff.GetNcols();
  std::map<std::string, float> temp_map;
  for (int col = 0; col < nCols; col++){
    temp_map.clear();
    for(int row = 0; row < nRows; row++){
      temp_map[uncList[row]] = TMatrixDRow(matCoeff, row)[col];
    }
    coefficientMap["Eigen_"+label+"_"+std::to_string(col)] = temp_map;
  }
  
  return true;
}

excludeNamedUncertainty()

void CalibrationDataEigenVariations::excludeNamedUncertainty	(	const std::string &	name,
		CalibrationDataContainer *	cnt )

exclude the source of uncertainty indicated by name from eigenvector calculations

Definition at line 371 of file CalibrationDataEigenVariations.cxx.

{
  // Exclude the source of uncertainty identified by the given name from being used
  // in the construction of the covariance matrix to be diagonalised.
  // Notes:
  // - Some names returned by CalibrationDataContainer::listUncertainties() are not
  //   meaningful in this context, and specifying them is not allowed.
  // - Once the eigenvector diagonalisation has been carried out, this method may
  //   not be used anymore.
 
  if (m_initialized) {
    std::cerr << "CalibrationDataEigenVariations::excludeNamedUncertainty error:" << " initialization already done" << std::endl;
  } else if (name == "comment"    || name == "result"   || name == "systematics" || 
             name == "statistics" || name == "combined" || name == "extrapolation" || 
             name == "MCreference" || name == "MChadronisation" || name == "ReducedSets" || 
             name == "excluded_set" || name == "" || name == " ") // <--- these last two handle some cases that may turn up
  {
    std::cerr << "CalibrationDataEigenVariations::excludeNamedUncertainty error:" << " name " << name << " not allowed" << std::endl;
  } 
  // in case multiple uncertainties should be discarded
  else if (name.back() == '*'){
    std::string temp_name = name.substr(0, name.size()-1); //remove "*"
    std::vector<std::string> uncs = m_cnt->listUncertainties();
    std::vector<std::string> unc_subgroup;
    std::copy_if(uncs.begin(), uncs.end(), back_inserter(unc_subgroup),
         [&temp_name](const std::string& el) {
           return el.compare(0, temp_name.size(), temp_name) == 0;
         });
    if (m_verbose) std::cout <<"Found a group of uncertainties to exclude: " <<name <<" found " <<unc_subgroup.size() <<" uncertainties corresponding to the query" <<std::endl;
    for (const auto& single_name : unc_subgroup){
      // only really add if the entry is not yet in the list
      if (m_namedIndices.find(single_name) == m_namedIndices.end()) {
        if (m_verbose) std::cout << "Name : " << single_name << std::endl;
        m_named.push_back(std::pair<TH1*, TH1*>(0, 0));
        m_namedIndices[single_name] = m_named.size()-1;
      }
    }
  }
  else if (! cnt->GetValue(name.c_str())){
    std::cerr << "CalibrationDataEigenVariations::excludeNamedUncertainty error:" << " uncertainty named " << name << " not found" << std::endl;
  } 
}

getEigenCovarianceMatrix()

TMatrixDSym CalibrationDataEigenVariations::getEigenCovarianceMatrix ( )

virtual

also provide (some) access to the underlying information: covariance matrix corresponding to eigenvector variations

Reimplemented in Analysis::CalibrationDataGlobalEigenVariations, and CalibrationDataGlobalEigenVariations.

Definition at line 416 of file CalibrationDataEigenVariations.cxx.

{
  // Construct the covariance matrix that is to be diagonalised.
  // Note that extrapolation uncertainties (identified by the keyword "extrapolation,
  // this will pertain mostly to the extrapolation to high jet pt) are always excluded
  // since by definition they will not apply to the normal calibration bins. Instead
  // this uncertainty has to be dealt with as a named variation. In addition there are
  // other items ("combined", "systematics") that will not be dealt with correctly
  // either and hence are excluded as well).
  //
  // Note that if an explicit covariance matrix is supplied (at present this may be
  // the case only for statistical uncertainties: in the case of "continuous tagging",
  // multinomial statistics applies so bin-to-bin correlations exist) this will be
  // used instead of constructing the statistical uncertainties' covariance matrix on
  // the fly.
 
  // retrieve the central calibration
  TH1* result = dynamic_cast<TH1*>(m_cnt->GetValue("result"));
  if (not result){
    std::cerr<<"CalibrationDataEigenVariations::getEigenCovarianceMatrix(): failed dynamic cast to TH1*\n";
    return  TMatrixDSym();
  }
 
  // loop over the uncertainties to construct the covariance matrix for all uncertainties
  // to be addressed using the eigenvector method.
 
  // First, treat the statistics separately.
  // Account for the possibility that this is handled as a (non-trivial) covariance matrix
  TMatrixDSym* sCov = dynamic_cast<TMatrixDSym*>(m_cnt->GetValue("statistics"));
 
  // Alternatively, statistical uncertainties may be accounted for as variations (i.e., much like systematic uncertainties).
  // In that case, we create a null matrix here and add the statistical contributions along with the systematic ones.
  TMatrixDSym cov = (sCov) ? *sCov : getStatCovarianceMatrix(result, m_statVariations);
 
  // Then loop through the list of (other) uncertainties
  std::vector<string> uncs = m_cnt->listUncertainties();
  for (unsigned int t = 0; t < uncs.size(); ++t) {
    // entries that should never be included
    if (uncs[t] == "comment" || uncs[t] == "result" || uncs[t] == "combined" || 
        uncs[t] == "statistics" || uncs[t] == "systematics" || uncs[t] == "MCreference" || 
        uncs[t] == "MChadronisation" || uncs[t] == "extrapolation" || uncs[t] == "ReducedSets" || 
        uncs[t] == "excluded_set") continue;
    // entries that can be excluded if desired
    if (m_namedIndices.find(uncs[t]) != m_namedIndices.end()) continue;
    TH1* hunc = dynamic_cast<TH1*>(m_cnt->GetValue(uncs[t].c_str()));
    if (not hunc){
      std::cerr<< "CalibrationDataEigenVariations::getEigenCovarianceMatrix(): dynamic cast failed\n";
      continue;
    }
    cov += getSystCovarianceMatrix(result, hunc, m_cnt->isBinCorrelated(uncs[t]), m_cnt->getTagWeightAxis()); // <-------- This is where we add the covariance matrices together to form the "total covariance"
  }
 
  return cov;
}

getEigenCovarianceMatrixFromVariations()

TMatrixDSym CalibrationDataEigenVariations::getEigenCovarianceMatrixFromVariations

(

)

covariance matrix corresponding to eigenvector variations constructed from the eigen-variation

Definition at line 473 of file CalibrationDataEigenVariations.cxx.

{
  // Construct the (Eigen-variation part of the) covariance matrix from the individual variations.
  // This must be called _after_ initialize()!
 
  // retrieve the central calibration
  TH1        *result = dynamic_cast<TH1*>(m_cnt->GetValue("result")); 
  TMatrixD    jac = getJacobianReductionMatrix();
  int         nbins = jac.GetNcols();
  TMatrixDSym cov(nbins);
  auto variation = std::make_unique<double[]>(nbins);
 
  for (const std::pair<TH1*, TH1*>& it : m_eigen){ // m_eigen is vector of pairs of TH1* which point to TH1's representing the upVariation and downVariation respectively
    TH1* resultVariedUp = it.first; // <--------------- This is the "result" but "varied" upwards - i.e. how the result would look like if the systematic "it" was imposed
    for (unsigned int u = 0; u < (unsigned int) nbins; ++u) variation[u] = resultVariedUp->GetBinContent(u) - result->GetBinContent(u);
    for (int u = 0; u < nbins; ++u){ 
      for (int v = 0; v < nbins; ++v){
        cov(u, v) += variation[u]*variation[v];
      }
    }
  }
 
  return cov;
}

getEigenvectorVariation()

bool CalibrationDataEigenVariations::getEigenvectorVariation	(	unsigned int	variation,
		TH1 *&	up,
		TH1 *&	down )

obtain the "up" and "down" variations for the given eigenvector number.

The return value will be false if the eigenvector number is invalid.

Definition at line 1018 of file CalibrationDataEigenVariations.cxx.

{
  // Return the pointers to the up- and downward variation histogram for the specified
  // eigenvector variation. In case of an invalid variation number, null pointers will
  // be returned and the return value will be false.
  //
  //     variation:   eigenvector variation number
  //     up:          (reference to) pointer to upward variation histogram
  //     down:        (reference to) pointer to downward variation histogram
 
  if (! m_initialized) initialize();
  
  if (variation < m_eigen.size()) {
    up   = m_eigen[variation].first;
    down = m_eigen[variation].second;
    return true;
  }
 
  up = down = 0;
  return false;
}

getJacobianReductionMatrix()

TMatrixD CalibrationDataEigenVariations::getJacobianReductionMatrix

(

)

matrix to remove unecessary rows and columns from covariance

Definition at line 500 of file CalibrationDataEigenVariations.cxx.

{
  // Construct the matrix that removes the rows and columns that fail to influence
  // the eigen-variations. To reduce the covariance matrix, do the following:
  // 
  // TMatrixDSym cov = getEigenCovarianceMatrix();
  // TMatrixDSym jac = getJacobianReductionMatrix(); // <------------ This is an upper triangular matrix of 1's. Similarity transformation will do...
  // TMatrixDSym redSystematicCovMatrix = cov.Similarity(jac);
 
  // retrieve the central calibration
  TH1* result = dynamic_cast<TH1*>(m_cnt->GetValue("result"));
  if (not result){
    std::cerr<<"CalibrationDataEigenVariations::getJacobianReductionMatrix(): dynamic cast failed\n";
    return TMatrixD();
  }
 
  // loop over the uncertainties to construct the covariance matrix for all uncertainties
  // to be addressed using the eigenvector method.
 
  // Retrieve the un-compressed Eigenvector variation covariance matrix
  // (only needed to check for unexpected singularities)
  TMatrixDSym cov = getEigenCovarianceMatrix();
 
  // Compute the original number of bins
  int nbins = result->GetNbinsX()+2;
  int ndim  = result->GetDimension();
  if (ndim > 1) nbins*= (result->GetNbinsY()+2);
  if (ndim > 2) nbins*= (result->GetNbinsZ()+2);
 
  // Start by "compressing" the covariance matrix (removing columns/rows containing zeros only)
  int nZeros=0;
  std::vector<int> zeroComponents;
  if (cov.GetNrows() != nbins) {
    std::cerr << " error: covariance matrix size (" << cov.GetNrows() << ") doesn't match histogram size (" << nbins << ")" << std::endl;
    return TMatrixDSym();
  }
 
  // First flag all the zeros
  for (int i = 0; i < nbins; ++i) {
    // Directly identify the under- and overflow bins
    Int_t binx, biny, binz;
    result->GetBinXYZ(i, binx, biny, binz);
    if ((binx == 0 || binx == result->GetNbinsX()+1) || 
       (ndim > 1 && (biny == 0 || biny == result->GetNbinsY()+1)) || 
       (ndim > 2 && (binz == 0 || binz == result->GetNbinsZ()+1))) 
    {
      ++nZeros;
      zeroComponents.push_back(i);
    }
    // Try a first (quick) identification of rows/columns of zeros by the first element in each row
    // If "successful", check the whole row in more detail
    else if (fabs(cov(i,0)) < 1e-10) {
      bool isThereANonZero(false);
      for (int j = 0; j < nbins; ++j) {
        if (fabs(cov(i,j)) > 1e-10) {
          isThereANonZero=true; break;
        }
      }
      if (! isThereANonZero) {
        ++nZeros;
        zeroComponents.push_back(i);
      }
    }
  }
 
  // **** COMMENTED OUT FOR NOW. 
  // Leave it here in case the calibration method will change again in the future. 
  // No need to reweight the SF by the efficiency of that bin (MCreference always = 0)
 
  // Determine whether the container is for "continuous" calibration.
  // This is important since the number of independent scale factors (for each pt or eta bin)
  // is reduced by 1 compared to the number of tag weight bins (related to the fact that the fractions
  // of events in tag weight bins have to sum up to unity).
  // int axis = m_cnt->getTagWeightAxis();
  // bool doContinuous = false;  unsigned int weightAxis = 0;
 
  // if (axis >= 0) {
  //   doContinuous = true;
  //   // weightAxis = (unsigned int) axis;
  //   // In this case, verify that the special "uncertainty" entry that is in fact the reference MC tag
  //   // weight fractions is present. These tag weight fractions are needed in order to carry out the
  //   // diagonalisation successfully.
  //   if (! dynamic_cast<TH1*>(m_cnt->GetValue("MCreference"))) {
  //     std::cerr << " Problem: continuous calibration object found without MC reference tag weight histogram " << std::endl;
  //     return TMatrixDSym();
  //   }
  // }
 
  // Only relevant for continuous calibration containers, but in order to void re-computation we
  // retrieve them here
  // Int_t nbinx = result->GetNbinsX()+2, nbiny = result->GetNbinsY()+2, nbinz = result->GetNbinsZ()+2;
 
  // // If we are indeed dealing with a "continuous" calibration container, ignore one tag weight row
  // const int skipTagWeightBin = 1; // NB this follows the histogram's bin numbering
  // if (doContinuous) {
  //   for (Int_t binx = 1; binx < nbinx-1; ++binx)
  //     for (Int_t biny = 1; biny < nbiny-1; ++biny)
  //       for (Int_t binz = 1; binz < nbinz-1; ++binz) {
  //         if ((weightAxis == 0 && binx == skipTagWeightBin) ||
  //             (weightAxis == 1 && biny == skipTagWeightBin) ||
  //             (weightAxis == 2 && binz == skipTagWeightBin)) {
  //           // At this point we simply add these to the 'null' elements
  //           ++nZeros;
  //           zeroComponents.push_back(result->GetBin(binx, biny, binz));
  //         }
  //       }
  // }
 
  if (nZeros >= nbins) {
    std::cerr << " Problem. Found n. " << nZeros << " while size of matrix is " << nbins << std::endl;
    return TMatrixDSym();
  }
 
  int size = nbins - nZeros; // <--- Tis the size of the matrix removing zeros from the covariance matrix
 
  TMatrixT<double> matrixVariationJacobian(size,nbins);
  int nMissed=0;
  for (int i = 0; i < nbins; ++i) { //full size
    bool missed=false;
    for (unsigned int s = 0; s < zeroComponents.size(); ++s) { // <-------- Basically what this does is it flags "missed" for a given "i" of the full bin size
      if (zeroComponents.at(s) == i) {                        //  <-------- if "i" is in "zeroComponents". Breaks (because it found that it's to be missed)
        missed = true;
        break;
      }
    }
    if (missed) {                                       //        <-------- Finally, if "i" is to be missed, increase "nMissed" by one, and....
      ++nMissed;
      continue; 
    }
    matrixVariationJacobian(i-nMissed,i)=1;         //            <-------- ... this ALWAYS adds a one. If zero "nMissed", add to diagonal. otherwise off-diagonal
  }                                                //             <-------- This matrix only add 1's on/off diagonal, upper triangular matrix
 
  return matrixVariationJacobian;
}

getNamedVariation() [1/2]

bool CalibrationDataEigenVariations::getNamedVariation	(	const std::string &	name,
		TH1 *&	up,
		TH1 *&	down )

obtain the "up" and "down" variations for the named uncertainty.

The return value will be false if the given name is not listed as being excluded from the eigenvector calculations.

Definition at line 1043 of file CalibrationDataEigenVariations.cxx.

{
  // Return the pointers to the up- and downward variation histogram for the specified
  // named variation. In case of an invalid named variation, null pointers will
  // be returned and the return value will be false.
  //
  //     name:        named variation
  //     up:          (reference to) pointer to upward variation histogram
  //     down:        (reference to) pointer to downward variation histogram
 
  map<string, unsigned int>::const_iterator it = m_namedIndices.find(name);
  if (it != m_namedIndices.end()) return getNamedVariation(it->second, up, down);
 
  up = down = 0;
  return false;
}

getNamedVariation() [2/2]

bool CalibrationDataEigenVariations::getNamedVariation	(	unsigned int	nameIndex,
		TH1 *&	up,
		TH1 *&	down )

obtain the "up" and "down" variations for the source uncertainty pointed to by the given index (which is assumed to correspond to the value retrieved using getNamedVariationIndex()).

The return value will be false if the index is out of bounds.

Definition at line 1063 of file CalibrationDataEigenVariations.cxx.

{
  // Return the pointers to the up- and downward variation histogram for the specified
  // named variation. In case of an invalid named variation number, null pointers will
  // be returned and the return value will be false.
  //
  //     nameIndex:   named variation number
  //     up:          (reference to) pointer to upward variation histogram
  //     down:        (reference to) pointer to downward variation histogram
 
  if (! m_initialized) initialize();
 
  if (nameIndex < m_named.size()) {
    up   = m_named[nameIndex].first;
    down = m_named[nameIndex].second;
    return true;
  }
 
  up = down = 0;
  return false;
}

getNamedVariationIndex()

unsigned int CalibrationDataEigenVariations::getNamedVariationIndex

(

const std::string &

name

)

const

retrieve the integer index corresponding to the named variation.

This can be used to speed up computations by avoiding string comparisons. Note that this function is not protected against passing an invalid name.

Definition at line 1088 of file CalibrationDataEigenVariations.cxx.

{
  // Return the integer index corresponding to the named variation.
  // Note that no checks are made on the validity of the name provided.
 
  map<string, unsigned int>::const_iterator it = m_namedIndices.find(name);
  return it->second;
}

getNumberOfEigenVariations()

unsigned int CalibrationDataEigenVariations::getNumberOfEigenVariations

(

)

retrieve the number of eigenvector variations

Definition at line 1010 of file CalibrationDataEigenVariations.cxx.

{
  if (! m_initialized) initialize();
  return m_eigen.size();
}

getNumberOfNamedVariations()

unsigned int CalibrationDataEigenVariations::getNumberOfNamedVariations

(

)

const

retrieve the number of named variations

Definition at line 988 of file CalibrationDataEigenVariations.cxx.

{
  // Returns the number of named variations
 
  return m_namedIndices.size();
}

initialize()

void CalibrationDataEigenVariations::initialize ( double min_variance = 1.0E-20 )

virtual

carry out the eigenvector computations.

Exclusion of any source of uncertainty has to be done before calling this method

Reimplemented in Analysis::CalibrationDataGlobalEigenVariations, and CalibrationDataGlobalEigenVariations.

Definition at line 637 of file CalibrationDataEigenVariations.cxx.

{
  // This is this class's most important method, in the sense that it does all the
  // math and constructs all "variation" histograms (for both eigenvector and named
  // named variations). This constitutes the full initialisation of the class.
  // This method is meant to be called only after all calls (if any) to the
  // CalibrationDataEigenVariations::excludeNamedUncertainty() method.
 
  // retrieve the central calibration
  TH1* result = dynamic_cast<TH1*>(m_cnt->GetValue("result"));
  if (not result){
    std::cerr<<"CalibrationDataEigenVariations::initialize: dynamic cast failed\n";
    return;
  }
  // First step: construct the original covariance matrix
  TMatrixDSym cov = getEigenCovarianceMatrix();
  TMatrixDSym corr(result->GetNbinsX()*result->GetNbinsY()*result->GetNbinsZ()); // We want to construct the correlation matrix in order to compare the final eigenvariations correlation matrix to it  
 
  int rowc = 0;
  for (int row = 0 ; row < cov.GetNrows() ; row++){
    int colc = 0; 
    bool colb = false;
    for (int col = 0 ; col < cov.GetNcols() ; col++){
      if(!cov(row,col) || !cov(row,row) || !cov(col,col) || cov(row,row)<1.0e-6 || cov(col,col)<1.0e-6 ) continue; // really don't want to divide by zero...
      colb=true;
      long double rowvar = sqrt(cov(row,row));
      long double colvar = sqrt(cov(col,col));
      corr(rowc,colc) = cov(row,col)/(rowvar * colvar); // divide each element by the variance
      colc++;
    }
    if (colb){
      rowc++;
    }
  }
 
  // Second step: create the variations for the named sources of uncertainty (easy...)
  for (map<string, unsigned int>::iterator it = m_namedIndices.begin(); it != m_namedIndices.end(); ++it) {
    pair<TH1*, TH1*>& p = m_named[it->second];
    TH1* hunc = (TH1*) m_cnt->GetValue(it->first.c_str());
    TString namedvar("namedVar");
    namedvar += it->first.c_str();
    TString namedvarUp(namedvar);   namedvarUp   += "_up";
    TString namedvarDown(namedvar); namedvarDown += "_down";
    TH1* resultVariedUp   = (TH1*)result->Clone(namedvarUp);   resultVariedUp->Add(hunc, 1.0);    resultVariedUp->SetDirectory(0);
    TH1* resultVariedDown = (TH1*)result->Clone(namedvarDown); resultVariedDown->Add(hunc, -1.0); resultVariedDown->SetDirectory(0);
    p.first  = resultVariedUp;
    p.second = resultVariedDown;
  }
  // Refinement: add the "extrapolation" uncertainty as a named uncertainty, if the histogram is provided
  // This is a bit special, since the extrapolation uncertainty histogram has a different size than other histograms
  if (TH1* hunc = (TH1*) m_cnt->GetValue("extrapolation")) { // this is just saying "if it exists"...
    TH1* resultVariedUp   = (TH1*) hunc->Clone("extrapolation_up");   resultVariedUp->SetDirectory(0);
    TH1* resultVariedDown = (TH1*) hunc->Clone("extrapolation_down"); resultVariedDown->SetDirectory(0);
    Int_t nbinx = hunc->GetNbinsX()+2, nbiny = hunc->GetNbinsY()+2, nbinz = hunc->GetNbinsZ()+2;
    Int_t firstbinx = hunc->GetXaxis()->FindFixBin(result->GetXaxis()->GetBinCenter(1));
    Int_t firstbiny = result->GetDimension() > 1 ? hunc->GetYaxis()->FindFixBin(result->GetYaxis()->GetBinCenter(1)) : 1;
    Int_t firstbinz = result->GetDimension() > 2 ? hunc->GetZaxis()->FindFixBin(result->GetZaxis()->GetBinCenter(1)) : 1;
    for (Int_t binx = 1; binx < nbinx-1; ++binx) {
      Int_t binxResult = binx - firstbinx + 1;
      if (binxResult < 1) binxResult = 1;
      if (binxResult > result->GetNbinsX()) binxResult = result->GetNbinsX();
      for (Int_t biny = 1; biny < nbiny-1; ++biny) {
        Int_t binyResult = biny - firstbiny + 1;
        if (binyResult > result->GetNbinsY()) binyResult = result->GetNbinsY();
        for (Int_t binz = 1; binz < nbinz-1; ++binz) {
          Int_t binzResult = binz - firstbinz + 1;
          if (binzResult > result->GetNbinsZ()) binzResult = result->GetNbinsZ();
          Int_t bin = hunc->GetBin(binx, biny, binz);
          double contResult = result->GetBinContent(binxResult, binyResult, binzResult);
          resultVariedUp->SetBinContent(bin, contResult + hunc->GetBinContent(bin));
          resultVariedDown->SetBinContent(bin, contResult - hunc->GetBinError(bin));
        }
      }
    }
    m_named.push_back(std::make_pair(resultVariedUp, resultVariedDown));
    m_namedExtrapolation = m_namedIndices["extrapolation"] = m_named.size()-1;
  }
 
  // Third step: compute the eigenvector variations corresponding to the remaining sources of uncertainty
  int nbins = result->GetNbinsX()+2;
  int ndim  = result->GetDimension();
  if (ndim > 1) nbins*= (result->GetNbinsY()+2);
  if (ndim > 2) nbins*= (result->GetNbinsZ()+2);
 
 
  // // Determine whether the container is for "continuous" calibration.
  // // This is important since the number of independent scale factors (for each pt or eta bin)
  // // is reduced by 1 compared to the number of tag weight bins (related to the fact that the fractions
  // // of events in tag weight bins have to sum up to unity).
  //  int axis = m_cnt->getTagWeightAxis();
  // bool doContinuous = false; unsigned int weightAxis = 0;
 
  //if (axis >= 0) {
  //   doContinuous = true;
  //   weightAxis = (unsigned int) axis;
  //   // In this case, verify that the special "uncertainty" entry that is in fact the reference MC tag
  //   // weight fractions is present. These tag weight fractions are needed in order to carry out the
  //   // diagonalisation successfully.
  //    NOTE: MCreference is not used at the moment (always 0 in the CDI). Comment it out. 
  //    if (! dynamic_cast<TH1*>(m_cnt->GetValue("MCreference"))) {
  //   std::cerr << " Problem: continuous calibration object found without MC reference tag weight histogram " << std::endl;
  //  return;
  // }
  //}
 
  // Only relevant for continuous calibration containers, but in order to void re-computation we
  // retrieve them here
  // Int_t nbinx = result->GetNbinsX()+2, nbiny = result->GetNbinsY()+2, nbinz = result->GetNbinsZ()+2;
 
  TMatrixT<double> matrixVariationJacobian = getJacobianReductionMatrix();
  int size = matrixVariationJacobian.GetNrows();
 
  // Reduce the matrix to one without the zeros, using a "similarity" transformation
 
  const TMatrixDSym matrixCovariance = cov.Similarity(matrixVariationJacobian); 
 
  // Carry out the Eigenvector decomposition on this matrix
  TMatrixDSymEigen eigenValueMaker (matrixCovariance);
  TVectorT<double> eigenValues   = eigenValueMaker.GetEigenValues(); 
  TMatrixT<double> eigenVectors  = eigenValueMaker.GetEigenVectors(); 
  TMatrixT<double> matrixVariations (size,size); 
 
  //compute the total variance by summing the eigenvalues
  m_totalvariance = eigenValues.Sum(); //
 
  for (int i = 0; i < size; ++i) {
    //now go back
    for (int r = 0; r < size; ++r)
      //first index is the variation number, second corresponds to the pT bin      //<--------- The "eigenvariations" matrix is the "C" matrix which has CKC^T = I with "K" being the o.g. covariance matrix, and "I" is the identity
      matrixVariations(i,r) = -1.0*eigenVectors[r][i]*sqrt(fabs(eigenValues[i])); // <--------- So the result is a matrix (eigenvariation) which is the eigenvector scaled by the sqrt(eigenvalue)
  } // <------- matrixVariations: each row is one variation, each column is the pT bin.
 
  TMatrixT<double> matrixVariationsWithZeros = matrixVariations * matrixVariationJacobian;
 
  // Construct the initial set of variations from this
  for (int i = 0; i < matrixVariationsWithZeros.GetNrows(); ++i) {
    // TString superstring(result->GetName());
    // superstring += "_eigenVar";
    TString superstring("eigenVar");
    superstring+=i;
 
    TString nameUp(superstring);   nameUp   += "_up";
    TString nameDown(superstring); nameDown += "_down";
    // TString nameUnc(superstring);  nameUnc+= "_unc";
 
    TH1* resultVariedUp   = (TH1*)result->Clone(nameUp);   resultVariedUp->SetDirectory(0); // <------- clone "result" hist, call it "up", and SetDirectory(0) means histogram doesn't belong to any directory.
    TH1* resultVariedDown = (TH1*)result->Clone(nameDown); resultVariedDown->SetDirectory(0);
 
    for (int u = 0; u < nbins; ++u) {
      resultVariedUp->SetBinContent(u,result->GetBinContent(u) + matrixVariationsWithZeros(i,u)); // <----- This actually constructs the up-variation histogram!
      resultVariedDown->SetBinContent(u,result->GetBinContent(u) - matrixVariationsWithZeros(i,u)); // <--- This likewise constructs the down-var., bin-by-bin.
    }
 
    m_eigen.push_back(std::make_pair(resultVariedUp, resultVariedDown));
 
  } //end eigenvector size
 
  // Remove variations that are below the given tolerance (effectively meaning that they don't have any effect) // <--------- Here we prune systematics
  IndexSet final_set; // <-------- What's IndexSet? It's a typedef of std::set<size_t>, where size_t = int
  size_t current_set = 0;
  for (size_t index = 0; index < m_eigen.size(); ++index) {
    bool keep_variation = false;
    TH1 *up = static_cast<TH1*>(m_eigen[index].first->Clone()); up->SetDirectory(0);
 
    up->Add(result, -1.0);
 
    for (int bin = 1; bin <= nbins; ++bin) {
      if (fabs(up->GetBinContent(bin)) > min_variance) { // <----- If you find even ONE bin with big enough variance, we keep the whole systematic.
        keep_variation = true;
        break;
      }
    }
    delete up;
    if (!keep_variation){ // <------ At this stage, if we find no bins in the systematic with large enough variation, we insert it to "final_set" for removal/pruning
      final_set.insert(current_set);
    } else {
      m_capturedvariance += eigenValues[index]; // let's add up the variance that the eigenvariation contributes to the total
    }
    ++current_set;
  }
  if (final_set.size() > 0) 
    if (m_verbose) std::cout << "CalibrationDataEigenVariations: Removing " << final_set.size() << " eigenvector variations leading to sub-tolerance effects, retaining " << m_eigen.size()-final_set.size() << " variations" << std::endl;
  
  removeVariations(final_set); // <----------------- This method actually performs the reduction. The above logic simply flags which variations to GET RID OF, inserting them into "final_set"
 
  if (m_verbose) std::cout << " The total variance is " << m_totalvariance << " and the reduction captured " << 100*(m_capturedvariance/m_totalvariance) << "% of this." << std::endl;
  if (m_validate){ // <---- this flag can be set manually in a local checkout of this package (temporary fix)
    validate_reduction(cov.GetNrows(), corr, m_eigen, result, "SFEigen", m_taggername, m_wp, m_jetauthor); // <------ This method is simply here to report the matrix comparison, for reduction scheme validation
  }
 
  m_initialized = true;
}

isExtrapolationVariation()

bool CalibrationDataEigenVariations::isExtrapolationVariation

(

unsigned int

nameIndex

)

const

flag whether the given index corresponds to an extrapolation variation

Definition at line 1099 of file CalibrationDataEigenVariations.cxx.

{
  // Verifies whether the given named variation index corresponds to the extrapolation
  // uncertainty.
 
  return (m_namedExtrapolation == int(nameIndex));
}

listNamedVariations()

vector< string > CalibrationDataEigenVariations::listNamedVariations

(

)

const

list the named variations

Definition at line 997 of file CalibrationDataEigenVariations.cxx.

{
  // Provides the list of named variations
 
  vector<string> names;
  for (map<string, unsigned int>::const_iterator it = m_namedIndices.begin(); it != m_namedIndices.end(); ++it){
    names.push_back(it->first);
  }
  return names;
}

mergeVariations() [1/2]

void CalibrationDataEigenVariations::mergeVariations

(

const IndexSet &

set

)

merge all variations in the given set

Definition at line 877 of file CalibrationDataEigenVariations.cxx.

{
  IndexSuperSet sset;
  sset.insert(set);
  mergeVariations(sset);
}

mergeVariations() [2/2]

void CalibrationDataEigenVariations::mergeVariations

(

const IndexSuperSet &

set

)

merge all variations in any of the given sets

Definition at line 886 of file CalibrationDataEigenVariations.cxx.

{
  // check for overlap
  IndexSet checker;
  for (IndexSuperSet::iterator set_it = set.begin(); set_it != set.end(); ++set_it) {
    for (IndexSet::iterator subset_it = set_it->begin(); subset_it != set_it->end(); ++subset_it){
      if (checker.count(*subset_it) == 0 && *subset_it <= m_eigen.size())
        checker.insert(*subset_it);
      else {
        std::cerr << "Error in CalibrationDataEigenVariations::mergeVariations: \
          IndexSets must not overlap and must lie between 1 and " << m_eigen.size() << ". Aborting!" << std::endl;
        return;
      }
    }
  }
 
  // retrieve the central calibration
  TH1 *result = static_cast<TH1*>(m_cnt->GetValue("result"));
  IndexSet toDelete;
  int nbins = result->GetNbinsX()+2;
  int ndim  = result->GetDimension();
  if (ndim > 1) nbins *= (result->GetNbinsY()+2);
  if (ndim > 2) nbins *= (result->GetNbinsZ()+2);
 
  // TH1 *var_up_final = static_cast<TH1*>(result->Clone()),
  //   *var_down_final = static_cast<TH1*>(result->Clone());
 
  // var_up_final->Reset();
  // var_down_final->Reset();
 
  // complex sum
  for (IndexSuperSet::iterator set_it = set.begin(); set_it != set.end(); ++set_it) {
    if (set_it->empty()) continue;
 
    double sum_H_up = 0.0, sum_H_down = 0.0;
    size_t lowest_index = *set_it->lower_bound(0);
    TH1 *total_var_up = static_cast<TH1*>(m_eigen[lowest_index].first->Clone()),
      *total_var_down = static_cast<TH1*>(m_eigen[lowest_index].second->Clone());
    total_var_up->SetDirectory(0);
    total_var_down->SetDirectory(0);
 
    total_var_up->Reset();
    total_var_down->Reset();
 
    // sum all other variations
    for (IndexSet::iterator subset_it = set_it->begin();
     subset_it != set_it->end(); ++subset_it) {
      size_t actual_index = *subset_it;
 
      if (actual_index != lowest_index) toDelete.insert(*subset_it);
 
      TH1 *partial_var_up = static_cast<TH1*>(m_eigen[actual_index].first->Clone()),
    *partial_var_down = static_cast<TH1*>(m_eigen[actual_index].second->Clone());
      partial_var_up->SetDirectory(0);
      partial_var_down->SetDirectory(0);
      
      partial_var_up->Add(result, -1.0); // <----- Is this correct? Should it be +1?
      partial_var_down->Add(result, -1.0);
      for (int i = 0; i < nbins; ++i) {
        partial_var_down->SetBinContent(i, -1.0*partial_var_down->GetBinContent(i));
      }
 
      for (int u = 0; u < nbins; ++u) {
        double sum_up = total_var_up->GetBinContent(u),
      sum_down = total_var_down->GetBinContent(u);
        for (int v = 0; v < nbins; ++v) {
          sum_up += partial_var_up->GetBinContent(u)*partial_var_up->GetBinContent(v);
          sum_H_up += partial_var_up->GetBinContent(u)*partial_var_up->GetBinContent(v);
          sum_down += partial_var_down->GetBinContent(u)*partial_var_down->GetBinContent(v);
          sum_H_down += partial_var_down->GetBinContent(u)*partial_var_down->GetBinContent(v);
        }
        total_var_up->SetBinContent(u, sum_up);
        total_var_down->SetBinContent(u, sum_down);
      }
      delete partial_var_up;
      delete partial_var_down;
    }
 
    // final part of complex summing
    for (int i = 0; i < nbins; ++i) {
      if (sum_H_up != 0.0)
        total_var_up->SetBinContent(i, total_var_up->GetBinContent(i)/sqrt(sum_H_up));
      else
        total_var_up->SetBinContent(i, 0.0);
      if (sum_H_down != 0.0)
        total_var_down->SetBinContent(i, -1.0*total_var_down->GetBinContent(i)/sqrt(sum_H_down));
      else
        total_var_down->SetBinContent(i, 0.0);
    }
 
    total_var_up->Add(result);
    total_var_down->Add(result);
 
    m_eigen[lowest_index].first = total_var_up;
    m_eigen[lowest_index].second = total_var_down;
  }
 
  removeVariations(toDelete);
}

mergeVariationsFrom()

void CalibrationDataEigenVariations::mergeVariationsFrom

(

const size_t &

index

)

merge all variations starting from the given index

Definition at line 863 of file CalibrationDataEigenVariations.cxx.

{
  // Merge all systematic variation starting from the given index.
  // The resulting merged variation replaces the first entry in the list
  // (i.e., the entry specified by the index).
  IndexSet simple_set;
 
  for (size_t it = index; it < m_eigen.size(); ++it)
    simple_set.insert(it);
  mergeVariations(simple_set);
}

removeVariations() [1/2]

void CalibrationDataEigenVariations::removeVariations

(

const IndexSet &

set

)

remove all variations in the given set

Definition at line 835 of file CalibrationDataEigenVariations.cxx.

{
  if (set.size() == 0) return;
 
  std::vector<std::pair<TH1*, TH1*> > new_eigen;
  for (size_t index = 0; index < m_eigen.size(); ++index){
      if (set.count(index) == 0) new_eigen.push_back(m_eigen[index]);
      else { delete m_eigen[index].first; delete m_eigen[index].second; }
    }
  m_eigen = std::move(new_eigen);
}

removeVariations() [2/2]

void CalibrationDataEigenVariations::removeVariations

(

const IndexSuperSet &

set

)

remove all variations in any of the given sets

Definition at line 849 of file CalibrationDataEigenVariations.cxx.

{
  IndexSet simple_set;
 
  for (IndexSuperSet::iterator set_it = set.begin(); set_it != set.end(); ++set_it) {
    for (IndexSet::iterator subset_it = set_it->begin(); subset_it != set_it->end(); ++subset_it)
      simple_set.insert(*subset_it);
  }
 
  removeVariations(simple_set);
}

setVerbose()

void CalibrationDataEigenVariations::setVerbose

(

bool

verbose

)

Definition at line 1247 of file CalibrationDataEigenVariations.cxx.

                                                            {
  m_verbose = verbose;
}

Member Data Documentation

m_capturedvariance

double Analysis::CalibrationDataEigenVariations::m_capturedvariance

protected

Definition at line 137 of file CalibrationDataEigenVariations.h.

m_cdipath

std::string Analysis::CalibrationDataEigenVariations::m_cdipath

protected

@ data members needed for eigenvector method

the map stores the int which is needed to access the other vector<> objects

Definition at line 129 of file CalibrationDataEigenVariations.h.

m_cnt

CalibrationDataHistogramContainer* Analysis::CalibrationDataEigenVariations::m_cnt

private

container object containing the basic information

Definition at line 100 of file CalibrationDataEigenVariations.h.

m_eigen

std::vector<std::pair<TH1*, TH1*> > Analysis::CalibrationDataEigenVariations::m_eigen

protected

eigenvector variations

Definition at line 116 of file CalibrationDataEigenVariations.h.

m_initialized

bool Analysis::CalibrationDataEigenVariations::m_initialized

protected

flag whether the initialization has been carried out

Definition at line 105 of file CalibrationDataEigenVariations.h.

m_jetauthor

std::string Analysis::CalibrationDataEigenVariations::m_jetauthor

protected

Definition at line 132 of file CalibrationDataEigenVariations.h.

m_named

std::vector<std::pair<TH1*, TH1*> > Analysis::CalibrationDataEigenVariations::m_named

protected

Definition at line 110 of file CalibrationDataEigenVariations.h.

m_namedExtrapolation

int Analysis::CalibrationDataEigenVariations::m_namedExtrapolation

protected

named variation index for the special case of extrapolation uncertainties

Definition at line 113 of file CalibrationDataEigenVariations.h.

m_namedIndices

std::map<std::string, unsigned int> Analysis::CalibrationDataEigenVariations::m_namedIndices

protected

named variations

Definition at line 109 of file CalibrationDataEigenVariations.h.

m_statVariations

bool Analysis::CalibrationDataEigenVariations::m_statVariations

protected

indicate whether statistical uncertainties are stored as variations

Definition at line 119 of file CalibrationDataEigenVariations.h.

m_taggername

std::string Analysis::CalibrationDataEigenVariations::m_taggername

protected

Definition at line 130 of file CalibrationDataEigenVariations.h.

m_totalvariance

double Analysis::CalibrationDataEigenVariations::m_totalvariance

protected

Definition at line 136 of file CalibrationDataEigenVariations.h.

m_validate

bool Analysis::CalibrationDataEigenVariations::m_validate

protected

Definition at line 106 of file CalibrationDataEigenVariations.h.

m_verbose

bool Analysis::CalibrationDataEigenVariations::m_verbose

protected

Definition at line 139 of file CalibrationDataEigenVariations.h.

m_wp

std::string Analysis::CalibrationDataEigenVariations::m_wp

protected

Definition at line 131 of file CalibrationDataEigenVariations.h.

---

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

• CalibrationDataEigenVariations.h
• CalibrationDataEigenVariations.cxx