MergeCalibHitsTool Class Reference

an algorithm to copy in the overlayed store the calib hits from the signal event More...

#include <MergeCalibHitsTool.h>

Inheritance diagram for MergeCalibHitsTool:

Collaboration diagram for MergeCalibHitsTool:

Public Member Functions
	MergeCalibHitsTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override final
	called before the event loop
virtual StatusCode	prepareEvent (const EventContext &ctx, unsigned int nInputEvents) override final
	called before the subevts loop.
virtual StatusCode	mergeEvent (const EventContext &ctx) override final
	called at the end of the subevts loop.
virtual StatusCode	processBunchXing (int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents) override final
	called for each active bunch-crossing to process current SubEvents bunchXing is in ns
virtual StatusCode	processAllSubEvents (const EventContext &ctx) override final
	return false if not interested in certain xing times (in ns) implemented by default in PileUpToolBase as FirstXing<=bunchXing<=LastXing

Private Attributes
Gaudi::Property< bool >	m_oldFormat {this, "OldFormat", false, ""}
ServiceHandle< PileUpMergeSvc >	m_pMergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", ""}
bool	m_firstSubEvent {true}
std::vector< CaloCalibrationHitContainer * >	m_outputContainers
std::vector< std::string >	m_CalibrationHitContainer

structors and AlgTool implementation
virtual bool	toProcess (int bunchXing) const override
	the method this base class helps implementing
virtual bool	filterPassed () const override
	dummy implementation of passing filter
virtual void	resetFilter () override
	dummy implementation of filter reset
Gaudi::Property< int >	m_firstXing
Gaudi::Property< int >	m_lastXing
Gaudi::Property< int >	m_vetoPileUpTruthLinks
bool	m_filterPassed {true}

Detailed Description

an algorithm to copy in the overlayed store the calib hits from the signal event

$Id:

Author

Guillaume Unal (from Paolo's MergeMcEventCollection)

Definition at line 25 of file MergeCalibHitsTool.h.

Constructor & Destructor Documentation

MergeCalibHitsTool()

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

Definition at line 10 of file MergeCalibHitsTool.cxx.

                                                                 :
  PileUpToolBase(type, name, parent)
{
}

Member Function Documentation

filterPassed()

virtual bool PileUpToolBase::filterPassed ( ) const

inlineoverridevirtualinherited

dummy implementation of passing filter

Definition at line 49 of file PileUpToolBase.h.

{ return m_filterPassed; }

initialize()

StatusCode MergeCalibHitsTool::initialize ( )

finaloverridevirtual

called before the event loop

Reimplemented from PileUpToolBase.

Definition at line 17 of file MergeCalibHitsTool.cxx.

                                          {
  ATH_MSG_VERBOSE ( "initialize()" );
 
  ATH_CHECK(m_pMergeSvc.retrieve());
 
  // list of CaloCalibrationHit containers
  if(m_oldFormat) {
    m_CalibrationHitContainer.reserve(5);
    m_CalibrationHitContainer.push_back("LArCalibrationHitActive");
    m_CalibrationHitContainer.push_back("LArCalibrationHitDeadMaterial");
    m_CalibrationHitContainer.push_back("LArCalibrationHitInactive");
    m_CalibrationHitContainer.push_back("TileCalibrationCellHitCnt");
    m_CalibrationHitContainer.push_back("TileCalibrationDMHitCnt");
  }
  else {
    m_CalibrationHitContainer.reserve(6);
    m_CalibrationHitContainer.push_back("LArCalibrationHitActive");
    m_CalibrationHitContainer.push_back("LArCalibrationHitDeadMaterial");
    m_CalibrationHitContainer.push_back("LArCalibrationHitInactive");
    m_CalibrationHitContainer.push_back("TileCalibHitActiveCell");
    m_CalibrationHitContainer.push_back("TileCalibHitInactiveCell");
    m_CalibrationHitContainer.push_back("TileCalibHitDeadMaterial");
  }
  m_outputContainers.reserve(m_CalibrationHitContainer.size());
  return StatusCode::SUCCESS;
}

mergeEvent()

StatusCode MergeCalibHitsTool::mergeEvent ( const EventContext & ctx )

finaloverridevirtual

called at the end of the subevts loop.

Not (necessarily) able to access SubEvents

Definition at line 113 of file MergeCalibHitsTool.cxx.

                                                               {
  for (unsigned int iHitContainer=0;iHitContainer<m_CalibrationHitContainer.size();++iHitContainer) {
    if ( m_outputContainers[iHitContainer]==0 ) { continue; } //don't bother recording unused containers!
    if (!(evtStore()->record(m_outputContainers[iHitContainer],m_CalibrationHitContainer[iHitContainer]).isSuccess())) {
      ATH_MSG_ERROR ( " Cannot record new calibration hit in overlayed event " );
      return StatusCode::FAILURE;
    }
  }   // end of loop over the various types of calo calibration hits
  return StatusCode::SUCCESS;
}

prepareEvent()

StatusCode MergeCalibHitsTool::prepareEvent ( const EventContext & ctx, unsigned int nInputEvents )

finaloverridevirtual

called before the subevts loop.

Not (necessarily) able to access SubEvents

Definition at line 45 of file MergeCalibHitsTool.cxx.

                                                                                           {
  ATH_MSG_VERBOSE ( "Calling prepareEvent()" );
  ATH_MSG_VERBOSE( "prepareEvent: there are " << nInputEvents << " subevents in this event.");
  m_firstSubEvent = true;
  //clean up pointers from the last event
  m_outputContainers.clear();
  for (unsigned int iHitContainer=0;iHitContainer<m_CalibrationHitContainer.size(); ++iHitContainer) {
    m_outputContainers.push_back(NULL);
  }
  return StatusCode::SUCCESS;
}

processAllSubEvents()

StatusCode MergeCalibHitsTool::processAllSubEvents ( const EventContext & ctx )

finaloverridevirtual

return false if not interested in certain xing times (in ns) implemented by default in PileUpToolBase as FirstXing<=bunchXing<=LastXing

Propagate the Calib Hit Containers to the output StoreGate

Reimplemented from PileUpToolBase.

Definition at line 124 of file MergeCalibHitsTool.cxx.

                                                                        {
  ATH_MSG_VERBOSE ( "processAllSubEvents()" );
 
  // loop over containers
  for (unsigned int iHitContainer=0;iHitContainer<m_CalibrationHitContainer.size();iHitContainer++) {
 
    ATH_MSG_DEBUG ( " Process CalibrationHit container " << m_CalibrationHitContainer[iHitContainer] );
 
    const CaloCalibrationHitContainer* hitCont;
 
    // if container not there from pileupservice, do nothing
    if (!(m_pMergeSvc->retrieveOriginal(m_CalibrationHitContainer[iHitContainer]
                                        ,hitCont).isSuccess())  ||  !hitCont) {
      ATH_MSG_DEBUG ( " Cannot find calibrationHit from PileUp service " );
      continue;
    }
 
    // create new container for overlayed event
    CaloCalibrationHitContainer* newContainer = new CaloCalibrationHitContainer(m_CalibrationHitContainer[iHitContainer]);
 
    // loop over this container, perform a deep brute-force copy
    int nhit=0;
    ATH_MSG_DEBUG ( " Start loop over calibration hits of signal event " );
    for (const CaloCalibrationHit* hit : *hitCont) {
      nhit++;
      newContainer->push_back(new CaloCalibrationHit(*hit));
    }   // end of loop over calibration hits
 
    ATH_MSG_DEBUG ( " Number of hits found in this container " << nhit );
 
    // record new container in overlayed event
    if (!(evtStore()->record(newContainer,m_CalibrationHitContainer[iHitContainer]).isSuccess())) {
      ATH_MSG_ERROR ( " Cannot record new calibration hit in overlayed event " );
      return StatusCode::FAILURE;
    }
 
  }   // end of loop over the various types of calo calibration hits
 
  return StatusCode::SUCCESS;
}

processBunchXing()

StatusCode MergeCalibHitsTool::processBunchXing ( int bunchXing, SubEventIterator bSubEvents, SubEventIterator eSubEvents )

finaloverridevirtual

called for each active bunch-crossing to process current SubEvents bunchXing is in ns

Reimplemented from PileUpToolBase.

Definition at line 57 of file MergeCalibHitsTool.cxx.

{
  SubEventIterator iEvt(bSubEvents);
  while (iEvt != eSubEvents) {
    // MergeCalibHitsTool should only write out the hits from the signal event.
    if(!m_firstSubEvent) {
      ATH_MSG_VERBOSE ( " Have already seen a SubEvent marked as Signal! Don't need to look at any others! " );
      break;
    }
 
    if( iEvt->type()==xAOD::EventInfo_v1::PileUpType::Signal ) {
      ATH_MSG_DEBUG ( " Found the Signal event! " );
    }
    else {
      // this is not the signal event, so we should skip it.
      ++iEvt;
      continue;
    }
 
    // loop over containers
    for (unsigned int iHitContainer=0;iHitContainer<m_CalibrationHitContainer.size();++iHitContainer) {
      ATH_MSG_VERBOSE ( " Bunch Crossing: " <<bunchXing << ". Process CalibrationHit container " << m_CalibrationHitContainer[iHitContainer] );
      const CaloCalibrationHitContainer* hitCont;
      if (!m_pMergeSvc->retrieveSingleSubEvtData(m_CalibrationHitContainer[iHitContainer], hitCont,
                                                 bunchXing, iEvt).isSuccess()){
        ATH_MSG_VERBOSE("CaloCalibrationHitContainer not found for event key " << m_CalibrationHitContainer[iHitContainer]);
        continue;
      }
 
      //if this is the first SubEvent for this Event then create the hitContainers;
      if(m_firstSubEvent) {
        m_outputContainers[iHitContainer] = new CaloCalibrationHitContainer(m_CalibrationHitContainer[iHitContainer]);
      }
      // loop over this container, perform a deep brute-force copy
      int nhit=0;
      ATH_MSG_VERBOSE ( " Start loop over calibration hits of signal event " );
      CaloCalibrationHitContainer::const_iterator calibhititer = hitCont->begin();
      CaloCalibrationHitContainer::const_iterator calibhitend  = hitCont->end();
      while(calibhititer != calibhitend) {
        ++nhit;
        m_outputContainers[iHitContainer]->push_back(new CaloCalibrationHit(**calibhititer));
        ++calibhititer;
      }   // end of loop over calibration hits
 
      ATH_MSG_DEBUG ( " Number of hits found in this " << m_CalibrationHitContainer[iHitContainer]
                      << " container = " << nhit );
    }
    //we must have seen at least one event by now...
    m_firstSubEvent = false;
    ++iEvt;
  }
 
  return StatusCode::SUCCESS;
}

resetFilter()

virtual void PileUpToolBase::resetFilter ( )

inlineoverridevirtualinherited

dummy implementation of filter reset

Reimplemented in MergeTruthJetsTool.

Definition at line 51 of file PileUpToolBase.h.

{ m_filterPassed=true; }

toProcess()

virtual bool PileUpToolBase::toProcess ( int bunchXing ) const

inlineoverridevirtualinherited

the method this base class helps implementing

Reimplemented in MergeHijingParsTool, and MergeTrackRecordCollTool.

Definition at line 32 of file PileUpToolBase.h.

                                                       {
    //closed interval [m_firstXing,m_lastXing]
    return !((m_firstXing > bunchXing) || (bunchXing > m_lastXing));
  }

Member Data Documentation

m_CalibrationHitContainer

std::vector<std::string> MergeCalibHitsTool::m_CalibrationHitContainer

private

Definition at line 57 of file MergeCalibHitsTool.h.

m_filterPassed

bool PileUpToolBase::m_filterPassed {true}

protectedinherited

Definition at line 60 of file PileUpToolBase.h.

{true}; 

m_firstSubEvent

bool MergeCalibHitsTool::m_firstSubEvent {true}

private

Definition at line 55 of file MergeCalibHitsTool.h.

{true};

m_firstXing

Gaudi::Property<int> PileUpToolBase::m_firstXing

protectedinherited

Initial value:

{this, "FirstXing", -999,
      "First bunch-crossing in which det is live"}

Definition at line 54 of file PileUpToolBase.h.

                                {this, "FirstXing", -999,
      "First bunch-crossing in which det is live"};

m_lastXing

Gaudi::Property<int> PileUpToolBase::m_lastXing

protectedinherited

Initial value:

{this, "LastXing", 999,
      "Last bunch-crossing in which det is live"}

Definition at line 56 of file PileUpToolBase.h.

                                {this, "LastXing", 999,
      "Last bunch-crossing in which det is live"};

m_oldFormat

Gaudi::Property<bool> MergeCalibHitsTool::m_oldFormat {this, "OldFormat", false, ""}

private

Definition at line 53 of file MergeCalibHitsTool.h.

{this, "OldFormat", false, ""};

m_outputContainers

std::vector<CaloCalibrationHitContainer*> MergeCalibHitsTool::m_outputContainers

private

Definition at line 56 of file MergeCalibHitsTool.h.

m_pMergeSvc

ServiceHandle<PileUpMergeSvc> MergeCalibHitsTool::m_pMergeSvc {this, "PileUpMergeSvc", "PileUpMergeSvc", ""}

private

Definition at line 54 of file MergeCalibHitsTool.h.

{this, "PileUpMergeSvc", "PileUpMergeSvc", ""};

m_vetoPileUpTruthLinks

Gaudi::Property<int> PileUpToolBase::m_vetoPileUpTruthLinks

protectedinherited

Initial value:

{this, "VetoPileUpTruthLinks", true,
      "Ignore links to suppressed pile-up truth"}

Definition at line 58 of file PileUpToolBase.h.

                                           {this, "VetoPileUpTruthLinks", true,
      "Ignore links to suppressed pile-up truth"};

---

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

• MergeCalibHitsTool.h
• MergeCalibHitsTool.cxx