LArCellMerger Class Reference

Replace cells in calo cell container with cells from alternate raw channel container. More...

#include <LArCellMerger.h>

Inheritance diagram for LArCellMerger:

Collaboration diagram for LArCellMerger:

Public Member Functions
virtual StatusCode	initialize () override
	initialize the tool
virtual StatusCode	finalize () override
	finalize the tool
virtual StatusCode	process (CaloCellContainer *theCellContainer, const EventContext &ctx) const override
	update theCellContainer

Private Attributes
SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of Cabling obj"}
	handle to LAr cabling
SG::ReadHandleKey< LArRawChannelContainer >	m_rawChannelContainerName
	key for raw channel container to merge to cells
const CaloCell_ID *	m_calo_id =nullptr
const LArOnlineID *	m_onlineID =nullptr

Detailed Description

Replace cells in calo cell container with cells from alternate raw channel container.

Use case: when full calo cell container is made from DSP computed cells, replace some of then with better energies from offline reconstructed digits

AlgTool properties (name defined in cxx file): Name of the alternate raw channel container (i.e made from the digits offline)

Created July 09, 2009 G.Unal

Definition at line 34 of file LArCellMerger.h.

Member Function Documentation

finalize()

StatusCode LArCellMerger::finalize ( )

overridevirtual

finalize the tool

Definition at line 44 of file LArCellMerger.cxx.

                                  {
   return StatusCode::SUCCESS;
}

initialize()

StatusCode LArCellMerger::initialize ( )

overridevirtual

initialize the tool

Definition at line 33 of file LArCellMerger.cxx.

                                     {
 
  ATH_CHECK(detStore()->retrieve(m_calo_id,"CaloCell_ID"));
  ATH_CHECK( detStore()->retrieve(m_onlineID, "LArOnlineID") );
  ATH_CHECK( m_cablingKey.initialize() );
 
  ATH_CHECK(m_rawChannelContainerName.initialize());
 
  return StatusCode::SUCCESS;
}

process()

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

overridevirtual

update theCellContainer

Definition at line 48 of file LArCellMerger.cxx.

{
  ATH_MSG_DEBUG("in  LArCellMerger::process");
  
  SG::ReadHandle<LArRawChannelContainer> rawColl(m_rawChannelContainerName, ctx);
  if (!rawColl.isValid()) {
    ATH_MSG_ERROR("Failed to retrieve LArRawChannelContainer with key " << 
          rawColl.name());
    return StatusCode::FAILURE;
  }
 
  SG::ReadCondHandle<LArOnOffIdMapping> larCablingHdl(m_cablingKey, ctx);
  const LArOnOffIdMapping* cabling=*larCablingHdl;
 
  unsigned nReplaced=0;
 
  // loop over raw channel container
  //   as this new container is supposed to contain only few cells, we do a simple loop and the basics onlineId to offlineId conversion
  //   this could be a little slow if by mistake this container contains all cells (not what this tool is supposed to be used for)
  for ( const LArRawChannel& theRawChannel : *rawColl ) {
      const HWIdentifier hwid=theRawChannel.channelID();
      const IdentifierHash onlHash=m_onlineID->channel_Hash(hwid);
      if( cabling->isOnlineConnectedFromHash(onlHash)) {
        const IdentifierHash theCellHashID= cabling->oflHashFromOnlHash(onlHash);
        const Identifier id=m_calo_id->cell_id(theCellHashID); 
          int index = theCont->findIndex(theCellHashID);
          if (index<0) {
        ATH_MSG_WARNING( " cell " << hwid.get_compact() << " " << id.get_compact() << " is not in the container "  );
        continue;
          }
          CaloCell* aCell = theCont->at(index);
 
          if (aCell) {
        ATH_MSG_DEBUG(" replace energies in cell hwid= " << hwid.get_identifier32().get_compact() 
              << " offlineid = " << id.get_identifier32().get_compact()
              << " old energy " << aCell->e() << " new energy " << theRawChannel.energy());
        nReplaced++;
        aCell->setEnergy((float)(theRawChannel.energy()));
        aCell->setTime((float)(theRawChannel.time())*0.001);    // convert from ps int in raw channel to ns float in calocell
        aCell->setQuality(theRawChannel.quality());
        aCell->setProvenance(theRawChannel.provenance());
          }
 
      }// isConnected
  }// loop over raw channel container
 
  if (nReplaced*5>theCont->size()) {
    ATH_MSG_WARNING("Replaced more than 20% of channels reco'ed online by channels reco'ed offline");
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_cablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> LArCellMerger::m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of Cabling obj"}

private

handle to LAr cabling

Definition at line 59 of file LArCellMerger.h.

{this,"CablingKey","LArOnOffIdMap","SG Key of Cabling obj"};

m_calo_id

const CaloCell_ID* LArCellMerger::m_calo_id =nullptr

private

Definition at line 67 of file LArCellMerger.h.

m_onlineID

const LArOnlineID* LArCellMerger::m_onlineID =nullptr

private

Definition at line 68 of file LArCellMerger.h.

m_rawChannelContainerName

SG::ReadHandleKey<LArRawChannelContainer> LArCellMerger::m_rawChannelContainerName

private

Initial value:

{this,"RawChannelsName","LArRawChannels_digits",
                                         "SG key of rebuilt LArRawChannelContainer"}

key for raw channel container to merge to cells

Definition at line 64 of file LArCellMerger.h.

                                                                    {this,"RawChannelsName","LArRawChannels_digits",
                                         "SG key of rebuilt LArRawChannelContainer"};

---

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

• LArCellMerger.h
• LArCellMerger.cxx