LArCellBuilderFromLArRawChannelTool Class Reference

Building LArCell objects from LArRawChannel. More...

#include <LArCellBuilderFromLArRawChannelTool.h>

Inheritance diagram for LArCellBuilderFromLArRawChannelTool:

Collaboration diagram for LArCellBuilderFromLArRawChannelTool:

Public Member Functions
virtual	~LArCellBuilderFromLArRawChannelTool ()=default
	Destructor, deletes the MsgService. More...
virtual StatusCode	initialize () override
	Initialize method. More...
virtual StatusCode	process (CaloCellContainer *theCellContainer, const EventContext &ctx) const override
	process method as defined in ICaloCellMaker interface More...

Private Attributes
SG::ReadHandleKey< LArRawChannelContainer >	m_rawChannelsKey {this,"RawChannelsName","LArRawChannels","Name of input container"}
	rdo container name (jO) More...
Gaudi::Property< bool >	m_addDeadOTX {this,"addDeadOTX",true,"Add dummy cells for missing FEBs"}
	activate addition of missing cells from dead OTX More...
Gaudi::Property< int >	m_initialDataPoolSize {this,"InitialCellPoolSize",-1,"Initial size of the DataPool<LArCells> (-1: Use nCells)"}
	Initial size of DataPool<LArCell> More...
unsigned	m_nTotalCells =0
	Number of cells, set in Initialize() More...
SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKey {this,"LArCablingKey","LArOnOffIdMap","Key of conditions data object holding cabling"}
const LArOnlineID *	m_onlineID =nullptr
const CaloCell_ID *	m_caloCID =nullptr
SG::ReadCondHandleKey< LArBadFebCont >	m_missingFebKey {this,"MissingFebKey","LArBadFeb","Key of conditions data object holding bad-feb info"}
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager"}

Detailed Description

Building LArCell objects from LArRawChannel.

An AlgTool class to create a CaloCellContainer out of a LArRawChannel container.

AlgTool properties (name defined in cxx file): RawChannelsName : input RawChannelContainer EThreshold: energy threshold

Modified: Dec 4, 2002 Hong Ma Use MakeLArCellFromRaw to make LArCell. Modified: June 2, 2004, David Rousseau : converted to AlgTool

Inherits from ICaloCellMakerTool and should be called by an instance of the CaloCellMaker algorithm.

Definition at line 52 of file LArCellBuilderFromLArRawChannelTool.h.

Constructor & Destructor Documentation

~LArCellBuilderFromLArRawChannelTool()

virtual LArCellBuilderFromLArRawChannelTool::~LArCellBuilderFromLArRawChannelTool ( )

virtualdefault

Destructor, deletes the MsgService.

Member Function Documentation

initialize()

StatusCode LArCellBuilderFromLArRawChannelTool::initialize ( )

overridevirtual

Initialize method.

Returns

Gaudi status code.

Initialazes pointers to servies and private members variable. Sets the m_subCalo variable based on the m_lArRegion jobOption. Computes the total number of cells based on the subcalo hash-range.

Definition at line 31 of file LArCellBuilderFromLArRawChannelTool.cxx.

                                                           {
 
  ATH_CHECK(m_rawChannelsKey.initialize());
 
  ATH_CHECK( detStore()->retrieve (m_caloCID, "CaloCell_ID") );
 
  ATH_CHECK( m_cablingKey.initialize() );
  ATH_CHECK( detStore()->retrieve(m_onlineID, "LArOnlineID") );
 
  if (!m_missingFebKey.key().empty()) {
    ATH_CHECK( m_missingFebKey.initialize() );
  }
  else {
    if (m_addDeadOTX) {
      ATH_MSG_ERROR( "Configuration problem: 'addDeadOTX' set, but no missing FEB container given."  );
      return StatusCode::FAILURE;
    }
  }
 
  ATH_CHECK(m_caloMgrKey.initialize());
 
  //Compute total number of cells
  m_nTotalCells=0;
 
  IdentifierHash caloCellMin, caloCellMax ;
  m_caloCID->calo_cell_hash_range(CaloCell_ID::LAREM,caloCellMin,caloCellMax);
  m_nTotalCells+=caloCellMax-caloCellMin;
  m_caloCID->calo_cell_hash_range(CaloCell_ID::LARHEC,caloCellMin,caloCellMax);
  m_nTotalCells+=caloCellMax-caloCellMin;
  m_caloCID->calo_cell_hash_range(CaloCell_ID::LARFCAL,caloCellMin,caloCellMax);
  m_nTotalCells+=caloCellMax-caloCellMin;
  
  if (m_initialDataPoolSize<0)  m_initialDataPoolSize=m_nTotalCells;
  ATH_MSG_DEBUG("Initial size of DataPool<LArCell>: " << m_initialDataPoolSize);
  
  ATH_MSG_DEBUG("Initialisating finished");
  return StatusCode::SUCCESS;
}

process()

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

overridevirtual

process method as defined in ICaloCellMaker interface

Parameters

theCellContainer	Pointer to the CaloCellContainer we are working on
ctx	The event context.

Returns

Gaudi status code.

Definition at line 74 of file LArCellBuilderFromLArRawChannelTool.cxx.

{
  if (theCellContainer->ownPolicy() == SG::OWN_ELEMENTS) {
    ATH_MSG_ERROR( "Called with a CaloCellContainer with wrong ownership policy! Need a VIEW container!"  );
    return StatusCode::FAILURE;
  }
 
  SG::ReadHandle<LArRawChannelContainer> rawColl(m_rawChannelsKey, ctx);
  if(!rawColl.isValid()) { 
    ATH_MSG_ERROR( " Can not retrieve LArRawChannelContainer: "
                   << m_rawChannelsKey.key()  );
    return StatusCode::FAILURE;      
   }  
 
   const size_t nRawChannels=rawColl->size();
   if (nRawChannels==0) {
     ATH_MSG_WARNING( "Got empty LArRawChannel container. Do nothing"  );
     return StatusCode::SUCCESS;
   }
   else
     ATH_MSG_DEBUG("Got " << nRawChannels << " LArRawChannels");
 
 
  unsigned nCellsAdded=0;
  std::bitset<CaloCell_ID::NSUBCALO> includedSubcalos;
  // resize calo cell container to correct size
  if (!theCellContainer->empty()) {
    ATH_MSG_WARNING( "Container should be empty! Clear now.");
    theCellContainer->clear();
  }
 
  DataPool<LArCell> pool (ctx,m_initialDataPoolSize);
 
  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl(m_cablingKey, ctx);
  const LArOnOffIdMapping* cabling=*cablingHdl;
 
  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey,ctx};
  const CaloDetDescrManager* caloDDM = *caloMgrHandle;
 
  theCellContainer->resize(m_nTotalCells);
 
  for (const LArRawChannel& rawChan : *rawColl) {
    const HWIdentifier hwid=rawChan.channelID();
    const IdentifierHash onlHash=m_onlineID->channel_Hash(hwid);
    if( cabling->isOnlineConnectedFromHash(onlHash)) {
      const IdentifierHash oflHash= cabling->oflHashFromOnlHash(onlHash);
      const Identifier id=m_caloCID->cell_id(oflHash); 
      const CaloDetDescrElement * theDDE=caloDDM->get_element(oflHash);
        
      LArCell *pCell   = pool.nextElementPtr();
 
      *pCell = LArCell (theDDE,
            id,
            rawChan.energy(),
            rawChan.time()*Gaudi::Units::picosecond/Gaudi::Units::nanosecond,    // convert time from ps (LArRawChannel) to ns
            rawChan.quality(),
            rawChan.provenance(),
            rawChan.gain());
 
      if ((*theCellContainer)[oflHash]) {
        ATH_MSG_WARNING("Channel added twice! Data corruption? hash="
                        << oflHash << " online ID=0x" << std::hex
                        << hwid.get_identifier32().get_compact() << std::dec
                        << "  " << m_onlineID->channel_name(hwid));
      } else {
        (*theCellContainer)[oflHash] = pCell;
        ++nCellsAdded;
        includedSubcalos.set(m_caloCID->sub_calo(oflHash));
      }
    }//end if connected
  }//end loop over LArRawChannelContainer
 
  //Now add in dummy cells (if requested)
    unsigned nMissingButPresent=0;
 
  if (m_addDeadOTX) {
    SG::ReadCondHandle<LArBadFebCont> missingFebHdl(m_missingFebKey, ctx);
    const LArBadFebCont::BadChanVec& allMissingFebs=(*missingFebHdl)->fullCont();
 
    for (const LArBadFebCont::BadChanEntry& it : allMissingFebs) {
      const LArBadFeb& febstatus=it.second;
      if (febstatus.deadReadout()  ||  febstatus.deadAll() || febstatus.deactivatedInOKS() ) {
    const HWIdentifier febId(it.first);
    //Loop over channels belonging to this FEB
    const int chansPerFeb=m_onlineID->channelInSlotMax(febId);
    for (int ch=0; ch<chansPerFeb; ++ch) {
      const HWIdentifier hwid = m_onlineID->channel_Id(febId, ch);
      if ( cabling->isOnlineConnected(hwid)) {
        const Identifier id=cabling->cnvToIdentifier(hwid);
        const IdentifierHash hashid= m_caloCID->calo_cell_hash(id);
        const CaloDetDescrElement * theDDE=caloDDM->get_element(hashid);
        LArCell *pCell   = pool.nextElementPtr();
        *pCell = LArCell (theDDE,
                  id,
                  0.0, //energy
                  0.0, //time
                  0.0, //quality;
                  0x0A00,   // 0x0800 (dead) + 0x0200  (to indicate missing readout)
                  CaloGain::LARHIGHGAIN);
      
    
        if ((*theCellContainer)[hashid]) {
          ++nMissingButPresent;
          ATH_MSG_DEBUG("The supposedly missing channel with online ID=0x" << std::hex 
                << hwid.get_identifier32().get_compact() << std::dec 
                << "  " << m_onlineID->channel_name(hwid) 
                << " is actually present in the LArRawChannel container");
        }
        else {
          (*theCellContainer)[hashid]=pCell;
          ++nCellsAdded;
          includedSubcalos.set(m_caloCID->sub_calo(hashid));
        }
      }//end if connected
    }//end loop over channels of one missing FEB
      }//end if is dead/missing FEB
    }//end loop over bad/missing FEBs
  }//end if  m_addDeadOTX
 
  //Set the 'hasCalo' variable of CaloCellContainer
  for (int iCalo=0;iCalo<CaloCell_ID::NSUBCALO;++iCalo) {
    if (includedSubcalos.test(iCalo))
      theCellContainer->setHasCalo(static_cast<CaloCell_ID::SUBCALO>(iCalo));
  }
 
  if (nMissingButPresent) 
    ATH_MSG_WARNING( "A total of " << nMissingButPresent 
                     << " supposedly missing channels where present in the LArRawChannelContainer"  );
 
  if (nCellsAdded!=m_nTotalCells) {
    ATH_MSG_DEBUG("Filled only  " << nCellsAdded << " out of " << m_nTotalCells << " cells. Removing holes");
    auto end1=std::remove(theCellContainer->begin(),theCellContainer->end(),nullptr);
    theCellContainer->erase(end1,theCellContainer->end());
    ATH_MSG_DEBUG("Shrunk the cell container to " << theCellContainer->size() << " (" << m_nTotalCells-nCellsAdded << " cells missing)");
  }//end if nCellsAdded!=m_nTotalCells
  else
    ATH_MSG_DEBUG("All " << nCellsAdded << " cells filled (no holes)");
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_addDeadOTX

Gaudi::Property<bool> LArCellBuilderFromLArRawChannelTool::m_addDeadOTX {this,"addDeadOTX",true,"Add dummy cells for missing FEBs"}

private

activate addition of missing cells from dead OTX

Definition at line 89 of file LArCellBuilderFromLArRawChannelTool.h.

m_cablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> LArCellBuilderFromLArRawChannelTool::m_cablingKey {this,"LArCablingKey","LArOnOffIdMap","Key of conditions data object holding cabling"}

private

Definition at line 96 of file LArCellBuilderFromLArRawChannelTool.h.

m_caloCID

const CaloCell_ID* LArCellBuilderFromLArRawChannelTool::m_caloCID =nullptr

private

Definition at line 98 of file LArCellBuilderFromLArRawChannelTool.h.

m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> LArCellBuilderFromLArRawChannelTool::m_caloMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager"}

private

Definition at line 101 of file LArCellBuilderFromLArRawChannelTool.h.

m_initialDataPoolSize

Gaudi::Property<int> LArCellBuilderFromLArRawChannelTool::m_initialDataPoolSize {this,"InitialCellPoolSize",-1,"Initial size of the DataPool<LArCells> (-1: Use nCells)"}

private

Initial size of DataPool<LArCell>

Definition at line 90 of file LArCellBuilderFromLArRawChannelTool.h.

m_missingFebKey

SG::ReadCondHandleKey<LArBadFebCont> LArCellBuilderFromLArRawChannelTool::m_missingFebKey {this,"MissingFebKey","LArBadFeb","Key of conditions data object holding bad-feb info"}

private

Definition at line 99 of file LArCellBuilderFromLArRawChannelTool.h.

m_nTotalCells

unsigned LArCellBuilderFromLArRawChannelTool::m_nTotalCells =0

private

Number of cells, set in Initialize()

Definition at line 93 of file LArCellBuilderFromLArRawChannelTool.h.

m_onlineID

const LArOnlineID* LArCellBuilderFromLArRawChannelTool::m_onlineID =nullptr

private

Definition at line 97 of file LArCellBuilderFromLArRawChannelTool.h.

m_rawChannelsKey

SG::ReadHandleKey<LArRawChannelContainer> LArCellBuilderFromLArRawChannelTool::m_rawChannelsKey {this,"RawChannelsName","LArRawChannels","Name of input container"}

private

rdo container name (jO)

Definition at line 88 of file LArCellBuilderFromLArRawChannelTool.h.

---

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

• LArCellBuilderFromLArRawChannelTool.h
• LArCellBuilderFromLArRawChannelTool.cxx