CaloTowerxAODFromCells Class Reference

#include <CaloTowerxAODFromCells.h>

Inheritance diagram for CaloTowerxAODFromCells:

Collaboration diagram for CaloTowerxAODFromCells:

Public Member Functions
	CaloTowerxAODFromCells (const std::string &name, ISvcLocator *pSvcLocator)
	Default algorithm constructor.
virtual	~CaloTowerxAODFromCells ()
	Baseclass destructor.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
@c AthAlgorithm interface implementation
virtual StatusCode	initialize () override
	Initialize algorithm.
virtual StatusCode	execute (const EventContext &ctx) const override
	Execute algorithm.
virtual StatusCode	finalize () override
	Finalize algorithm.

Protected Types
Internal mapping of cells to towers
typedef std::vector< std::vector< cellToTower_t > >	CellToTowerVec

Protected Member Functions
StatusCode	initBase ()
	<
SG::WriteHandle< xAOD::CaloTowerContainer >	makeContainer (const EventContext &ctx) const
	Intialize m_cellToTower cache.
const CellToTowerVec &	getIndexCache (const EventContext &ctx) const
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Protected Attributes
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloMgrKey
Algorithm properties
SG::WriteHandleKey< xAOD::CaloTowerContainer >	m_caloTowerContainerKey
	Handle to xAOD::CaloTowerContainer.
float	m_minEta
	Tower-grid: lower eta boundary.
float	m_maxEta
	Tower-grid: upper eta boundary.
int	m_nEtaBins
	Tower-grid: number of phi bins.
int	m_nPhiBins
	Tower-grid: number of phi bins.
bool	m_doxCheck
	Turn on internal checks (debugging)

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
StatusCode	fillIndexCache (const EventContext &ctx, CellToTowerVec &cellToTower) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
bool	m_filterCells
CxxUtils::CachedValue< CellToTowerVec >	m_cellToTower
	map of cell indices to tower indices and weights
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared
Algorithm properties
SG::ReadHandleKey< CaloCellContainer >	m_inputCellContainerKey
double	m_cellThresholdE
	Cell energy threshold (only for FilteredCell mode)

Detailed Description

Definition at line 19 of file CaloTowerxAODFromCells.h.

Member Typedef Documentation

CellToTowerVec

typedef std::vector<std::vector<cellToTower_t> > CaloTowerxAODAlgoBase::CellToTowerVec

protectedinherited

Definition at line 63 of file CaloTowerxAODAlgoBase.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

CaloTowerxAODFromCells()

CaloTowerxAODFromCells::CaloTowerxAODFromCells	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Default algorithm constructor.

Parameters

name	reference to non-modifiable name of algorithm instance
pSvcLocator	pointer to generic service locator

Definition at line 18 of file CaloTowerxAODFromCells.cxx.

  : CaloTowerxAODAlgoBase(name,pSvcLocator)
  , m_inputCellContainerKey("AllCalo")
  , m_cellThresholdE(std::numeric_limits<float>::min())
  , m_filterCells(false)
{
  declareProperty("InputCellContainer", m_inputCellContainerKey);
  declareProperty("CellEnergyThreshold", m_cellThresholdE);
}

~CaloTowerxAODFromCells()

CaloTowerxAODFromCells::~CaloTowerxAODFromCells ( )

virtualdefault

Baseclass destructor.

Member Function Documentation

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode CaloTowerxAODFromCells::execute ( const EventContext & ctx ) const

overridevirtual

Execute algorithm.

Definition at line 46 of file CaloTowerxAODFromCells.cxx.

{ 
  const CellToTowerVec& cellToTower = getIndexCache(ctx);
  if(cellToTower.empty()) {
    ATH_MSG_ERROR( "Failed to compute the index cache");
    return StatusCode::FAILURE;
  }
 
  SG::ReadHandle<CaloCellContainer> inputCellContainer(m_inputCellContainerKey, ctx);
  if (!inputCellContainer.isValid()) {
    ATH_MSG_ERROR( "Can't retrieve CaloCellContainer with key " << inputCellContainer.name()  );
    return StatusCode::FAILURE;
  }
 
  SG::WriteHandle<xAOD::CaloTowerContainer> caloTowerContainer =
    this->makeContainer(ctx);
  if (!caloTowerContainer.isValid())
    return StatusCode::FAILURE;
 
  const size_t nCell2Tower=cellToTower.size();
  if (nCell2Tower<inputCellContainer->size()) {
    ATH_MSG_ERROR( "Number of cells larger than size of internal cell2tower cache. nCells=" 
                   << inputCellContainer->size() <<  ", cell2tower size=" << nCell2Tower  );
    return StatusCode::FAILURE;
  }
 
  for (const CaloCell* cell : *inputCellContainer) {
    
    if (!m_filterCells || (cell->e()> m_cellThresholdE)) {
 
      const IdentifierHash cellHash=cell->caloDDE()->calo_hash();
      assert(cellHash<cellToTower.size());
      if (!(cellHash<cellToTower.size())) {
    ATH_MSG_ERROR( "Cell2Tower mapping too small " << cellToTower.size() << ", expected at least" << cellHash  );
        return StatusCode::FAILURE;
      }
      const auto& c2ts=cellToTower[cellHash];
      //Remember: A cell can contribute to more than one tower!
      for (const cellToTower_t& c2t : c2ts) {
    if (c2t.m_towerIdx > caloTowerContainer->size()) {
      ATH_MSG_ERROR( "Tower container size too small " << caloTowerContainer->size() << ", expected at least" << c2t.m_towerIdx  );
      return StatusCode::FAILURE;
    }
    (*caloTowerContainer)[c2t.m_towerIdx]->addEnergy(cell->e()*c2t.m_weight);
      }//end loop over towers coverd by this cell
    }// end if filter cells
  }//end loop over cells
 
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

fillIndexCache()

StatusCode CaloTowerxAODAlgoBase::fillIndexCache ( const EventContext & ctx, CellToTowerVec & cellToTower ) const

privateinherited

Definition at line 73 of file CaloTowerxAODAlgoBase.cxx.

{
  ATH_MSG_INFO("Filling cell -> tower index map");
 
  //Some basic sanity checks:
  if (m_minEta>=m_maxEta) {
    ATH_MSG_ERROR( "Configuration problem: minEta>=maxEta " << m_minEta << "," << m_maxEta  );
    return StatusCode::FAILURE;
  }
  
  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey,ctx};
  ATH_CHECK(caloMgrHandle.isValid());
  const CaloDetDescrManager* theManager = *caloMgrHandle;
 
  //Build a dummy CaloTowerContainer
  std::unique_ptr<xAOD::CaloTowerContainer> dummy(new xAOD::CaloTowerContainer());
 
  dummy->configureGrid(m_nEtaBins,m_minEta,m_maxEta,m_nPhiBins);
  
  const int nTowers=dummy->nTowers();
  
  if (nTowers<1) {
    ATH_MSG_ERROR( "Something went wrong with tower grid config: Got container with " << nTowers << " Towers."  );
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_INFO("Working on tower container with dEta=" << dummy->deltaEta() << ", dPhi=" 
           << dummy->deltaPhi() << ", nTowers=" << nTowers);
 
  cellToTower.clear();
  cellToTower.resize(theManager->element_size()); //fixme, get calo-hash-max
 
  //FCAL cells are not pointing. We slice them in smaller chunks to see in which tower they go 
  const std::array<double,3> ndxFCal={{4.,4.,6.}};
  const std::array<double,3> ndyFCal={{4.,6.,6.}};
 
  for (CaloDetDescrManager::calo_element_const_iterator ddeIt=theManager->element_begin();
       ddeIt!=theManager->element_end();++ddeIt) {
 
    const CaloDetDescrElement* dde=*ddeIt;
 
    if (dde->is_lar_fcal()) {
      //special handling of FCAL cells. Inspired by LArRecUtils/src/LArFCalTowerStore.cxx 
      double xCell  = dde->x();
      double yCell  = dde->y();
      double zCell  = dde->z();
      double dxCell = dde->dx();
      double dyCell = dde->dy();
 
      // get cell logical location
      int thisModule = dde->getLayer()-1; //modules are counted 1..n, convert to 0..n-1
      double theXBin   = dxCell / ndxFCal[thisModule];
      double theYBin   = dyCell / ndyFCal[thisModule];
      double theWeight = 1. / (ndxFCal[thisModule] * ndyFCal[thisModule]);
 
      // loop the cell fragments
      for (int iX=0;iX<ndxFCal[thisModule];++iX) {
    double x=xCell-dxCell/2.0 + iX*theXBin;
    for (int iY=0;iY<ndyFCal[thisModule];++iY) {
      double y=yCell-dyCell/2.0 + iY*theYBin;
 
      // eta,phi of fragment
      double r   = sqrt( x * x + y * y + zCell * zCell );
      double eta = -0.5 * log((r-zCell)/(r+zCell));
      double phi =  CaloPhiRange::fix(atan2(y,x));
      //int towerIdx=xAOD::CaloTowerGrid::index(dummy.get(),eta,phi);
      int towerIdx=dummy->index(eta,phi);
      if (towerIdx>=nTowers || towerIdx<0) {
        ATH_MSG_ERROR("Found invalid tower index for FCAL cell eta/phi " << eta << "/" << phi << ", x/y=" << x << "/" << y);
        return StatusCode::FAILURE;
      }
      //m_cellToTower[dde->calo_hash()].push_back(cellToTower_t(towerIdx,theWeight));
      cellToTower[dde->calo_hash()].emplace_back(towerIdx,theWeight);
      ATH_MSG_VERBOSE("cell hash " << dde->calo_hash() << ", goes into tower " << towerIdx << " with weight " << theWeight);
    } //end y loop
      } //end x loop
    }//end FCAL
 
    else { //Non-FCAL subcalos:
 
      const double cellDeta = dde->deta();
      const double cellDphi = dde->dphi();
      const double etaRaw   = dde->eta_raw();
      const double phiRaw   = CaloPhiRange::fix(dde->phi_raw());
      //The following lines ar copied from the old CaloTowerStore.cxx
      // calculate cell/tower size ratio (integer,[1..n])
      size_t ke = (size_t) (cellDeta/dummy->deltaEta()+0.5);
      ke = (ke==0) ? 1 : ke;
      size_t kp = (size_t) (cellDphi/dummy->deltaPhi()+0.5);
      kp = (kp==0) ? 1 : kp;
      // signal weight
      if ( ke>1 || kp>1 ) {
    ATH_MSG_VERBOSE( "Found cell [0x" << std::hex << dde->identify().get_compact() << std::dec 
                         << "] spanning several towers. nEta=" << ke << "nPhi="<<kp );
      }
 
 
      double theWeight = 1. / ( (double) ke * kp );
      // fractional cell sizes
      double cellDdeta = cellDeta / (double) ke;
      double cellDdphi = cellDphi / (double) kp;
      double etaMin    = etaRaw - cellDeta / 2.;
      double phiMin    = phiRaw - cellDphi / 2.;
    
      //Loop over cell fragments:
 
      for ( size_t ie=1; ie<=ke; ie++ ){                            // outer (eta) fragment loop
    double cellEta  = etaMin + ((double)ie - 0.5) * cellDdeta;        // eta of fragment
    for ( size_t ip=1; ip<=kp; ip++ ){                          // inner (phi) fragement loop
      double cellPhi = phiMin + ((double)ip - 0.5) * cellDdphi;       // phi of fragment
      int towerIdx=dummy->index(cellEta,cellPhi);
      if (towerIdx>=nTowers || towerIdx<0) {
        ATH_MSG_ERROR("Found invalid tower index " << towerIdx << " for cell eta/phi " << cellEta << "/" << cellPhi << " coming from " <<  dde->calo_hash() << "/" << ie << "/" << ip);
        return StatusCode::FAILURE;
      }
      cellToTower[dde->calo_hash()].push_back(cellToTower_t(towerIdx,theWeight));
      ATH_MSG_VERBOSE("cell hash " << dde->calo_hash() << ", goes into tower " << towerIdx << "with weight" << theWeight);
    }//end loop over fragments (phi)
      }// end loop over fragments (eta)
    }//end else FCAL
  }//end loop over detDescrElements
  
  
  if (m_doxCheck) {
    const CaloCell_ID* caloCellId;
    ATH_CHECK(detStore()->retrieve(caloCellId));
    for (size_t i=0;i<cellToTower.size(); ++i) {
      const auto& towerinfo=cellToTower[i];
      if (!towerinfo.empty()) {
    ATH_MSG_DEBUG("Cell with index " << i << " contributes to " << towerinfo.size() << " Towers.");
      }
      else {
    const Identifier id=caloCellId->cell_id(i);
    ATH_MSG_ERROR("Cell with index " << i << ", id=0x" 
              << std::hex << id.get_identifier32().get_compact() << std::dec 
              << "does not contribute to any tower!");  
      }
      double sumWeight=0;
      for (const  cellToTower_t& ct : towerinfo) sumWeight+=ct.m_weight;
      if (fabs(sumWeight-1)>0.001) {
    const Identifier id=caloCellId->cell_id(i);
    ATH_MSG_ERROR( "Cell with index " << i << ", id=0x" 
                       << std::hex << id.get_identifier32().get_compact() << std::dec 
                       << ": Weights don't add up to 1.0, got " << sumWeight  );
      }
    }//end loop over cells
  }//end if doxCheck
  
  ATH_MSG_DEBUG("Built CelltoTower index table. nCells=" << cellToTower.size() << ", nTowers=" << nTowers);
 
  return StatusCode::SUCCESS;
}

filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

finalize()

StatusCode CaloTowerxAODFromCells::finalize ( )

overridevirtual

Finalize algorithm.

Definition at line 98 of file CaloTowerxAODFromCells.cxx.

{ return StatusCode::SUCCESS; }

getIndexCache()

const CaloTowerxAODAlgoBase::CellToTowerVec & CaloTowerxAODAlgoBase::getIndexCache ( const EventContext & ctx ) const

protectedinherited

Definition at line 63 of file CaloTowerxAODAlgoBase.cxx.

{
  if(!m_cellToTower.isValid()) {
    CellToTowerVec cellToTower;
    if(fillIndexCache(ctx,cellToTower).isFailure()) cellToTower.clear();
    m_cellToTower.set(std::move(cellToTower));
  }
  return *m_cellToTower.ptr();
}

initBase()

StatusCode CaloTowerxAODAlgoBase::initBase ( )

protectedinherited

<

Initialization of this base-class

Create xAOD::CaloTowerContainer and auxiliary store

Definition at line 30 of file CaloTowerxAODAlgoBase.cxx.

                                           {
  ATH_CHECK( m_caloTowerContainerKey.initialize() );
  ATH_CHECK( m_caloMgrKey.initialize() );  
  return StatusCode::SUCCESS;
}

initialize()

StatusCode CaloTowerxAODFromCells::initialize ( )

overridevirtual

Initialize algorithm.

Definition at line 31 of file CaloTowerxAODFromCells.cxx.

                                              {
 
  m_filterCells=(m_cellThresholdE!=std::numeric_limits<float>::min());
  ATH_CHECK(m_inputCellContainerKey.initialize());
 
  // process modes
  if ( m_filterCells ) { 
    ATH_MSG_INFO("[Configuration::Status] FilterCell mode configured with Ecell > " << m_cellThresholdE << " MeV");
  } else { 
    ATH_MSG_INFO("[Configuration::Status] Using all cells");
  }
 
  return initBase();
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

makeContainer()

SG::WriteHandle< xAOD::CaloTowerContainer > CaloTowerxAODAlgoBase::makeContainer ( const EventContext & ctx ) const

protectedinherited

Intialize m_cellToTower cache.

Definition at line 38 of file CaloTowerxAODAlgoBase.cxx.

{
  SG::WriteHandle<xAOD::CaloTowerContainer> caloTowerContainer
    (m_caloTowerContainerKey, ctx);
 
  if( caloTowerContainer.record (std::make_unique<xAOD::CaloTowerContainer>(),
                                  std::make_unique<xAOD::CaloTowerAuxContainer>()).isSuccess())
  {
    // configure the container
    caloTowerContainer->configureGrid(m_nEtaBins,m_minEta,m_maxEta,m_nPhiBins);
 
    //Prefill the container:
    const int nTowers=caloTowerContainer->nTowers();
  
    for (int iTower=0;iTower<nTowers;++iTower) {
      xAOD::CaloTower* tower=new xAOD::CaloTower();
      caloTowerContainer->push_back(tower);
      tower->setEnergy(0.0);
    }
  }
  
  return caloTowerContainer;
}

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> CaloTowerxAODAlgoBase::m_caloMgrKey

protectedinherited

Initial value:

{ this
      , "CaloDetDescrManager"
      , "CaloDetDescrManager"
      , "SG Key for CaloDetDescrManager in the Condition Store" }

Definition at line 49 of file CaloTowerxAODAlgoBase.h.

                                                        { this
      , "CaloDetDescrManager"
      , "CaloDetDescrManager"
      , "SG Key for CaloDetDescrManager in the Condition Store" };

m_caloTowerContainerKey

SG::WriteHandleKey<xAOD::CaloTowerContainer> CaloTowerxAODAlgoBase::m_caloTowerContainerKey

protectedinherited

Handle to xAOD::CaloTowerContainer.

Definition at line 41 of file CaloTowerxAODAlgoBase.h.

m_cellThresholdE

double CaloTowerxAODFromCells::m_cellThresholdE

private

Cell energy threshold (only for FilteredCell mode)

Definition at line 45 of file CaloTowerxAODFromCells.h.

m_cellToTower

CxxUtils::CachedValue<CellToTowerVec> CaloTowerxAODAlgoBase::m_cellToTower

privateinherited

map of cell indices to tower indices and weights

Definition at line 77 of file CaloTowerxAODAlgoBase.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doxCheck

bool CaloTowerxAODAlgoBase::m_doxCheck

protectedinherited

Turn on internal checks (debugging)

Definition at line 46 of file CaloTowerxAODAlgoBase.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_filterCells

bool CaloTowerxAODFromCells::m_filterCells

private

Definition at line 48 of file CaloTowerxAODFromCells.h.

m_inputCellContainerKey

SG::ReadHandleKey<CaloCellContainer> CaloTowerxAODFromCells::m_inputCellContainerKey

private

Definition at line 44 of file CaloTowerxAODFromCells.h.

m_maxEta

float CaloTowerxAODAlgoBase::m_maxEta

protectedinherited

Tower-grid: upper eta boundary.

Definition at line 43 of file CaloTowerxAODAlgoBase.h.

m_minEta

float CaloTowerxAODAlgoBase::m_minEta

protectedinherited

Tower-grid: lower eta boundary.

Definition at line 42 of file CaloTowerxAODAlgoBase.h.

m_nEtaBins

int CaloTowerxAODAlgoBase::m_nEtaBins

protectedinherited

Tower-grid: number of phi bins.

Definition at line 44 of file CaloTowerxAODAlgoBase.h.

m_nPhiBins

int CaloTowerxAODAlgoBase::m_nPhiBins

protectedinherited

Tower-grid: number of phi bins.

Definition at line 45 of file CaloTowerxAODAlgoBase.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• CaloTowerxAODFromCells.h
• CaloTowerxAODFromCells.cxx