LArCellMaskingTool Class Reference

#include <LArCellMaskingTool.h>

Inheritance diagram for LArCellMaskingTool:

Collaboration diagram for LArCellMaskingTool:

Public Member Functions
	LArCellMaskingTool (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
virtual StatusCode	finalize () override

Private Member Functions
StatusCode	fillIncludedCellsMap (const LArOnOffIdMapping *cabling) const

Private Attributes
const LArOnlineID *	m_onlineID
const CaloCell_ID *	m_offlineID
SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}
std::vector< std::string >	m_rejLArChannels
std::bitset< 200000 > m_includedCellsMap	ATLAS_THREAD_SAFE
std::atomic< bool >	m_mapInitialized
IdentifierHash	m_offlinehashMax
IdentifierHash	m_onlinehashMax
std::mutex	m_mutex

Detailed Description

Definition at line 21 of file LArCellMaskingTool.h.

Constructor & Destructor Documentation

LArCellMaskingTool()

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

Definition at line 21 of file LArCellMaskingTool.cxx.

  : base_class (type, name, parent),
    m_onlineID(nullptr),
    m_offlineID(nullptr),
    m_mapInitialized (false)
{
  //List of strings to determine detector parts to be masked.
  //Syntax: barrel_endcap pos_neg Feedthrough slot channel (integers separated by white space)
  //Feedthrough, slot, and channel can be left out. In this case all channels belonging to this 
  //Subdetector, Feedthrough or FEB will be masked.
  declareProperty ("RejectLArChannels",m_rejLArChannels);
}

Member Function Documentation

fillIncludedCellsMap()

StatusCode LArCellMaskingTool::fillIncludedCellsMap ( const LArOnOffIdMapping * cabling ) const

private

Definition at line 68 of file LArCellMaskingTool.cxx.

{
  for (const std::string& s : m_rejLArChannels) {
    std::stringstream is;
    is << s;
    bool haveFT=false, haveSlot=false, haveChannel=false;
    int bec=0, pn=0, FT=0, slot=1,channel=0;
    //Want at least subdetector (=pn & bec)
    is >> bec >> pn;
    if (is.bad()) {
      ATH_MSG_ERROR ("jO problem: Malformed string [" << s << "]");
      return StatusCode::FAILURE;
    }
 
    int FTmax;
    if (bec==0) 
      FTmax=32; //Barrel
    else
      FTmax=24; //Endcap
 
 
 
    if (!is.eof()) {//have FT
      is >> FT; 
      haveFT=true;
      //check good?
    }
    if (!is.eof()) {//have slot
      is >> slot; 
      haveSlot=true;
    }
    if (!is.eof()) {//have channel
      is >> channel; 
      haveChannel=true;
    }
    
    msg() << MSG::DEBUG << "Will exclude: bec="<< bec << " pn=" << pn;
    if (haveFT) msg() << " FT=" << FT;
    if (haveSlot) msg() << " slot=" << slot; 
    if (haveChannel) msg() << " channel=" << channel;
    msg() << endmsg;
 
    unsigned nChannels=0;
    unsigned nDisconnected=0;
    HWIdentifier chanId;
    do { //loop over FTs (only once if FT is set
      //Number of channels for this FT
      int slotMax=15;
      do {
    int channelMax=128;
    do { //loop over channels in slot
      nChannels++;
      try {
        chanId=m_onlineID->channel_Id(bec,pn,FT,slot,channel);
        if (cabling->isOnlineConnected(chanId)) {
          const Identifier cellId=cabling->cnvToIdentifier(chanId);
          const IdentifierHash cellhash=m_offlineID->calo_cell_hash(cellId);
          m_includedCellsMap.reset(cellhash);
          //std::cout << "Block channel: bec="<< bec << " pn=" << pn 
          //        << " FT=" << FT <<":" << haveFT << " slot=" << slot << ":" << haveSlot << " channel=" << channel <<":" << haveChannel<< std::endl;
        }
        else
          nDisconnected++;
      }
      catch (const LArOnlID_Exception&) {
      }
      catch(const LArID_Exception&) {
      }
      if (!haveChannel) channel++;
    }while (!haveChannel && channel<channelMax); 
    if (!haveChannel) channel=0;
    if (!haveSlot) slot++;
      }while (!haveSlot && slot<slotMax);
      if (!haveSlot) slot=0;
      if (!haveFT) FT++;
    } while (!haveFT && FT<FTmax); 
    ATH_MSG_DEBUG ("Channels selected for exclusion: "<< nChannels << ". Disconnected: " << nDisconnected);
  }// end loop over strings
  return StatusCode::SUCCESS;
}

finalize()

StatusCode LArCellMaskingTool::finalize ( )

overridevirtual

Definition at line 184 of file LArCellMaskingTool.cxx.

                                        {
  return StatusCode::SUCCESS;
}

initialize()

StatusCode LArCellMaskingTool::initialize ( )

overridevirtual

Definition at line 45 of file LArCellMaskingTool.cxx.

{
  ATH_CHECK( detStore()->retrieve(m_offlineID) );
  ATH_CHECK( detStore()->retrieve(m_onlineID) );
  ATH_CHECK( m_cablingKey.initialize());
  
 // Get hash ranges
  m_offlinehashMax=m_offlineID->calo_cell_hash_max();
  ATH_MSG_DEBUG ("CaloCell Hash Max: " << m_offlinehashMax);
  
//   m_onlinehashMax=m_onlineID->hash_max();
//   (*m_log) << MSG::DEBUG << "CaloCell Hash Max: " << m_offlinehashMax << endmsg;
  
  //Fill the bit map
  m_includedCellsMap.set(); // By default include all cells
  
  ATH_MSG_INFO (" Will exclude " << m_includedCellsMap.size() - m_includedCellsMap.count() << " cells from CaloCellContainer");
  
 
  return StatusCode::SUCCESS;
 
}

process()

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

overridevirtual

Definition at line 151 of file LArCellMaskingTool.cxx.

{
  if (! m_mapInitialized) {
    // FIXME: Can we do this in start()?
    std::lock_guard<std::mutex> lock (m_mutex);
    // cppcheck-suppress identicalInnerCondition
    if (!m_mapInitialized) {
      SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl (m_cablingKey, ctx);
      const LArOnOffIdMapping* cabling=*cablingHdl;
      ATH_CHECK(fillIncludedCellsMap(cabling));
      m_mapInitialized=true;
    }
  }
 
  //Build bitmap to keep track which cells have been added to reducedCellContainer;
  unsigned cnt=0;
  CaloCellContainer::iterator it=theCont->begin();
  while(it!=theCont->end()) {
    const IdentifierHash cellHash=(*it)->caloDDE()->calo_hash();
    if (!m_includedCellsMap.test(cellHash)) {
      //Possible optimization: check how many consecutive cells to be deleted and erase a range
      it=theCont->erase(it);
      cnt++;
    }
    else
      ++it;
  }
  ATH_MSG_DEBUG ("Removed " << cnt << " Cells from container");
  return StatusCode::SUCCESS ;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::bitset<200000> m_includedCellsMap LArCellMaskingTool::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 48 of file LArCellMaskingTool.h.

m_cablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> LArCellMaskingTool::m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}

private

Definition at line 44 of file LArCellMaskingTool.h.

{this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"};

m_mapInitialized

std::atomic<bool> LArCellMaskingTool::m_mapInitialized

mutableprivate

Definition at line 50 of file LArCellMaskingTool.h.

m_mutex

std::mutex LArCellMaskingTool::m_mutex

mutableprivate

Definition at line 53 of file LArCellMaskingTool.h.

m_offlinehashMax

IdentifierHash LArCellMaskingTool::m_offlinehashMax

private

Definition at line 51 of file LArCellMaskingTool.h.

m_offlineID

const CaloCell_ID* LArCellMaskingTool::m_offlineID

private

Definition at line 43 of file LArCellMaskingTool.h.

m_onlinehashMax

IdentifierHash LArCellMaskingTool::m_onlinehashMax

private

Definition at line 52 of file LArCellMaskingTool.h.

m_onlineID

const LArOnlineID* LArCellMaskingTool::m_onlineID

private

Definition at line 42 of file LArCellMaskingTool.h.

m_rejLArChannels

std::vector<std::string> LArCellMaskingTool::m_rejLArChannels

private

Definition at line 47 of file LArCellMaskingTool.h.

---

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

• LArCellMaskingTool.h
• LArCellMaskingTool.cxx