CaloLCOutOfClusterTool Class Reference

calculates out-of-cluster corrections based on cluster quantities More...

#include <CaloLCOutOfClusterTool.h>

Inheritance diagram for CaloLCOutOfClusterTool:

Collaboration diagram for CaloLCOutOfClusterTool:

Public Member Functions
virtual	~CaloLCOutOfClusterTool ()
virtual StatusCode	weight (xAOD::CaloCluster *theCluster, const EventContext &ctx) const override
virtual StatusCode	initialize () override

Private Attributes
SG::ReadCondHandleKey< CaloLocalHadCoeff >	m_key {this, "CorrectionKey", "OOCCorrection"}
	name of the key for out-of-cluster weights
Gaudi::Property< bool >	m_useEmProbability {this, "UseEmProbability", false}
	look for em-probability moment and apply relative weight only
Gaudi::Property< bool >	m_useHadProbability {this, "UseHadProbability", false}
	look for em-probability moment and apply relative weight only
Gaudi::Property< std::vector< std::string > >	m_invalidSamplingNames
	vector of names of the calorimeter samplings not to use when applying the out-of-cluster weights.
std::set< int >	m_invalidSamplings
	actual set of samplings to be ignored for out-of-cluster weights
Gaudi::Property< bool >	m_interpolate {this, "Interpolate", false}
	interpolate correction coefficients
Gaudi::Property< bool >	m_updateSamplingVars {this, "UpdateSamplingVars", false}
	update also sampling variables
Gaudi::Property< std::vector< std::string > >	m_interpolateDimensionNames
	vector of names of dimensions in look-up tables to interpolate
std::vector< int >	m_interpolateDimensions
	actual set of dimension id's to interpolate

Detailed Description

calculates out-of-cluster corrections based on cluster quantities

Version

$Id: CaloLCOutOfClusterTool.h,v 1.3 2009-01-27 09:09:14 gunal Exp $

Author

Sven Menke menke.nosp@m.@mpp.nosp@m.mu.mp.nosp@m.g.de

Date

2-March-2007

concrete class implementing a IClusterCellWeightTool to calculate the out-of-cluster corrections for topo clusters. The cluster moments and its energy are used to derive the correction

• therefore the correction is not called cell-by-cell, but for the entire cluster This tool reads its data from pool containing TProfile2D based correction data.

Definition at line 27 of file CaloLCOutOfClusterTool.h.

Constructor & Destructor Documentation

~CaloLCOutOfClusterTool()

CaloLCOutOfClusterTool::~CaloLCOutOfClusterTool ( )

virtualdefault

Member Function Documentation

initialize()

StatusCode CaloLCOutOfClusterTool::initialize ( )

overridevirtual

Definition at line 36 of file CaloLCOutOfClusterTool.cxx.

{
  ATH_MSG_INFO( "Initializing " << name()  );
 
  //--- check sampling names to use exclude in correction
  std::vector<std::string>::iterator samplingIter = m_invalidSamplingNames.begin(); 
  std::vector<std::string>::iterator samplingIterEnd = m_invalidSamplingNames.end(); 
  for(; samplingIter!=samplingIterEnd; ++samplingIter) { 
    int theSampling(CaloSampling::Unknown);
    for (unsigned int jsamp = 0;jsamp< CaloSampling::Unknown; jsamp++) {
      if ( *samplingIter == CaloSamplingHelper::getSamplingName((CaloSampling::CaloSample)jsamp)) {
    theSampling = jsamp;
    break;
      }
    }
    if ( theSampling == CaloSampling::Unknown ) {
      msg(MSG::ERROR) << "Calorimeter sampling " 
      << *samplingIter
          << " is not a valid Calorimeter sampling name and will be ignored! "
          << "Valid names are: ";
      for (unsigned int jsamp = 0;jsamp< CaloSampling::Unknown; jsamp++) {
    msg() << CaloSamplingHelper::getSamplingName((CaloSampling::CaloSample)jsamp);
    if ( jsamp < CaloSampling::Unknown-1) 
      msg() << ", ";
    else 
      msg() << ".";
      }
      msg() << endmsg;
    }
    else {
      m_invalidSamplings.insert(theSampling);
    }
  }
 
  msg(MSG::INFO) << "Samplings to exclude from the out-of-cluster weighting:";
  samplingIter = m_invalidSamplingNames.begin(); 
  for(; samplingIter!=samplingIterEnd; ++samplingIter)  
    msg() << " " << *samplingIter;
  msg() << endmsg;
 
  if(m_interpolate) {
    msg(MSG::INFO) << "Interpolation is ON, dimensions: ";
    for(std::vector<std::string>::iterator it=m_interpolateDimensionNames.begin(); it!=m_interpolateDimensionNames.end(); ++it){
      msg() << " " << (*it);
    }
    msg() << endmsg;
    for(std::vector<std::string>::iterator it=m_interpolateDimensionNames.begin(); it!=m_interpolateDimensionNames.end(); ++it){
      CaloLocalHadDefs::LocalHadDimensionId id = CaloLCCoeffHelper::getDimensionId( (*it) );
      if(id!=CaloLocalHadDefs::DIMU_UNKNOWN) {
        m_interpolateDimensions.push_back(int(id));
      }else{
        ATH_MSG_WARNING( "Dimension '" << (*it) << "' is invalid and will be excluded."  );
      }
    }
  }
 
  // callback for conditions data
  ATH_CHECK(  m_key.initialize() );
 
  return StatusCode::SUCCESS;
}

weight()

StatusCode CaloLCOutOfClusterTool::weight ( xAOD::CaloCluster * theCluster, const EventContext & ctx ) const

overridevirtual

Definition at line 98 of file CaloLCOutOfClusterTool.cxx.

{
  double eWeightedOrig = theCluster->e();
  double eWeighted = theCluster->e();
  // get ratio of weighted and em cluster
  double ratio=1.;
  std::vector<float> vars(5);
 
  CaloLCCoeffHelper hp;
 
  double pi0Prob = 0;
  if ( m_useEmProbability || m_useHadProbability) {
    if (!theCluster->retrieveMoment(CaloCluster::EM_PROBABILITY,pi0Prob)) {
      ATH_MSG_WARNING ("Cannot find cluster moment EM_PROBABILITY");
    }
  }
  else if (theCluster->recoStatus().checkStatus(CaloRecoStatus::TAGGEDEM)) {
    pi0Prob = 1.;
  }
  if ( pi0Prob < 0 ) 
    pi0Prob = 0;
  if ( pi0Prob > 1 )
    pi0Prob = 1;
 
  double classifyWeight = 1;
  if ( m_useEmProbability ) {
    classifyWeight = pi0Prob;
  }
  else if ( m_useHadProbability ) {
    classifyWeight = 1-pi0Prob;
  }
  double eEM = theCluster->rawE();
  // basic energy can be 0 if the locking tool option FixBasicEnergy is False
  // in that case simply use the weighted energy ...
  if ( eEM == 0. ) {
    ATH_MSG_DEBUG("Basic Energy is 0. Use weighted energy instead");
    eEM = eWeighted;
  }
  
  
 
  // subtract the samplings to ignore from eEM and eWeighted, assuming that
  // they would not have received any cell weights in prior calibration 
  // steps
  std::set<int>::const_iterator ivSamplingIter = m_invalidSamplings.begin(); 
  std::set<int>::const_iterator ivSamplingIterEnd = m_invalidSamplings.end(); 
  for(; ivSamplingIter!=ivSamplingIterEnd; ++ivSamplingIter) {
    eEM       -= theCluster->eSample((CaloCluster::CaloSample)(*ivSamplingIter));
    eWeighted -= theCluster->eSample((CaloCluster::CaloSample)(*ivSamplingIter));
  }
 
  if ( eEM > 0 && eWeighted > 0 ) {
    // ratio is em energy over weighted energy without the samplings
    // to ignore. This means also the OOC weight tables have to be made 
    // relative to the em energy wihtout the samplings to ignore ...
    ratio = eEM / eWeighted;
 
    if ( ratio < 0.3 || ratio > 3 ) {
      ATH_MSG_DEBUG("The ratio eEM/eWeighted = " 
            << ratio << " is out of normal range [0.3,3]" 
            << " - this mean we have mainly noise ... using 1 instead");
      ratio = 1.0;
    }
    
    double log10cluse = log10(eEM);
 
    SG::ReadCondHandle<CaloLocalHadCoeff> h (m_key,ctx);
    const CaloLocalHadCoeff* data = *h;
    if (!data) {
      ATH_MSG_ERROR("Unable to access conditions object");
      return StatusCode(CaloRecoStatus::TAGGEDUNKNOWN);
    }
 
    const CaloLocalHadCoeff::LocalHadDimension *logeDim = data->getArea(0)->getDimension(2);
    double lemax = logeDim->getXmax()-0.5*logeDim->getDx();
    double lemin = logeDim->getXmin()+0.5*logeDim->getDx();
    if ( log10cluse > lemax ) 
      log10cluse = lemax;
    if ( log10cluse < lemin ) 
      log10cluse = lemin;
 
    double center_lambda,isolation;
    if ( theCluster->retrieveMoment(CaloCluster::ISOLATION,isolation) 
     && theCluster->retrieveMoment(CaloCluster::CENTER_LAMBDA, center_lambda)) {
      if ( isolation > 0 ) {
    if ( center_lambda > 0 ) {
      const double abseta = fabs(theCluster->eta());
      const double log10lambda = log10(center_lambda);
 
      vars[CaloLocalHadDefs::DIMO_SIDE] = static_cast<float> ((theCluster->eta()<0?-1.0:1.0));
      vars[CaloLocalHadDefs::DIMO_PHI] = static_cast<float> (theCluster->phi());
      vars[CaloLocalHadDefs::DIMO_ENER] = static_cast<float> (log10cluse);
      vars[CaloLocalHadDefs::DIMO_ETA] = static_cast<float> (abseta);
      vars[CaloLocalHadDefs::DIMO_LAMBDA] = static_cast<float> (log10lambda);
 
          bool isDataOK = false;
          double oocData(0);
 
          // accessing coefficients (non-interpolated)
          int iBin = data->getBin(0,vars);
          if ( iBin >= 0 ) {
            const CaloLocalHadCoeff::LocalHadCoeff * pData = data->getCoeff(iBin);
            if ( pData && (*pData)[CaloLocalHadDefs::BIN_ENTRIES] > 0 ) {
              isDataOK = true;
              oocData = (*pData)[CaloLocalHadDefs::BIN_WEIGHT];
            }
            if(m_interpolate) {
              // accesing interpolated coefficients
              CaloLocalHadCoeff::LocalHadCoeff parint;
              bool isa = CaloLCCoeffHelper::Interpolate(data, 0,vars,parint, m_interpolateDimensions);
              if(isa && parint[CaloLocalHadDefs::BIN_ENTRIES] > 0) {
                isDataOK = true;
                oocData = parint[CaloLocalHadDefs::BIN_WEIGHT];
              }
            }
          }
 
      ATH_MSG_DEBUG("interpolation_ON=" << m_interpolate
            << "isDataOK="<<isDataOK
            << "side = " << vars[0]
            << ", phi = " << vars[1]
            << ", log10cluse = " << log10cluse
            << ", eta = " << abseta
            << ", log10lambda = " << log10lambda
            << ", ratio = " << ratio
            << ", isol = " << isolation
            << ", oocData = " << oocData);
 
          if(isDataOK){
            const double oocWeight = 1.+classifyWeight*isolation*ratio*oocData;
            // loop over all cells
        CaloCluster::cell_iterator itrCell = theCluster->cell_begin();
            CaloCluster::cell_iterator itrCellEnd = theCluster->cell_end();
            for (;itrCell!=itrCellEnd; ++itrCell) {
              CaloPrefetch::nextDDE(itrCell, itrCellEnd);
              const CaloDetDescrElement* cDDE = itrCell->caloDDE();
              if ( cDDE && !m_invalidSamplings.contains(cDDE->getSampling())) { //Fixme ... could use a bit-pattern
                double weight = itrCell.weight();//theCluster->getCellWeight(itrCell); // fastest!
                weight *= oocWeight;
                // reweight cell in cluster
                theCluster->reweightCell(itrCell,weight);
              } else if (cDDE) {
                ATH_MSG_DEBUG("Exclude cell with sampling = " << cDDE->getSampling());
              }
            }//cell-loop
        CaloClusterKineHelper::calculateKine(theCluster,true,m_updateSamplingVars);
          }
    } // log10lambda
      } // isolation
    } // moments
  }
  
  // assume that the weighting could be called more than once. In that
  // case eWeighted is the result of the previous step and the current
  // e/eWeighted ratio should be multiplied with the existing
  // OOC_WEIGHT moment
  if ( eWeightedOrig > 0 || eWeightedOrig < 0 ) { 
    double old_weight(1);
    if (!theCluster->retrieveMoment(CaloCluster::OOC_WEIGHT,old_weight)) {
      ATH_MSG_ERROR("Cannot retrieve OOC_WEIGHT cluster moment." );
      return StatusCode::FAILURE;
    }
    const double new_weight = old_weight*theCluster->e()/eWeightedOrig;
    theCluster->insertMoment(CaloCluster::OOC_WEIGHT,new_weight); 
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_interpolate

Gaudi::Property<bool> CaloLCOutOfClusterTool::m_interpolate {this, "Interpolate", false}

private

interpolate correction coefficients

Definition at line 80 of file CaloLCOutOfClusterTool.h.

{this, "Interpolate", false};

m_interpolateDimensionNames

Gaudi::Property<std::vector<std::string> > CaloLCOutOfClusterTool::m_interpolateDimensionNames

private

Initial value:

{this
    , "InterpolateDimensionNames"
    , {"DIMO_ENER", "DIMO_ETA", "DIMO_LAMBDA"}
  }

vector of names of dimensions in look-up tables to interpolate

Definition at line 88 of file CaloLCOutOfClusterTool.h.

                                                                  {this
    , "InterpolateDimensionNames"
    , {"DIMO_ENER", "DIMO_ETA", "DIMO_LAMBDA"}
  };

m_interpolateDimensions

std::vector<int> CaloLCOutOfClusterTool::m_interpolateDimensions

private

actual set of dimension id's to interpolate

Definition at line 95 of file CaloLCOutOfClusterTool.h.

m_invalidSamplingNames

Gaudi::Property<std::vector<std::string> > CaloLCOutOfClusterTool::m_invalidSamplingNames

private

Initial value:

{this
    , "InvalidSamplings"
    , {"PreSamplerB", "PreSamplerE", "TileGap3"}
  }

vector of names of the calorimeter samplings not to use when applying the out-of-cluster weights.

The pre-sampler layers (barrel and endcap) and the gap-scintillators should not receive out-of-cluster weights as they mainly deal with dead-material corrections.

Definition at line 66 of file CaloLCOutOfClusterTool.h.

                                                             {this
    , "InvalidSamplings"
    , {"PreSamplerB", "PreSamplerE", "TileGap3"}
  };

m_invalidSamplings

std::set<int> CaloLCOutOfClusterTool::m_invalidSamplings

private

actual set of samplings to be ignored for out-of-cluster weights

This set is created according to the names given in the property m_invalidSamplingNames.

Definition at line 76 of file CaloLCOutOfClusterTool.h.

m_key

SG::ReadCondHandleKey<CaloLocalHadCoeff> CaloLCOutOfClusterTool::m_key {this, "CorrectionKey", "OOCCorrection"}

private

name of the key for out-of-cluster weights

Definition at line 41 of file CaloLCOutOfClusterTool.h.

{this, "CorrectionKey", "OOCCorrection"};

m_updateSamplingVars

Gaudi::Property<bool> CaloLCOutOfClusterTool::m_updateSamplingVars {this, "UpdateSamplingVars", false}

private

update also sampling variables

Definition at line 84 of file CaloLCOutOfClusterTool.h.

{this, "UpdateSamplingVars", false};

m_useEmProbability

Gaudi::Property<bool> CaloLCOutOfClusterTool::m_useEmProbability {this, "UseEmProbability", false}

private

look for em-probability moment and apply relative weight only

The classification provides the probability p for the current cluster to be em-like. OOC weights are applied with the additional em-prob factor p to all clusters for the cases EM and HAD.

Definition at line 49 of file CaloLCOutOfClusterTool.h.

{this, "UseEmProbability", false};

m_useHadProbability

Gaudi::Property<bool> CaloLCOutOfClusterTool::m_useHadProbability {this, "UseHadProbability", false}

private

look for em-probability moment and apply relative weight only

The classification provides the probability p for the current cluster to be em-like. OOC weights are applied with the additional had-prob factor (1-p) to all clusters for the cases EM and HAD.

Definition at line 57 of file CaloLCOutOfClusterTool.h.

{this, "UseHadProbability", false};

---

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

• CaloLCOutOfClusterTool.h
• CaloLCOutOfClusterTool.cxx