FastHitConvertTool Class Reference

This is for the Doxygen-Documentation. More...

#include <FastHitConvertTool.h>

Inheritance diagram for FastHitConvertTool:

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

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"}
SG::ReadCondHandleKey< ILArfSampl >	m_fSamplKey {this,"fSamplKey","LArfSamplSym","SG Key of LArfSampl object"}
SG::ReadCondHandleKey< TileSamplingFraction >	m_tileSamplingFractionKey
	Name of TileSamplingFraction in condition store.
ServiceHandle< TileCablingSvc >	m_tileCablingSvc
	Name of Tile cabling service.
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}

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 43 of file FastHitConvertTool.h.

Constructor & Destructor Documentation

FastHitConvertTool()

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

Definition at line 28 of file FastHitConvertTool.cxx.

  :
  base_class(type,name,parent)
{
}

~FastHitConvertTool()

virtual FastHitConvertTool::~FastHitConvertTool ( )

inlinevirtual

default destructor

Definition at line 49 of file FastHitConvertTool.h.

{};

Member Function Documentation

initialize()

StatusCode FastHitConvertTool::initialize ( )

finaloverridevirtual

standard Athena-Algorithm method

Definition at line 44 of file FastHitConvertTool.cxx.

{
 
  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());
 
  return StatusCode::SUCCESS;
}

process()

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

overridevirtual

standard Athena-Algorithm method

Definition at line 81 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 ");
 
  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 60 of file FastHitConvertTool.h.

{this,"embHitContainername","LArHitEMB","Name of output FastSim LAr EM Barrel Hit Container"};

m_emecHitContainerKey

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

private

Definition at line 61 of file FastHitConvertTool.h.

{this,"emecHitContainername","LArHitEMEC","Name of output FastSim LAr EM Endcap Hit Container"};

m_fcalHitContainerKey

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

private

Definition at line 62 of file FastHitConvertTool.h.

{this,"fcalHitContainername","LArHitFCAL","Name of output FastSim LAr FCAL Hit Container"};

m_fSamplKey

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

private

Definition at line 66 of file FastHitConvertTool.h.

{this,"fSamplKey","LArfSamplSym","SG Key of LArfSampl object"};

m_hecHitContainerKey

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

private

Definition at line 63 of file FastHitConvertTool.h.

{this,"hecHitContainername","LArHitHEC","Name of output FastSim LAr HEC Hit Container"};

m_larEmID

const LArEM_ID* FastHitConvertTool::m_larEmID {nullptr}

private

Definition at line 80 of file FastHitConvertTool.h.

{nullptr};

m_larFcalID

const LArFCAL_ID* FastHitConvertTool::m_larFcalID {nullptr}

private

Definition at line 81 of file FastHitConvertTool.h.

{nullptr};

m_larHecID

const LArHEC_ID* FastHitConvertTool::m_larHecID {nullptr}

private

Definition at line 82 of file FastHitConvertTool.h.

{nullptr};

m_tileCabling

const TileCablingService* FastHitConvertTool::m_tileCabling {nullptr}

private

Definition at line 85 of file FastHitConvertTool.h.

{nullptr};

m_tileCablingSvc

ServiceHandle<TileCablingSvc> FastHitConvertTool::m_tileCablingSvc

private

Initial value:

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

Name of Tile cabling service.

Definition at line 77 of file FastHitConvertTool.h.

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

m_tileHitVectorKey

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

private

Definition at line 64 of file FastHitConvertTool.h.

{this,"tileHitContainername","TileHitVec","Name of output FastSim Tile Hit Container"};

m_tileHWID

const TileHWID* FastHitConvertTool::m_tileHWID {nullptr}

private

Definition at line 84 of file FastHitConvertTool.h.

{nullptr};

m_tileID

const TileID* FastHitConvertTool::m_tileID {nullptr}

private

Definition at line 83 of file FastHitConvertTool.h.

{nullptr};

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 71 of file FastHitConvertTool.h.

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

---

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

• FastHitConvertTool.h
• FastHitConvertTool.cxx