LArCellNoiseMaskingTool Class Reference

#include <LArCellNoiseMaskingTool.h>

Inheritance diagram for LArCellNoiseMaskingTool:

Collaboration diagram for LArCellNoiseMaskingTool:

Public Member Functions
	LArCellNoiseMaskingTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual StatusCode	process (CaloCellContainer *theCellContainer, const EventContext &ctx) const override

Private Attributes
Gaudi::Property< std::vector< std::string > >	m_problemsToMask
Gaudi::Property< std::vector< std::string > >	m_sporadicProblemsToMask
SG::ReadCondHandleKey< LArBadChannelCont >	m_bcContKey
LArBadChannelMask	m_noiseMask
LArBadChannelMask	m_sporadicNoiseMask
int	m_qualityCut
std::vector< int >	m_caloNums
bool	m_maskNoise
bool	m_maskSporadic

Detailed Description

Definition at line 14 of file LArCellNoiseMaskingTool.h.

Constructor & Destructor Documentation

LArCellNoiseMaskingTool()

LArCellNoiseMaskingTool::LArCellNoiseMaskingTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 27 of file LArCellNoiseMaskingTool.cxx.

  :base_class (type, name, parent),
   m_qualityCut(65536),
   m_maskNoise(true),
   m_maskSporadic(true)
{ 
  declareProperty("qualityCut",m_qualityCut,"Quality cut for sporadic noise channel");
  m_caloNums.clear();
  m_caloNums.push_back( static_cast<int>(CaloCell_ID::LAREM) );
  m_caloNums.push_back( static_cast<int>(CaloCell_ID::LARHEC) );
  m_caloNums.push_back( static_cast<int>(CaloCell_ID::LARFCAL) );
 
}

Member Function Documentation

initialize()

StatusCode LArCellNoiseMaskingTool::initialize ( )

overridevirtual

Definition at line 52 of file LArCellNoiseMaskingTool.cxx.

                                               {
 
  m_maskNoise= not m_problemsToMask.empty();
  m_maskSporadic = not m_sporadicProblemsToMask.empty();
 
  ATH_CHECK(m_bcContKey.initialize(m_maskNoise or m_maskSporadic));
 
  ATH_CHECK(m_noiseMask.buildBitMask(m_problemsToMask,msg()));
  ATH_CHECK(m_sporadicNoiseMask.buildBitMask(m_sporadicProblemsToMask,msg()));
 
  if (m_maskNoise) {
    ATH_MSG_INFO (" Cell masking for noise/dead channels activated");
  }
  else {
    ATH_MSG_INFO (" Cell masking for noise/dead channels not activated ");
  }
 
  if (m_maskSporadic) {
    ATH_MSG_INFO (" Cell masking for sporadic noise activated");
  }
  else {
    ATH_MSG_INFO (" Cell masking for sporadic noise not activated ");
  }
 
  return StatusCode::SUCCESS;
}

process()

StatusCode LArCellNoiseMaskingTool::process ( CaloCellContainer * theCellContainer, const EventContext & ctx ) const

overridevirtual

Definition at line 80 of file LArCellNoiseMaskingTool.cxx.

{
  StatusCode returnSc = StatusCode::SUCCESS ;
 
  if (!m_maskNoise && !m_maskSporadic) return returnSc;
 
  SG::ReadCondHandle<LArBadChannelCont> bcContHdl{m_bcContKey,ctx};
  const LArBadChannelCont* bcCont{*bcContHdl};
 
  for (std::vector<int>::const_iterator itrCalo=m_caloNums.begin();itrCalo!=m_caloNums.end();++itrCalo){
      CaloCell_ID::SUBCALO caloNum=static_cast<CaloCell_ID::SUBCALO>(*itrCalo);
      CaloCellContainer::iterator itrCell=theCont->beginCalo(caloNum);
      CaloCellContainer::iterator itrCellEnd=theCont->endCalo(caloNum);
 
      for (; itrCell!=itrCellEnd;++itrCell){
          CaloCell * aCell=*itrCell;
          Identifier cellId = aCell->ID();
 
          bool toMask = false;
 
// sporadic noise masking using quality cut.   Logic could be improved using neighbour information...
          if (m_maskSporadic) {
              if (aCell->quality() > m_qualityCut) {
        if (m_sporadicNoiseMask.cellShouldBeMasked(bcCont,cellId)) {
          toMask=true;
          ATH_MSG_DEBUG (" Mask sporadic noise cell" << cellId << " E,t,chi2 " << aCell->energy() << " " << aCell->time() << " " << aCell->quality());
        }
              }      
          }
 
// high noise / dead channel masking
          if (m_maskNoise) {
        if (m_noiseMask.cellShouldBeMasked(bcCont,cellId)) {
          toMask=true;
          ATH_MSG_DEBUG (" Mask highNoise/dead  cell" << cellId << " E,t,chi2 " << aCell->energy() << " " << aCell->time() << " " << aCell->quality());
        }
          }
 
 
          if (toMask) {
              aCell->setEnergy(0.);
              aCell->setTime(0.);
              uint16_t qua=0;
              aCell->setQuality(qua);
              uint16_t provenance = (aCell->provenance() | 0x0800);
              aCell->setProvenance(provenance);
          }
 
      }
  }
 
 
  return returnSc ;
}

Member Data Documentation

m_bcContKey

SG::ReadCondHandleKey<LArBadChannelCont> LArCellNoiseMaskingTool::m_bcContKey

private

Initial value:

{this, "BadChanKey", "LArBadChannel", 
      "SG key for LArBadChan object"}

Definition at line 35 of file LArCellNoiseMaskingTool.h.

                                                     {this, "BadChanKey", "LArBadChannel", 
      "SG key for LArBadChan object"};

m_caloNums

std::vector<int> LArCellNoiseMaskingTool::m_caloNums

private

Definition at line 43 of file LArCellNoiseMaskingTool.h.

m_maskNoise

bool LArCellNoiseMaskingTool::m_maskNoise

private

Definition at line 44 of file LArCellNoiseMaskingTool.h.

m_maskSporadic

bool LArCellNoiseMaskingTool::m_maskSporadic

private

Definition at line 45 of file LArCellNoiseMaskingTool.h.

m_noiseMask

LArBadChannelMask LArCellNoiseMaskingTool::m_noiseMask

private

Definition at line 39 of file LArCellNoiseMaskingTool.h.

m_problemsToMask

Gaudi::Property<std::vector<std::string> > LArCellNoiseMaskingTool::m_problemsToMask

private

Initial value:

{this,"ProblemsToMask",{},
      "Bad-Channel categories to mask entirly"}

Definition at line 31 of file LArCellNoiseMaskingTool.h.

                                                       {this,"ProblemsToMask",{},
      "Bad-Channel categories to mask entirly"}; 

m_qualityCut

int LArCellNoiseMaskingTool::m_qualityCut

private

Definition at line 42 of file LArCellNoiseMaskingTool.h.

m_sporadicNoiseMask

LArBadChannelMask LArCellNoiseMaskingTool::m_sporadicNoiseMask

private

Definition at line 40 of file LArCellNoiseMaskingTool.h.

m_sporadicProblemsToMask

Gaudi::Property<std::vector<std::string> > LArCellNoiseMaskingTool::m_sporadicProblemsToMask

private

Initial value:

{this,"SporadicProblemsToMask",{},
      "Bad-Channel categories to mask in case of sporadic noise"}

Definition at line 33 of file LArCellNoiseMaskingTool.h.

                                                               {this,"SporadicProblemsToMask",{},
      "Bad-Channel categories to mask in case of sporadic noise"}; 

---

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

• LArCellNoiseMaskingTool.h
• LArCellNoiseMaskingTool.cxx