CaloLCWeightTool Class Reference

calculates hadronic cell weights based on cluster and cell quantities More...

#include <CaloLCWeightTool.h>

Inheritance diagram for CaloLCWeightTool:

Collaboration diagram for CaloLCWeightTool:

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

Private Attributes
SG::ReadCondHandleKey< CaloLocalHadCoeff >	m_key {this, "CorrectionKey", "HadWeights"}
	name of the key for had cell weights
Gaudi::Property< double >	m_signalOverNoiseCut {this, "SignalOverNoiseCut", 2}
	minimal signal/elec_noise ratio for a cell to be weighted
Gaudi::Property< bool >	m_useHadProbability {this, "UseHadProbability", false}
	look for em-probability moment and apply relative weight only
std::vector< std::string >	m_sampnames
	vector of names of individual samplings
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
const CaloCell_ID *	m_calo_id {}
SG::ReadCondHandleKey< CaloNoise >	m_noiseCDOKey {this,"CaloNoiseKey","electronicNoise","SG Key of CaloNoise data object"}

Detailed Description

calculates hadronic cell weights based on cluster and cell quantities

Version

$Id: CaloLCWeightTool.h,v 1.8 2009-01-27 09:09:14 gunal Exp $

Author

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

Date

26-August-2009

concrete class implementing a IClusterCellWeightTool to calculate the H1-type cell hadronic weights for cells inside a cluster. The cluster moments and its energy are also used to derive the weights

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

Definition at line 32 of file CaloLCWeightTool.h.

Constructor & Destructor Documentation

~CaloLCWeightTool()

CaloLCWeightTool::~CaloLCWeightTool ( )

virtualdefault

Member Function Documentation

initialize()

StatusCode CaloLCWeightTool::initialize ( )

overridevirtual

Definition at line 34 of file CaloLCWeightTool.cxx.

{
  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(MSG::INFO) << " " << (*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."  );
      }
    }
  }
 
  ATH_MSG_INFO( "Initializing " << name()  );
 
  ATH_CHECK( m_key.initialize() );
 
  ATH_CHECK( detStore()->retrieve( m_calo_id, "CaloCell_ID") );
 
  m_sampnames.reserve(CaloSampling::Unknown);
  for (int iSamp=0;iSamp<CaloSampling::Unknown;iSamp++) {
     m_sampnames.push_back(CaloSamplingHelper::getSamplingName((CaloSampling::CaloSample)iSamp));
  }
 
  ATH_CHECK(m_noiseCDOKey.initialize());
 
  return StatusCode::SUCCESS;
}

weight()

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

overridevirtual

Definition at line 68 of file CaloLCWeightTool.cxx.

{
  const CaloLocalHadCoeff* data(nullptr);
  SG::ReadCondHandle<CaloLocalHadCoeff> rch(m_key, ctx);
 
  SG::ReadCondHandle<CaloNoise> noiseHdl{m_noiseCDOKey,ctx};
  const CaloNoise* noiseCDO=*noiseHdl;
 
  data = *rch;
  if(data==nullptr) {
    ATH_MSG_ERROR("Unable to access conditions object");
    return StatusCode::FAILURE;
  }
  // this is not super effective, but try to put is here first, and optimize later
  std::vector<int> isAmpMap(CaloSampling::Unknown,-1);
  for (int iArea=0;iArea<data->getSizeAreaSet();iArea++) {
    for (int iSamp=0;iSamp<CaloSampling::Unknown;iSamp++) {
      if ( m_sampnames[iSamp] == data->getArea(iArea)->getTitle() ) {
        ATH_MSG_DEBUG("Found Area for Sampling " << CaloSamplingHelper::getSamplingName((CaloSampling::CaloSample)iSamp));
        isAmpMap[iSamp] = iArea;
        break;
      }
    }
  }
 
  double eEM = theCluster->e();
 
  std::vector<float> vars(5);
 
  CaloLCCoeffHelper hp;
  CaloLocalHadCoeff::LocalHadCoeff parint;
 
  double pi0Prob = 0;
  if ( m_useHadProbability) {
    if (!theCluster->retrieveMoment(xAOD::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;
 
  if ( eEM > 0 ) {
    // loop over all cells
    
    xAOD::CaloCluster::cell_iterator itrCell = theCluster->cell_begin();
    xAOD::CaloCluster::cell_iterator itrCellEnd = theCluster->cell_end();
    for (;itrCell!=itrCellEnd; ++itrCell) {
      CaloPrefetch::nextDDE(itrCell, itrCellEnd);
      // check calo and sampling index for current cell
      Identifier myId = itrCell->ID();
      CaloCell_ID::CaloSample theSample = CaloCell_ID::CaloSample(m_calo_id->calo_sample(myId));
      if ( isAmpMap[theSample] >= 0 ) {
    double sigma =  noiseCDO->getNoise(itrCell->ID(),itrCell->gain());
    double energy = fabs(itrCell->e());
    double ratio = 0;
    if ( std::isfinite(sigma) && sigma > 0 ) 
      ratio = energy/sigma;
    if ( ratio > m_signalOverNoiseCut ) {
      double volume = 0;
      double density = 0;
          const CaloDetDescrElement* myCDDE = itrCell->caloDDE();
      if ( myCDDE ) {
        volume = myCDDE->volume();
      }
      if ( volume > 0 ) 
        density = energy/volume;
      if ( density > 0 ) {
        double abseta = fabs(itrCell->eta());
        double log10edens = log10(density);
        double log10cluse = log10(eEM);
        const CaloLocalHadCoeff::LocalHadDimension *logeDim = data->getArea(isAmpMap[theSample])->getDimension(3);
        double lemax = logeDim->getXmax()-0.5*logeDim->getDx();
        if ( log10cluse > lemax ) log10cluse = lemax;
 
            vars[CaloLocalHadDefs::DIMW_SIDE] = static_cast<float> ((itrCell->eta()<0?-1.0:1.0));
            vars[CaloLocalHadDefs::DIMW_ETA] = static_cast<float> (abseta);
            vars[CaloLocalHadDefs::DIMW_PHI] = static_cast<float> (itrCell->phi());
            vars[CaloLocalHadDefs::DIMW_ENER] = static_cast<float> (log10cluse);
            vars[CaloLocalHadDefs::DIMW_EDENS] = static_cast<float> (log10edens);
 
            bool isDataOK = false;
            double wData(0);
 
            // accessing coefficients (non-interpolated)
            int iBin = data->getBin(isAmpMap[theSample],vars);
            if ( iBin >= 0 ) {
              const CaloLocalHadCoeff::LocalHadCoeff * pData = data->getCoeff(iBin);
              if ( pData && (*pData)[CaloLocalHadDefs::BIN_ENTRIES] > 10 ) {
                isDataOK = true;
                wData = (*pData)[CaloLocalHadDefs::BIN_WEIGHT];
              }
              if(m_interpolate) {
                // accesing interpolated coefficients
                bool isa = CaloLCCoeffHelper::Interpolate(data, isAmpMap[theSample], vars, parint, m_interpolateDimensions);
                if(isa && parint[CaloLocalHadDefs::BIN_ENTRIES] > 10) {
                  isDataOK = true;
                  wData = parint[CaloLocalHadDefs::BIN_WEIGHT];
                }
              }
            }
 
            if(isDataOK) {
              ATH_MSG_DEBUG(" weight(" 
                << theSample << ", " 
                << vars[0] << ", " 
                << vars[1] << ", " 
                << vars[2] << ", " 
                << vars[3] << ", " 
                << vars[4] << ") = " 
                << wData);
              double weight = itrCell.weight();//theCluster->getCellWeight(itrCell); // fastest!
              weight *= (pi0Prob + (1-pi0Prob)*wData);
              // reweight cell in cluster
              theCluster->reweightCell(itrCell,weight);
            }
      } // density
    } // noise cut
      } // sampling
    } // itrCell
    CaloClusterKineHelper::calculateKine(theCluster,true,m_updateSamplingVars);
  } // eEM
 
  // assume that the weighting could be called more than once. In that case 
  // eEM is the result of the previous step and the current e/eEM ratio
  // should be multiplied with the existing HAD_WEIGHT moment
  double new_weight (1);
  if (!theCluster->retrieveMoment(xAOD::CaloCluster::HAD_WEIGHT,new_weight)) {
    ATH_MSG_ERROR("Cannot retrieve HAD_WEIGHT cluster moment." );
    return StatusCode::FAILURE;
  }
 
  if ( eEM > 0 || eEM < 0 ) {
    new_weight *= theCluster->e()/eEM;
  }
  theCluster->insertMoment(xAOD::CaloCluster::HAD_WEIGHT,new_weight);
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_calo_id

const CaloCell_ID* CaloLCWeightTool::m_calo_id {}

private

Definition at line 88 of file CaloLCWeightTool.h.

{};

m_interpolate

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

private

interpolate correction coefficients

Definition at line 73 of file CaloLCWeightTool.h.

{this, "Interpolate", false};

m_interpolateDimensionNames

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

private

Initial value:

{this, "InterpolateDimensionNames"
    , {"DIMW_ETA", "DIMW_ENER", "DIMW_EDENS"}}

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

Definition at line 81 of file CaloLCWeightTool.h.

                                                                  {this, "InterpolateDimensionNames"
    , {"DIMW_ETA", "DIMW_ENER", "DIMW_EDENS"}};

m_interpolateDimensions

std::vector<int> CaloLCWeightTool::m_interpolateDimensions

private

actual set of dimension id's to interpolate

Definition at line 86 of file CaloLCWeightTool.h.

m_key

SG::ReadCondHandleKey<CaloLocalHadCoeff> CaloLCWeightTool::m_key {this, "CorrectionKey", "HadWeights"}

private

name of the key for had cell weights

Definition at line 45 of file CaloLCWeightTool.h.

{this, "CorrectionKey", "HadWeights"};

m_noiseCDOKey

SG::ReadCondHandleKey<CaloNoise> CaloLCWeightTool::m_noiseCDOKey {this,"CaloNoiseKey","electronicNoise","SG Key of CaloNoise data object"}

private

Definition at line 90 of file CaloLCWeightTool.h.

{this,"CaloNoiseKey","electronicNoise","SG Key of CaloNoise data object"};

m_sampnames

std::vector<std::string> CaloLCWeightTool::m_sampnames

private

vector of names of individual samplings

needed to not call many times CaloSamplingHelper::getSamplingName

Definition at line 69 of file CaloLCWeightTool.h.

m_signalOverNoiseCut

Gaudi::Property<double> CaloLCWeightTool::m_signalOverNoiseCut {this, "SignalOverNoiseCut", 2}

private

minimal signal/elec_noise ratio for a cell to be weighted

Only cells with |energy| above this value times the RMS of the electronics noise are considered in weighting.

Definition at line 52 of file CaloLCWeightTool.h.

{this, "SignalOverNoiseCut", 2};

m_updateSamplingVars

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

private

update also sampling variables

Definition at line 77 of file CaloLCWeightTool.h.

{this, "UpdateSamplingVars", false};

m_useHadProbability

Gaudi::Property<bool> CaloLCWeightTool::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. Hadronic weights are applied with the additional hadronic probablity factor (1-p) to all clusters for the cases EM and HAD.

Definition at line 61 of file CaloLCWeightTool.h.

{this, "UseHadProbability", false} ;

---

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

• CaloLCWeightTool.h
• CaloLCWeightTool.cxx