FastHitConvertTool Class Reference

#include <FastHitConvertTool.h>

Inheritance diagram for FastHitConvertTool:

Collaboration diagram for FastHitConvertTool:

Public Member Functions
	FastHitConvertTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~FastHitConvertTool ()
	default destructor More...
virtual StatusCode	initialize () override final
	standard Athena-Algorithm method More...
virtual StatusCode	process (CaloCellContainer *theCellContainer, const EventContext &ctx) const override
	standard Athena-Algorithm method More...

Private Attributes
SG::WriteHandleKey< LArHitContainer >	m_embHitContainerKey {this,"embHitContainername","LArHitEMB","Name of output FastSim LAr EM Barrel Hit Container"}
SG::WriteHandleKey< LArHitContainer >	m_emecHitContainerKey {this,"emecHitContainername","LArHitEMEC","Name of output FastSim LAr EM Endcap Hit Container"}
SG::WriteHandleKey< LArHitContainer >	m_fcalHitContainerKey {this,"fcalHitContainername","LArHitFCAL","Name of output FastSim LAr FCAL Hit Container"}
SG::WriteHandleKey< LArHitContainer >	m_hecHitContainerKey {this,"hecHitContainername","LArHitHEC","Name of output FastSim LAr HEC Hit Container"}
SG::WriteHandleKey< TileHitVector >	m_tileHitVectorKey {this,"tileHitContainername","TileHitVec","Name of output FastSim Tile Hit Container"}
ServiceHandle< StoreGateSvc >	m_storeGateFastCalo
PileUpMergeSvc *	m_pMergeSvc {nullptr}
SG::ReadCondHandleKey< ILArfSampl >	m_fSamplKey {this,"fSamplKey","LArfSamplSym","SG Key of LArfSampl object"}
SG::ReadCondHandleKey< TileSamplingFraction >	m_tileSamplingFractionKey
	Name of TileSamplingFraction in condition store. More...
ServiceHandle< TileCablingSvc >	m_tileCablingSvc
	Name of Tile cabling service. More...
const LArEM_ID *	m_larEmID {nullptr}
const LArFCAL_ID *	m_larFcalID {nullptr}
const LArHEC_ID *	m_larHecID {nullptr}
const TileID *	m_tileID {nullptr}
const TileHWID *	m_tileHWID {nullptr}
const TileCablingService *	m_tileCabling {nullptr}
Gaudi::Property< bool >	m_pileup {this,"doPileup",false,"Pileup mode (default=false)"}
SG::ReadHandleKey< EventInfo >	m_pileup_evt {this,"pileupEventInfo","MyEvent",""}
SG::ReadHandleKey< PileUpEventInfo >	m_pileup_pOverEvent {this,"pileupOverlayEvent","OverlayEvent",""}

Detailed Description

This is for the Doxygen-Documentation. Please delete these lines and fill in information about the Algorithm! Please precede every member function declaration with a short Doxygen comment stating the purpose of this function.

Author

Bo Liu boliu.nosp@m.@cer.nosp@m.n.ch

Definition at line 50 of file FastHitConvertTool.h.

Constructor & Destructor Documentation

FastHitConvertTool()

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

Definition at line 36 of file FastHitConvertTool.cxx.

  :
  base_class(type,name,parent),
  m_storeGateFastCalo("StoreGateSvc/FastCalo",name)
{
}

~FastHitConvertTool()

virtual FastHitConvertTool::~FastHitConvertTool ( )

inlinevirtual

default destructor

Definition at line 56 of file FastHitConvertTool.h.

{};

Member Function Documentation

initialize()

StatusCode FastHitConvertTool::initialize ( )

finaloverridevirtual

standard Athena-Algorithm method

Definition at line 53 of file FastHitConvertTool.cxx.

{
 
  //Service for Pileup
  if(m_pileup)
    {
      CHECK(service("PileUpMergeSvc", m_pMergeSvc));
      CHECK(m_storeGateFastCalo.retrieve());
    }
  ATH_MSG_DEBUG("StoreGateFastCalo Svc structure at Initialisation"<<(*m_storeGateFastCalo).dump());
  const CaloIdManager* caloIdManager = nullptr;
  CHECK(detStore()->retrieve(caloIdManager));
  m_larEmID=caloIdManager->getEM_ID();
  if(m_larEmID==0)
    throw std::runtime_error("FastHitConvertTool: Invalid LAr EM ID helper");
  m_larFcalID=caloIdManager->getFCAL_ID();
  if(m_larFcalID==0)
    throw std::runtime_error("FastHitConvertTool: Invalid FCAL ID helper");
  m_larHecID=caloIdManager->getHEC_ID();
  if(m_larHecID==0)
    throw std::runtime_error("FastHitConvertTool: Invalid HEC ID helper");
  m_tileID=caloIdManager->getTileID();
  if(m_tileID==0)
    throw std::runtime_error("FastHitConvertTool: Invalid Tile ID helper");
 
  // LAr and Tile Sampling Fractions
  ATH_CHECK(m_fSamplKey.initialize());
 
  ATH_CHECK(detStore()->retrieve(m_tileHWID));
  ATH_CHECK( m_tileSamplingFractionKey.initialize() );
 
  ATH_CHECK( m_tileCablingSvc.retrieve() );
  m_tileCabling = m_tileCablingSvc->cablingService();
 
  // Output keys
  ATH_CHECK(m_embHitContainerKey.initialize());
  ATH_CHECK(m_emecHitContainerKey.initialize());
  ATH_CHECK(m_fcalHitContainerKey.initialize());
  ATH_CHECK(m_hecHitContainerKey.initialize());
  ATH_CHECK(m_tileHitVectorKey.initialize());
 
  // Inputs for pileup (only initialized if m_pileup==true)
  ATH_CHECK(m_pileup_evt.initialize(m_pileup));
  ATH_CHECK(m_pileup_pOverEvent.initialize(m_pileup));
 
  return StatusCode::SUCCESS;
}

process()

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

overridevirtual

standard Athena-Algorithm method

Definition at line 101 of file FastHitConvertTool.cxx.

{
  ATH_MSG_DEBUG("initEvent()");
  auto embHitContainer = SG::makeHandle<LArHitContainer>( m_embHitContainerKey, ctx );
  auto emecHitContainer = SG::makeHandle<LArHitContainer>( m_emecHitContainerKey, ctx );
  auto fcalHitContainer = SG::makeHandle<LArHitContainer>( m_fcalHitContainerKey, ctx );
  auto hecHitContainer = SG::makeHandle<LArHitContainer>( m_hecHitContainerKey, ctx );
  auto tileHitVector = SG::makeHandle<TileHitVector>(   m_tileHitVectorKey, ctx );
  embHitContainer = std::make_unique<LArHitContainer>( m_embHitContainerKey.key() );
  emecHitContainer = std::make_unique<LArHitContainer>( m_emecHitContainerKey.key() );
  fcalHitContainer = std::make_unique<LArHitContainer>( m_fcalHitContainerKey.key() );
  hecHitContainer = std::make_unique<LArHitContainer>( m_hecHitContainerKey.key() );
  tileHitVector = std::make_unique<TileHitVector>(   m_tileHitVectorKey.key() );
 
  ATH_MSG_DEBUG("ATLFASTIIDigi "<<this->name()<<" hitConstruction");
  const double minEnergy=1e-9;
  double hitTime=0.0;
  Identifier cellid((unsigned int) 0);
  double energy=0.0;
  double energyConv=0.0;
  float SampFrac=0.0;
 
  int countFastCell=0;
 
  double eLArEMRead=0.0;
  double eLArHECRead=0.0;
  double eLArFCALRead=0.0;
  double eTileRead=0.0;
 
  double eLArEMConv=0.0;
  double eLArHECConv=0.0;
  double eLArFCALConv=0.0;
  double eTileConv=0.0;
 
  SG::ReadCondHandle<ILArfSampl> fSamplHdl(m_fSamplKey, ctx);
  const ILArfSampl* fSampl=*fSamplHdl;
 
  CaloCellContainer::const_iterator it1=theCellCont->beginConstCalo(CaloCell_ID::LAREM);
  CaloCellContainer::const_iterator it2=theCellCont->endConstCalo(CaloCell_ID::LAREM);
  for(;it1!=it2;++it1)
    {
      ATH_MSG_DEBUG("FastCell LArEM"<<countFastCell);
 
      cellid=(*it1)->ID();
      energy=(*it1)->energy();
      SampFrac=fSampl->FSAMPL(cellid);
      energyConv=energy*SampFrac;
 
      eLArEMRead+=energy;
      eLArEMConv+=energyConv;
 
      ATH_MSG_DEBUG("ReadFastCell id= "<<cellid<<"E= "<<energy<<" SampFrac= "<<SampFrac);
      if(energyConv > minEnergy)
        {
          if(m_larEmID->is_lar_em(cellid))
            {
              if(m_larEmID->is_em_barrel(cellid))
                {
                  ATH_MSG_DEBUG("Storing em barrel hit");
                  embHitContainer->push_back(new LArHit(cellid,energyConv,hitTime));
                }
              else if(m_larEmID->is_em_endcap(cellid))
                {
                  ATH_MSG_DEBUG("Storing em endcap hit");
                  emecHitContainer->push_back(new LArHit(cellid,energyConv,hitTime));
                }
            }
        }
      countFastCell++;
    }
 
  it1=theCellCont->beginConstCalo(CaloCell_ID::LARHEC);
  it2=theCellCont->endConstCalo(CaloCell_ID::LARHEC);
 
  countFastCell=0;
  for(;it1!=it2;++it1)
    {
      ATH_MSG_DEBUG("FastCell LArHEC"<<countFastCell);
 
      cellid=(*it1)->ID();
      energy=(*it1)->energy();
      SampFrac=fSampl->FSAMPL(cellid);
      energyConv=energy*SampFrac;
 
      eLArHECRead+=energy;
      eLArHECConv+=energyConv;
 
      ATH_MSG_DEBUG("ReadFastCell id= "<<cellid<<"E= "<<energy<<"SampFrac= "<<SampFrac);
 
      if(energyConv>minEnergy)
        {
          if(m_larHecID->is_lar_hec(cellid))
            {
              ATH_MSG_DEBUG("Storing hec hit");
              hecHitContainer->push_back(new LArHit(cellid,energyConv,hitTime));
            }
        }
      countFastCell++;
    }
 
  it1=theCellCont->beginConstCalo(CaloCell_ID::LARFCAL);
  it2=theCellCont->endConstCalo(CaloCell_ID::LARFCAL);
  countFastCell=0;
  for(;it1!=it2;++it1)
    {
      ATH_MSG_DEBUG("FastCell LArFCAL"<<countFastCell);
      cellid=(*it1)->ID();
      energy=(*it1)->energy();
      SampFrac=fSampl->FSAMPL(cellid);
      energyConv=energy*SampFrac;
 
      eLArHECRead+=energy;
      eLArHECConv+=energyConv;
 
      ATH_MSG_DEBUG("ReadFastCell id= "<<cellid<<"E="<<energy<<"SampFrac="<<SampFrac);
      if(energyConv>minEnergy)
        {
          if(m_larFcalID->is_lar_fcal(cellid))
            {
              ATH_MSG_DEBUG("Storing fcal hit");
              fcalHitContainer->push_back(new LArHit(cellid,energyConv,hitTime));
            }
        }
      countFastCell++;
    }
 
  SG::ReadCondHandle<TileSamplingFraction> tileSamplingFraction(m_tileSamplingFractionKey, ctx);
  ATH_CHECK( tileSamplingFraction.isValid() );
 
  it1=theCellCont->beginConstCalo(CaloCell_ID::TILE);
  it2=theCellCont->endConstCalo(CaloCell_ID::TILE);
 
  countFastCell=0;
  Identifier pmt_id0((unsigned int) 0);
  Identifier pmt_id1((unsigned int) 0);
 
  for(;it1!=it2;++it1)
    {
      ATH_MSG_DEBUG("FastCell Tile Cal"<<countFastCell);
      cellid=(*it1)->ID();
      energy=(*it1)->energy();
 
      pmt_id0=m_tileID->pmt_id(cellid,0);
      pmt_id1=m_tileID->pmt_id(cellid,1);
 
      HWIdentifier channel_id = m_tileCabling->s2h_channel_id(pmt_id0);
      int channel = m_tileHWID->channel(channel_id);
      int drawerIdx = m_tileHWID->drawerIdx(channel_id);
      SampFrac = tileSamplingFraction->getSamplingFraction(drawerIdx, channel);
      energyConv=energy/SampFrac;
 
      eTileRead+=energy;
      eTileConv+=energyConv;
 
      ATH_MSG_DEBUG("ReadFastCell id= "<<cellid<<"E="<<energy<<"SampFrac"<<SampFrac);
      ATH_MSG_DEBUG("PMT_id0="<<pmt_id0<<"PMT_id1="<<pmt_id1);
      if(energyConv>minEnergy)
        {
          if(m_tileID->is_tile(cellid))
            {
              ATH_MSG_DEBUG("Storing tile hit");
              if(m_tileID->is_tile_gapscin(cellid))
                {
                  tileHitVector->push_back(TileHit(pmt_id0,energyConv,hitTime));
                }
              else
                {
                  tileHitVector->push_back(TileHit(pmt_id0,energyConv/2.0,hitTime));
                  tileHitVector->push_back(TileHit(pmt_id1,energyConv/2.0,hitTime));
                }
            }
        }
      countFastCell++;
    }
  ATH_MSG_DEBUG("eReadTot= "<<eLArEMRead+eLArHECRead+eLArFCALRead+eTileRead);
  ATH_MSG_DEBUG("eLArEMRead= "<<eLArEMRead<<" eLArHECRead= "<<eLArHECRead<<" eLArFCALRead= "<<eLArFCALRead<<" eTileRead= "<<eTileRead);
  ATH_MSG_DEBUG("eConvTot= "<<eLArEMConv+eLArHECConv+eLArFCALConv+eTileConv);
  ATH_MSG_DEBUG("eLArEMConv= "<<eLArEMConv<<" eLArHECConv= "<<eLArHECConv<<"eLArFCALConv"<<eLArFCALConv<<"eTileConv"<<eTileConv);
 
  ATH_MSG_DEBUG("finaliseEvent()");
  ATH_MSG_DEBUG(embHitContainer.name()<<" : "<<embHitContainer->size()<<" hits ");
  ATH_MSG_DEBUG(emecHitContainer.name()<<" : "<<emecHitContainer->size()<<" hits ");
  ATH_MSG_DEBUG(fcalHitContainer.name()<<" : "<<fcalHitContainer->size()<<" hits ");
  ATH_MSG_DEBUG(hecHitContainer.name()<<" : "<<hecHitContainer->size()<<" hits ");
  ATH_MSG_DEBUG(tileHitVector.name()<<" : "<<tileHitVector->size()<<" hits ");
 
  if(m_pileup)
    {
      CHECK((*m_storeGateFastCalo).clearStore(true));
      auto evt = SG::makeHandle<EventInfo>(m_pileup_evt, ctx);
      const EventInfo* newEvt=new EventInfo(*evt);
 
      // Migration note: this was an evtStore()->retrieve for a non-const pointer
      // Using a const_cast to preserve the old behaviour, but this is MT-unfriendly
      if (Gaudi::Concurrency::ConcurrencyFlags::numConcurrentEvents() > 1) {
         ATH_MSG_ERROR ("FastHitConvertTool doesn't support pileup in AthenaMT");
         return StatusCode::FAILURE;
      }
      auto pOverEventHandle = SG::makeHandle<PileUpEventInfo>(m_pileup_pOverEvent, ctx);
      auto pOverEvent ATLAS_THREAD_SAFE =  // we checked above that this is not MT
        const_cast<PileUpEventInfo*>(pOverEventHandle.get());
      pOverEvent->addSubEvt(0,PileUpTimeEventIndex::Signal,newEvt,&(*m_storeGateFastCalo));
    }
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_embHitContainerKey

SG::WriteHandleKey<LArHitContainer> FastHitConvertTool::m_embHitContainerKey {this,"embHitContainername","LArHitEMB","Name of output FastSim LAr EM Barrel Hit Container"}

private

Definition at line 67 of file FastHitConvertTool.h.

m_emecHitContainerKey

SG::WriteHandleKey<LArHitContainer> FastHitConvertTool::m_emecHitContainerKey {this,"emecHitContainername","LArHitEMEC","Name of output FastSim LAr EM Endcap Hit Container"}

private

Definition at line 68 of file FastHitConvertTool.h.

m_fcalHitContainerKey

SG::WriteHandleKey<LArHitContainer> FastHitConvertTool::m_fcalHitContainerKey {this,"fcalHitContainername","LArHitFCAL","Name of output FastSim LAr FCAL Hit Container"}

private

Definition at line 69 of file FastHitConvertTool.h.

m_fSamplKey

SG::ReadCondHandleKey<ILArfSampl> FastHitConvertTool::m_fSamplKey {this,"fSamplKey","LArfSamplSym","SG Key of LArfSampl object"}

private

Definition at line 76 of file FastHitConvertTool.h.

m_hecHitContainerKey

SG::WriteHandleKey<LArHitContainer> FastHitConvertTool::m_hecHitContainerKey {this,"hecHitContainername","LArHitHEC","Name of output FastSim LAr HEC Hit Container"}

private

Definition at line 70 of file FastHitConvertTool.h.

m_larEmID

const LArEM_ID* FastHitConvertTool::m_larEmID {nullptr}

private

Definition at line 90 of file FastHitConvertTool.h.

m_larFcalID

const LArFCAL_ID* FastHitConvertTool::m_larFcalID {nullptr}

private

Definition at line 91 of file FastHitConvertTool.h.

m_larHecID

const LArHEC_ID* FastHitConvertTool::m_larHecID {nullptr}

private

Definition at line 92 of file FastHitConvertTool.h.

m_pileup

Gaudi::Property<bool> FastHitConvertTool::m_pileup {this,"doPileup",false,"Pileup mode (default=false)"}

private

Definition at line 97 of file FastHitConvertTool.h.

m_pileup_evt

SG::ReadHandleKey<EventInfo> FastHitConvertTool::m_pileup_evt {this,"pileupEventInfo","MyEvent",""}

private

Definition at line 98 of file FastHitConvertTool.h.

m_pileup_pOverEvent

SG::ReadHandleKey<PileUpEventInfo> FastHitConvertTool::m_pileup_pOverEvent {this,"pileupOverlayEvent","OverlayEvent",""}

private

Definition at line 99 of file FastHitConvertTool.h.

m_pMergeSvc

PileUpMergeSvc* FastHitConvertTool::m_pMergeSvc {nullptr}

private

Definition at line 74 of file FastHitConvertTool.h.

m_storeGateFastCalo

ServiceHandle<StoreGateSvc> FastHitConvertTool::m_storeGateFastCalo

private

Definition at line 73 of file FastHitConvertTool.h.

m_tileCabling

const TileCablingService* FastHitConvertTool::m_tileCabling {nullptr}

private

Definition at line 95 of file FastHitConvertTool.h.

m_tileCablingSvc

ServiceHandle<TileCablingSvc> FastHitConvertTool::m_tileCablingSvc

private

Initial value:

{ this,
     "TileCablingSvc", "TileCablingSvc", "Tile cabling service"}

Name of Tile cabling service.

Definition at line 87 of file FastHitConvertTool.h.

m_tileHitVectorKey

SG::WriteHandleKey<TileHitVector> FastHitConvertTool::m_tileHitVectorKey {this,"tileHitContainername","TileHitVec","Name of output FastSim Tile Hit Container"}

private

Definition at line 71 of file FastHitConvertTool.h.

m_tileHWID

const TileHWID* FastHitConvertTool::m_tileHWID {nullptr}

private

Definition at line 94 of file FastHitConvertTool.h.

m_tileID

const TileID* FastHitConvertTool::m_tileID {nullptr}

private

Definition at line 93 of file FastHitConvertTool.h.

m_tileSamplingFractionKey

SG::ReadCondHandleKey<TileSamplingFraction> FastHitConvertTool::m_tileSamplingFractionKey

private

Initial value:

{this,
      "TileSamplingFraction", "TileSamplingFraction", "Input Tile sampling fraction"}

Name of TileSamplingFraction in condition store.

Definition at line 81 of file FastHitConvertTool.h.

---

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

• FastHitConvertTool.h
• FastHitConvertTool.cxx