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.
virtual StatusCode	initialize () override
	Initialize method.
virtual StatusCode	process (CaloCellContainer *theCellContainer, const EventContext &ctx) const override
	process method as defined in ICaloCellMaker interface

Private Attributes
SG::ReadHandleKey< LArRawChannelContainer >	m_rawChannelsKey {this,"RawChannelsName","LArRawChannels","Name of input container"}
	rdo container name (jO)
Gaudi::Property< bool >	m_addDeadOTX {this,"addDeadOTX",true,"Add dummy cells for missing FEBs"}
	activate addition of missing cells from dead OTX
Gaudi::Property< int >	m_initialDataPoolSize {this,"InitialCellPoolSize",-1,"Initial size of the DataPool<LArCells> (-1: Use nCells)"}
	Initial size of DataPool<LArCell>
unsigned	m_nTotalCells =0
	Number of cells, set in Initialize()
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.

89{this,"addDeadOTX",true,"Add dummy cells for missing FEBs"};

◆ 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.

96{this,"LArCablingKey","LArOnOffIdMap","Key of conditions data object holding cabling"};

◆ 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.

101{this,"CaloDetDescrManager", "CaloDetDescrManager"};

◆ 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.

90{this,"InitialCellPoolSize",-1,"Initial size of the DataPool<LArCells> (-1: Use nCells)"};

◆ 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.

99{this,"MissingFebKey","LArBadFeb","Key of conditions data object holding bad-feb info"};

◆ 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.

88{this,"RawChannelsName","LArRawChannels","Name of input container"};

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

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ~LArCellBuilderFromLArRawChannelTool()

Member Function Documentation

◆ initialize()

◆ process()

Member Data Documentation

◆ m_addDeadOTX

◆ m_cablingKey

◆ m_caloCID

◆ m_caloMgrKey

◆ m_initialDataPoolSize

◆ m_missingFebKey

◆ m_nTotalCells

◆ m_onlineID

◆ m_rawChannelsKey