CaloTopoTowerFromClusterMaker Class Reference

A cluster builder tool forming topo-clusters representing calorimeter tower signals on a regular grid in \( (\eta,\phi) \) space. More...

#include <CaloTopoTowerFromClusterMaker.h>

Inheritance diagram for CaloTopoTowerFromClusterMaker:

Collaboration diagram for CaloTopoTowerFromClusterMaker:

Public Member Functions
	CaloTopoTowerFromClusterMaker (const std::string &type, const std::string &name, const IInterface *pParent)
	Tool constructor.
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	sysInitialize () override
	Perform system initialization for an algorithm.
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 AthAlgTool and @c CaloClusterCellProcessor interface implementations
virtual StatusCode	initialize () override
	Setting up the operational mode and corresponding parameters.
virtual StatusCode	execute (const EventContext &ctx, xAOD::CaloClusterContainer *pClusCont, CaloCellClusterWeights *cellWeights) const override
	Execute the tool and fill the xAOD::CaloClusterContainer pointed to by pClusCont.
virtual StatusCode	finalize () override
	Finalize the tool (no action).

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	Standard Gaudi interface ID method.

Protected Member Functions
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.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t
Internally used types
typedef std::vector< CaloProtoCluster >	protocont_t
	Container for CaloProtoCluster objects.
typedef std::size_t	uint_t
	Unsigned integral type.

Private Member Functions
bool	addCellToProtoCluster (const CaloTowerGeometry *towerGeo, const CaloCell *cptr, protocont_t &pProtoCont, double weight=1.) const
	Adding cells to proto-clusters.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>
Tower builders
uint_t	buildInclTowers (const CaloTowerGeometry *towerGeo, const CaloCellContainer &pCellCont, protocont_t &pProtoCont) const
	Inclusive towers.
uint_t	buildExclTowers (const CaloTowerGeometry *towerGeo, const CaloCellContainer &pCellCont, protocont_t &pProtoCont) const
	Exclusive towers.
uint_t	buildEMTopoTowers (const CaloTowerGeometry *towerGeo, const xAOD::CaloClusterContainer &clusCont, protocont_t &protoCont) const
	EM topo-towers.
uint_t	buildLCWTopoTowers (const CaloTowerGeometry *towerGeo, const xAOD::CaloClusterContainer &clusCont, protocont_t &protoCont, CaloCellClusterWeights *cellWeights) const
	LCW topo-towers.

Private Attributes
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
Tool properties
SG::ReadCondHandleKey< CaloTowerGeometry >	m_towerGeoKey {this,"TowerGeometry","CaloTowerGeometry"}
	the name of the key of the CaloTowerGeometry object in the ConditonsStore
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager"}
SG::ReadHandleKey< xAOD::CaloClusterContainer >	m_clusterContainerKey {this, "CaloTopoClusterContainerKey", "CaloTopoClusters", "SG Key for CaloClusterContainer (input)"}
	Topo-cluster container key.
SG::ReadHandleKey< CaloCellContainer >	m_cellContainerKey {this, "CaloCellContainerKey", "AllCalo", "SG Key for CaloCellContainer (input)"}
	Calorimeter cell container.
Gaudi::Property< bool >	m_orderByPt {this, "OrderClusterByPt", false, "Turn on/off pT-ordering of CaloClusterContainer (output)"}
	Orders cluster container by \( p_{\text{T}} \), default true.
Gaudi::Property< bool >	m_prepareLCW {this, "PrepareLCW", false, "Prepare data structure to apply LCW"}
	Prepare LCW calibration, default is false.
Gaudi::Property< bool >	m_useCellsFromClusters {this, "BuildTopoTowers", true, "Turn on/off topo-tower formation"}
	Use cells from topo-clusters if true, else use all cells, default is true.
Gaudi::Property< bool >	m_applyCellEnergyThreshold {this, "ApplyCellEnergyThreshold", false, "Turn on/off cell energy thresholds"}
	Apply cell energy threshold, default is false.
Gaudi::Property< bool >	m_doCellIndexCheck {this, "DoCellIndexCheck", false, "Check cell hash indices for consistency"}
	Check cell hash index consistency if true (default false).
Gaudi::Property< bool >	m_buildCombinedSignal {this, "BuildCombinedTopoSignal", false, "Build topo-clusters and topo-towers"}
	Build topo-clusters within given \( y \) range, else topo-towers.
Gaudi::Property< double >	m_energyThreshold {this, "CellEnergyThreshold", m_energyThresholdDef-1., "Energy threshold for cells filled in clusters"}
	Cell energy threshold, default is set in m_energyThresholdDef.
Gaudi::Property< double >	m_clusterRange {this, "TopoClusterRange", m_clusterRangeDef, "Rapidity range for using topo-clusters in combined signal mode"}
	Range where topo-clusters are used when m_buildCombinedSignal = true.
Gaudi::Property< bool >	m_removeSamplingData {this, "RemoveSamplingData", true, "Remove the associated sampling data"}
	Remove sampling data for towers.
Excluded samplings
std::vector< CaloSampling::CaloSample >	m_excludedSamplings
	List of excluded samplings (CaloSampling::CaloSample enumerators).
Gaudi::Property< std::vector< std::string > >	m_excludedSamplingsName {this, "ExcludedSamplings", {}, "Excluded samplings by name"}
	List of excluded samplings (human-readable names).
std::bitset< _CALOTOPOTOWERFROMCLUSTERMAKER_BITSET_SIZE >	m_excludedSamplingsPattern
	Bit pattern indicates if sampling is excluded.

Constants and parameters
uint_t	m_numberOfSamplings {static_cast<uint_t>(CaloSampling::Unknown)}
	Number of samplings.
static const double	m_energyThresholdDef = -100000000.
	Default energy threshold.
static const double	m_clusterRangeDef = 5.
	Default cluster \( y \) range.
static const uint_t	m_errorValueUINT = uint_t(-1)
	Error value for uint_t type values.

Internally used helpers
static xAOD::CaloCluster::ClusterSize	getClusterSize (uint_t etaBins, uint_t phiBins)
	Returns a cluster size tag from number of eta and phi bins in tower grid.
static xAOD::CaloCluster::ClusterSize	getClusterSize (uint_t towerBins)
	Returns a cluster size tag from number of towers (bins) in tower grid.
int	cleanupCells (const CaloTowerGeometry *towerGeo, CaloClusterCellLink *clk, uint_t nclus) const
	Checks CaloClusterCellLink for consistency.

Helpers
static bool	filterProtoCluster (const CaloClusterCellLink &clnk)
	Checks for and removes invalid cell links.
bool	checkCellIndices (const CaloTowerGeometry *towerGeo, const CaloDetDescrManager *caloDDM, const CaloCellContainer *pCellCont) const
	Checks consistency between cell indices and hash identifiers.
bool	isValidIndex (uint_t idx) const
	Checks if argument is a valid index value.
uint_t	badIndexValue () const
	Returns value indicating a bad index.

Detailed Description

A cluster builder tool forming topo-clusters representing calorimeter tower signals on a regular grid in \( (\eta,\phi) \) space.

By default, EM-scale topo-towers are created from cells in topo-clusters.

This tool fills EM-scale towers and stores them as xAOD::CaloCluster. It supports several operational modes, which are controlled by tool properties. It fills a container of type xAOD::CaloClusterContainer. The properties controlling its specific behavior are:

Properties defining tool behavior
Property name	Property type	Default value	Comment
OrderClusterByPt	bool	false	if true, the xAOD::CaloClusterContainer is ordered by \( p_{\rm T}^{\rm clus} \). See further comments below.
PrepareLCW	bool	false	if true, the tool fills a CaloCellClusterWeights object and records it into the event store to be used by CaloTopoClusterFromTowerCalibrator
UseCellsFromClusters	bool	true	if true, only cells from topo-clusters are used to fill the towers (topo-towers); else, inclusive towers are filled with all cells.
Properties setting variables for operational modes
Property name	Property type	Default value	Comment
CellEnergyThreshold	double	m_energyThresholdDef	cell energy threshold used in exclusive mode only. See further comments below.
CellContainerKey	SG::ReadHandleKey<CaloCellContainer>	"AllCalo"	cell container key is needed to pick up CaloCellContainer for all operational modes.
ClusterContainerKey	SG::ReadHandleKey<xAOD::CaloClusterContainer>	"CaloTopoClusters"	cluster container key is needed to pick up xAOD::CaloClusterContainer for filtered mode (UseCellsFromCluster = true)
CellClusterWeightKey	SG::WriteHandleKey<CaloCellClusterWeights>	−N/A−	key for CaloCellClusterWeights object is needed if PrepareLCW = true. Default is empty key.
BuildCombinedTopoSignal	bool	false	turns on combined topo-cluster/topo-tower output, with topo-clusters used within the rapidity range defined by TopoClusterRange and topo-towers elsewhere.

TopoClusterRange

double

5.

sets the range \( y_{\rm topo-cluster}^{\rm max} \) for using topo-clusters when BuildCombinedTopoSignal = true; topo-clusters with \( \left|y_{\rm topo-cluster}\right| < y_{\rm topo-cluster}^{\rm max} \) are used.

The towers can be classified as:

1. inclusive cell towers All cells are collected into inclusive towers, independent of their signal. Requires properties UseCellsFromClusters = false and UseCellEnergyThreshold = false. Only EM towers are possible, as cells not collected into topo-clustersdo not have a calibration applied.
2. exclusive cell towers Cells with \( E > E_{\rm min} \) are collected into exclusive towers. This behaviour is turned on by UseCellsFromClusters = false and UseCellEnergyThreshold = true. A meaningful CellEnergyThreshold value needs to be provided in addition.
3. filtered mode Cells contributing to standard topo-clusters are collected into topo-towers. This behaviour is triggered by UseCellsFromClusters = true. Optionally, LCW calibration can be applied to these towers by setting PrepareLCW = true and scheduling a CaloTopoClusterFromTowerCalibrator tool after the cluster moment calculators. The values of the UseEnergyThreshold and CellEnergyThreshold properties are ignored in this mode. A valid event store key needs to be provided in the to pick up the topo-cluster container. Note that building EM topo-towers requires topo-clusters on EM scale (no LCW applied) to get the correct geometrical cell weights only. LCW topo-towers require LCW scale topo-clusters to get the correct full geometrical and calibration weights.

4. mixed mode Cells contributing to standard topo-clusters are collected into towers if these topo-clusters are outside of a give rapidity range. The rapidity range is defined by the TopoClusterRange property. This mode is turned on by setting the property BuildCombinedTopoSignal = true. It is turned off by default (BuildCombinedTopoSignal = false). EM scale and LCW scale is possible, as in the filtered mode.

   Configuration 2 and 3 are exclusive, with 3 overwriting 2. The output topo-clusters represent calorimeter towers on the EM scale. The can be handed to cluster moment tools (needs EM scale) and, if desired, to a dedicated cluster calibration tool of type xAOD::CaloTowerClusterFromTowerCalibrator .
   

   To avoid multiple retrievals of the same weights by searching for cells in (many) topo-clusters, the overall weight of the cell signal is stored in a random access look-up table stored in a CaloCellClusterWeights object in the detector store. This object is created by this tool, if needed. If the tool property CellWeightLookupKey is set, this object will be generated, filled, and recorded. This is essential for calibrated topo-towers!

Definition at line 37 of file CaloTopoTowerFromClusterMaker.h.

Member Typedef Documentation

protocont_t

typedef std::vector<CaloProtoCluster> CaloTopoTowerFromClusterMaker::protocont_t

private

Container for CaloProtoCluster objects.

Definition at line 57 of file CaloTopoTowerFromClusterMaker.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 376 of file AthCommonDataStore.h.

uint_t

typedef std::size_t CaloTopoTowerFromClusterMaker::uint_t

private

Unsigned integral type.

Definition at line 58 of file CaloTopoTowerFromClusterMaker.h.

Constructor & Destructor Documentation

CaloTopoTowerFromClusterMaker()

CaloTopoTowerFromClusterMaker::CaloTopoTowerFromClusterMaker	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	pParent )

Tool constructor.

Definition at line 50 of file CaloTopoTowerFromClusterMaker.cxx.

  : AthAlgTool(type,name,pParent)
{
  declareInterface<CaloTowerCollectionProcessor>(this);
}

Member Function Documentation

addCellToProtoCluster()

bool CaloTopoTowerFromClusterMaker::addCellToProtoCluster ( const CaloTowerGeometry * towerGeo, const CaloCell * cptr, protocont_t & pProtoCont, double weight = 1. ) const

private

Adding cells to proto-clusters.

Returns

true if cell successfully added to one (or more) proto-clusters

Parameters

cptr	pointer ton non-modifiable CaloCell object
pProtoCont	reference to proto-cluster container
weight	additional (global) weight of cell (e.g. for geometrical weight for combined EM-scale signals)

Definition at line 417 of file CaloTopoTowerFromClusterMaker.cxx.

{
  // invalid input
  if ( cptr == nullptr ) { return false; }
 
  // get towers for cell from geometry service
  uint_t nctr(0);
  for ( auto elm : towerGeo->getTowers(cptr->caloDDE()->calo_hash()) ) { 
    auto towerIdx(towerGeo->towerIndex(elm));
    if ( !towerGeo->isInvalidIndex(towerIdx) ) {
      if ( !m_excludedSamplingsPattern[(size_t)cptr->caloDDE()->getSampling()] ) {
    uint_t cellIdx(pProtoCont.at(towerIdx).getCellLinks()->getCellContainer()->findIndex(cptr->caloDDE()->calo_hash()));
    pProtoCont[towerIdx].addCell(cellIdx,towerGeo->cellWeight(elm)*weight); ++nctr; 
      }
    }
  }
  return nctr > 0;
}

badIndexValue()

CaloTopoTowerFromClusterMaker::uint_t CaloTopoTowerFromClusterMaker::badIndexValue ( ) const

inlineprivate

Returns value indicating a bad index.

Definition at line 145 of file CaloTopoTowerFromClusterMaker.h.

{ return m_errorValueUINT;       } 

buildEMTopoTowers()

CaloTopoTowerFromClusterMaker::uint_t CaloTopoTowerFromClusterMaker::buildEMTopoTowers ( const CaloTowerGeometry * towerGeo, const xAOD::CaloClusterContainer & clusCont, protocont_t & protoCont ) const

private

EM topo-towers.

Definition at line 284 of file CaloTopoTowerFromClusterMaker.cxx.

{
  // presets
  uint_t cCtr(0);
  std::vector<bool> cellTags(towerGeo->totalNumberCells(),false);
 
  // -- EM scale clusters
  if ( !m_buildCombinedSignal ) { 
    // topo-towers
    for ( const auto *pClus : pClusCont ) { 
      for ( auto fCell(pClus->cell_begin()); fCell != pClus->cell_end(); ++fCell ) { 
    uint_t cidx(static_cast<uint_t>((*fCell)->caloDDE()->calo_hash()));
    if ( cidx < cellTags.size() ) {
      if ( !cellTags.at(cidx) ) { cellTags[cidx] = this->addCellToProtoCluster(towerGeo,*fCell,pProtoCont); }  
    } else {
      ATH_MSG_ERROR( CaloRec::Helpers::fmtMsg("Invalid cell hash index %6zu >= maximum index %6zu for cell in %s at (eta,phi) = (%6.3f,%6.3f)",
                          cidx,cellTags.size(),CaloSampling::getSamplingName((*fCell)->caloDDE()->getSampling()).c_str(),(*fCell)->eta(),(*fCell)->phi()) );
      return m_errorValueUINT;
    }
      } // end cells-in-cluster loop
    } // end cluster loop
  } else { 
    // selected topo-towers for combined signal
    std::vector<std::tuple<const CaloCell*,double> > cellList(towerGeo->totalNumberCells(),std::tuple<const CaloCell*,double>(nullptr,0.));
    for ( const auto *pClus : pClusCont ) { 
      if ( std::abs(pClus->eta()) > m_clusterRange ) { 
    for ( auto fCell(pClus->cell_begin()); fCell != pClus->cell_end(); ++fCell ) { 
      uint_t cidx(static_cast<uint_t>((*fCell)->caloDDE()->calo_hash()));
      if ( cellTags.at(cidx) ) { 
        std::get<1>(cellList[cidx]) += fCell.weight();
      } else { 
        cellList[cidx] = std::tuple<const CaloCell*,double>(*fCell,fCell.weight());
        cellTags[cidx] = true; 
      } 
    } // cell in cluster loop
      } else { 
    ++cCtr; 
      } // cluster range check
    } // cluster loop
    // fill proto-cluster
    for ( auto tpl : cellList ) { this->addCellToProtoCluster(towerGeo,std::get<0>(tpl),pProtoCont,std::get<1>(tpl)); }
  } // end of fill mode
 
  //
  return cCtr+pProtoCont.size();
}

buildExclTowers()

CaloTopoTowerFromClusterMaker::uint_t CaloTopoTowerFromClusterMaker::buildExclTowers ( const CaloTowerGeometry * towerGeo, const CaloCellContainer & pCellCont, protocont_t & pProtoCont ) const

private

Exclusive towers.

Definition at line 399 of file CaloTopoTowerFromClusterMaker.cxx.

{
  // loop cell container
  uint_t icl(0);
  for ( const auto *cptr : pCellCont ) {
    if ( cptr == nullptr ) { 
      ATH_MSG_ERROR( CaloRec::Helpers::fmtMsg("CaloCellContainer[%6zu] contains invalid cell object pointer %p",icl,(void*)cptr) ); 
      return m_errorValueUINT;
    } else {
      // existing cell with energy above threshold
      if ( cptr->e() > m_energyThreshold ) { this->addCellToProtoCluster(towerGeo,cptr,pProtoCont); }
    } // end pointer check
    ++icl;
  } // end cell loop
  //return StatusCode::SUCCESS;
  return pProtoCont.size();
}

buildInclTowers()

CaloTopoTowerFromClusterMaker::uint_t CaloTopoTowerFromClusterMaker::buildInclTowers ( const CaloTowerGeometry * towerGeo, const CaloCellContainer & pCellCont, protocont_t & pProtoCont ) const

private

Inclusive towers.

Returns

false in case of problems with data access or inconsistent data structures

Parameters

pCellCont	reference to non-modifiable CaloCellContainer@param pProtoCont reference to CaloProtoCluster container filled on output.
clusCont	reference to non-modifiable xAOD::CaloClusterContainer@param protoCont reference to modifiable proto-cluster container

Returns

Definition at line 381 of file CaloTopoTowerFromClusterMaker.cxx.

{
  // loop cell container - counter icl replaces cell hash index for NULL pointers in cell container
  uint_t icl(0);
  for ( const auto *cptr : pCellCont ) { 
    if ( cptr == nullptr ) { 
      ATH_MSG_ERROR( CaloRec::Helpers::fmtMsg("CaloCellContainer[%6zu] contains invalid cell object pointer %p",icl,(void*)cptr) ); 
      return m_errorValueUINT;
    } else {
      // existing cell with non-zero energy (negative or positive)
      if ( std::fabs(cptr->e()) > 0. ) { this->addCellToProtoCluster(towerGeo,cptr,pProtoCont); }
    } // end pointer check 
    ++icl;
  } // end cell loop
  return pProtoCont.size();
}

buildLCWTopoTowers()

CaloTopoTowerFromClusterMaker::uint_t CaloTopoTowerFromClusterMaker::buildLCWTopoTowers ( const CaloTowerGeometry * towerGeo, const xAOD::CaloClusterContainer & clusCont, protocont_t & protoCont, CaloCellClusterWeights * cellWeights ) const

private

LCW topo-towers.

Definition at line 332 of file CaloTopoTowerFromClusterMaker.cxx.

{ 
  // Need to keep track of LCW weights (up to two per cell) available from the topo-cluster(s) the cell is assigned to.
  // Each cell in a topo-cluster is, at first occurance, added to the CaloProtoCluster(s) representing the tower(s) and its
  // LCW calibration weight is stored in a lookup table indexed by the calorimeter hash id of the cell. The second 
  // time the same cell is found in another topo-cluster, only its LCW weight is added to the lookup table (stored in
  // CaloCellClusterWeights for use in the downstream tower calibration tool) - the assignment to tower(s) has already
  // happened.
 
  uint_t cCtr(0);
  // project cells on tower grid
  if ( !m_buildCombinedSignal ) { 
    // loop original topo-cluster container
    for ( const auto *pClus : pClusCont ) { 
      // loop over cells in the original topo-cluster
      for ( auto fCell(pClus->cell_begin()); fCell != pClus->cell_end(); ++fCell ) {
    // map to towers only once
    if ( !cellWeights->check(*fCell) ) { this->addCellToProtoCluster(towerGeo,*fCell,pProtoCont); }
    // store all associated LCW weights
    cellWeights->set(*fCell,fCell.weight());
      } // end cells-in-cluster loop
    } // end cluster loop
  } else { 
    // loop topo-cluster
    for ( const auto *pClus : pClusCont ) {
      // keep top-clusters in configured eta range
      if ( std::abs(pClus->eta()) > m_clusterRange ) { 
    // loop over cells of topo-clusters for the forward towards 
    for ( auto fCell(pClus->cell_begin()); fCell != pClus->cell_end(); ++fCell ) {
      // map to towers only once
      if ( !cellWeights->check(*fCell) ) { this->addCellToProtoCluster(towerGeo,*fCell,pProtoCont); }
      // store all associated LCW weights
      cellWeights->set(*fCell,fCell.weight());
    } // end cells-in-cluster loop
      } else { 
    ++cCtr; 
      } // end range check
    } // end cluster loop
  } // end combined signal check
 
  //
  return cCtr+pProtoCont.size();
}

checkCellIndices()

bool CaloTopoTowerFromClusterMaker::checkCellIndices ( const CaloTowerGeometry * towerGeo, const CaloDetDescrManager * caloDDM, const CaloCellContainer * pCellCont ) const

private

Checks consistency between cell indices and hash identifiers.

Definition at line 501 of file CaloTopoTowerFromClusterMaker.cxx.

{
  // input and setup checks //
 
  // check argument
  if ( pCellCont == nullptr ) { 
    ATH_MSG_WARNING( CaloRec::Helpers::fmtMsg("Invalid pointer to CaloCellContainer (%p)",(void*)pCellCont) ); return false;
  } else if ( pCellCont->empty() ) { 
    ATH_MSG_WARNING( CaloRec::Helpers::fmtMsg("CaloCellContainer at %p is empty (size %zu)",(void*)pCellCont,pCellCont->size()) ); return false; 
  }
  // check the atomic state
  if ( CaloTopoTowerFromClusterMaker_checkCellIndices ) { return true; }
  // set the atomic flag
  ATH_MSG_INFO( "Cell hash index check requested" ); 
  CaloTopoTowerFromClusterMaker_checkCellIndices = true;
  // assign output file
  std::string algname(this->name());
  if ( algname.find_last_of('.') != std::string::npos ) { algname = algname.substr(algname.find_last_of('.')+1); }
  std::string logname(CaloRec::Helpers::fmtMsg("%s.cellhash_index_check.dat",this->name().c_str())); 
  std::ofstream logstream; logstream.open(logname);
  if ( !logstream.is_open() ) { 
    ATH_MSG_WARNING( CaloRec::Helpers::fmtMsg("Cannot open log file \042%s\042 - no hash index checking",logname.c_str()) ); 
    return false;
  }
  logstream << "##########################################################################\n";
  logstream << "### This file contains a list of CaloCell indices in CaloCellContainer ###\n";
  logstream << "### for which this index is not the same as the calorimeter cell hash  ###\n";
  logstream << "### identifier. An empty list indicates full consistency between this  ###\n";
  logstream << "### index and the hash identifier for all cells.                       ###\n";
  logstream << "##########################################################################\n";
  logstream << "<begin list>--------------------------------------------------------------\n";

  // loop cell container //
 
  // prepare tag store
  size_t ifc(0);
  auto chkflg = std::make_unique<std::bitset<200000> >();
  chkflg->reset();
  for ( size_t i(0); i<pCellCont->size(); ++i ) { 
    if ( pCellCont->at(i) != nullptr ) { 
      size_t chash((size_t)pCellCont->at(i)->caloDDE()->calo_hash());
      if ( chash != i ) {
    std::string cni("UKNOWN");
    double etai(0.); double phii(0.);
    const CaloDetDescrElement* iel = i < caloDDMgr->element_size() ? caloDDMgr->get_element(i) : nullptr;
    if ( iel != nullptr ) {
      cni  = CaloRec::Lookup::getSamplingName(iel->getSampling());
      etai = iel->eta_raw();
      phii = iel->phi_raw();
    }
    std::string cnc("UNKNOWN");
    double etac(0.); double phic(0.);
    const CaloDetDescrElement* cel = chash < caloDDMgr->element_size() ? caloDDMgr->get_element(chash) : nullptr;
    if ( cel != nullptr ) { 
      cnc  = CaloRec::Lookup::getSamplingName(cel->getSampling());
      etac = cel->eta_raw();
      phic = cel->phi_raw();
    }
    size_t cidx(pCellCont->findIndex(chash));
    logstream << CaloRec::Helpers::fmtMsg("[%06zu] Cell %6zu [%12.12s %5.3f %5.3f] non-matching id %6zu [%12.12s %5.3f %5.3f] findCell() index %6zu",
                          ++ifc,i,cni.c_str(),etai,phii,chash,cnc.c_str(),etac,phic,cidx) << '\n'; 
      }
      chkflg->set(chash);
    }
  }
  logstream << "<end list>----------------------------------------------------------------\n";
  logstream.close();

  // check missed hashes //
 
  // number of non-matched hashes
  if ( ifc > 0 ) { 
    ATH_MSG_DEBUG( CaloRec::Helpers::fmtMsg("Found %zu non-matching cell hashes",ifc) );
  }
  // list of non-matched hashes
  std::vector<size_t> chl; chl.reserve(towerGeo->totalNumberCells());
  for ( size_t i(0); i<chl.size(); ++i ) { if ( !chkflg->test(i) ) { chl.push_back(i); } }
  if ( !chl.empty() ) { 
    for ( auto h : chl ) { ATH_MSG_DEBUG( CaloRec::Helpers::fmtMsg("Cell hash %6zu not in CaloCellContainer",h) ); }
  }
 
  return true;
}

cleanupCells()

int CaloTopoTowerFromClusterMaker::cleanupCells ( const CaloTowerGeometry * towerGeo, CaloClusterCellLink * clk, uint_t nclus ) const

private

Checks CaloClusterCellLink for consistency.

Definition at line 455 of file CaloTopoTowerFromClusterMaker.cxx.

{
  // Any pathology here probably indicates a configuration problem with the conditions (geometry)
  // database (wrong tag for data?)
 
  // check on null pointers in cell links
  int nrc(0); int hid(0);
  auto fcell(clk->begin());
  while ( fcell != clk->end() ) {
    const CaloCell* pCell = *fcell;
    auto nc(clk->getCellContainer()->size());
    const CaloCell* aCell = fcell.index() < nc ? clk->getCellContainer()->at(fcell.index()) : (const CaloCell*)nullptr;
    if ( pCell == nullptr ) {
      ATH_MSG_WARNING( CaloRec::Helpers::fmtMsg("CaloCellContainer[%6u/%6zu] - tower %5zu at (%6.3f,%6.3f) - cell pointer invalid (%p/%p) [removed %3i of %3zu cells]",
                        fcell.index(),nc-1,nclus,towerGeo->towerEta(nclus),towerGeo->towerPhi(nclus),
                        (void*)pCell,(void*)aCell,++nrc,clk->size()) );
      fcell = clk->removeCell(fcell);
    } else {
      uint_t chash(static_cast<uint_t>(pCell->caloDDE()->calo_hash()));
      uint_t csamp(static_cast<uint_t>(pCell->caloDDE()->getSampling()));
      if (chash > towerGeo->maxCellHash() ) {
    // check cell hash
    ATH_MSG_WARNING( CaloRec::Helpers::fmtMsg("Tower %5zu at (%6.3f,%6.3f) linked cell %3i - cell hash index (%6zu/%6zu) invalid",
                          nclus,towerGeo->towerEta(nclus),towerGeo->towerPhi(nclus),hid,chash,towerGeo->maxCellHash()) );
    fcell = clk->removeCell(fcell); ++nrc;
      } else if ( csamp >= m_numberOfSamplings ) {
    // check sampling id
    ATH_MSG_WARNING( CaloRec::Helpers::fmtMsg("Tower %5zu at (%6.3f,%6.3f) linked cell %3i -cell sampling id (%3zu/%3zu) invalid",
                          nclus,towerGeo->towerEta(nclus),towerGeo->towerPhi(nclus),hid,csamp,m_numberOfSamplings) );
    fcell = clk->removeCell(fcell); ++nrc;
      } else if ( fcell.weight() <= 0.0000001 ) { 
    // remove cells with 0 weight 
    fcell = clk->removeCell(fcell); ++nrc;
      } else { 
    // next cell 
    ++fcell;
      }
    } // end remove cell due to pointer invalid
    ++hid;
  } // end loop on cells in cell link object
  return nrc;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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 CaloTopoTowerFromClusterMaker::execute ( const EventContext & ctx, xAOD::CaloClusterContainer * pClusCont, CaloCellClusterWeights * cellWeights ) const

overridevirtual

Execute the tool and fill the xAOD::CaloClusterContainer pointed to by pClusCont.

Implements CaloTowerCollectionProcessor.

Definition at line 163 of file CaloTopoTowerFromClusterMaker.cxx.

{
  // Check input //
 
  // CaloCellContainer is needed to construct CaloProtoCluster
  SG::ReadHandle<CaloCellContainer> pCellCont(m_cellContainerKey,ctx);
  if ( !pCellCont.isValid() ) { 
    ATH_MSG_ERROR("Cannot allocate CaloCellContainer with key <" << m_cellContainerKey << ">");
    return StatusCode::FAILURE;
  }
 
  SG::ReadCondHandle<CaloTowerGeometry> towerGeoHandle{m_towerGeoKey,ctx};
  const CaloTowerGeometry* towerGeo=*towerGeoHandle;
 
  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey,ctx};
  const CaloDetDescrManager* caloDDMgr = *caloMgrHandle;
 
 
  if ( msgLvl(MSG::DEBUG) && towerGeo->totalNumberCells() != pCellCont->size() ) { 
    ATH_MSG_DEBUG( CaloRec::Helpers::fmtMsg("[mismatch] number of cells in CaloCellContainer %6zu, total number of cell descriptors %6zu",
                          pCellCont->size(),towerGeo->totalNumberCells()) );
  }
 
  if ( m_doCellIndexCheck ) { this->checkCellIndices(towerGeo,caloDDMgr, pCellCont.cptr()); }

  // Set up ProtoCluster //
 
  // index of CaloProtoCluster in container relates to tower position! DO NOT sort, shuffle, or remove elements!  
  size_t numberOfTowers=towerGeo->towerBins();
  protocont_t pProtoCont; pProtoCont.reserve(numberOfTowers);
  for ( uint_t i(0); i<numberOfTowers; ++i ) { pProtoCont.push_back(CaloProtoCluster(pCellCont.cptr())); }

  // Apply overall cell filter and fill protoclusters //
 
  // The weights extracted for cells from clusters are LCW weights (typically). The total
  // contribution of a LCW-weighted cell to towers is Ecell*Weight_LCW*Weight_tower.
 
  // If EM clusters are used, the weights of a clustered cell are completely defined
  // by the tower grid. As cells can shared between clusters, each cell can only be
  // projected onto the towergrid once, with Ecell*Weight_tower
 
  // The CaloCellClusterWeights object is used to store the combined LCW weight.
  // for each clustered cell. In case of EM, the LCW weights are ignored and this
  // object is not used - a simple vector<bool> tags cells already put into towers.
 
  uint_t cCtr(0);
  if ( m_useCellsFromClusters ) {
    // retrieve topo-cluster container for topo-towers
    SG::ReadHandle<xAOD::CaloClusterContainer> pTopoClusCont(m_clusterContainerKey,ctx);
    if ( !pTopoClusCont.isValid() ) {
      ATH_MSG_ERROR("Cannot allocate xAOD::CaloClusterContainer with key <" << m_clusterContainerKey << ">");
      return StatusCode::FAILURE;
    } // check on ReadHandle validity
    cCtr = m_prepareLCW && cellWeights != nullptr ? this->buildLCWTopoTowers(towerGeo,*pTopoClusCont,pProtoCont,cellWeights) : this->buildEMTopoTowers(towerGeo,*pTopoClusCont,pProtoCont);
    if ( !isValidIndex(cCtr) ) { ATH_MSG_WARNING("problems building EM or LCW topo-towers"); return StatusCode::SUCCESS; }
  } else {
    // fill inclusive/exclusive towers
    cCtr = m_applyCellEnergyThreshold ?  this->buildExclTowers(towerGeo,*pCellCont,pProtoCont) : this->buildInclTowers(towerGeo,*pCellCont,pProtoCont);
    if ( !isValidIndex(cCtr) ) { ATH_MSG_WARNING("problems building EM inclusive or exclusive towers"); return StatusCode::SUCCESS; }
  } // end topo-towers/inclusive-exclusive towers
  
  
  
  // allocate sufficient space in vector
  pClusCont->reserve(cCtr);
  // pick up cluster size tag and set up counter
  xAOD::CaloCluster::ClusterSize csize = CaloTopoTowerFromClusterMaker::getClusterSize(numberOfTowers);
  // loop proto-clusters
  for ( uint_t ipc(0); ipc<pProtoCont.size(); ++ipc ) {
    CaloProtoCluster& pProto  = pProtoCont.at(ipc);                              // pick up proto-cluster
    std::unique_ptr<CaloClusterCellLink> lptr(pProto.releaseCellLinks());        // take over CaloClusterCellLink object
    this->cleanupCells(towerGeo,lptr.get(),ipc);                                 // clean up cell links 
    if ( CaloTopoTowerFromClusterMaker::filterProtoCluster(*lptr.get()) ) {      // ignore empty proto-clusters (no cells assigned)
      xAOD::CaloCluster* clptr = pClusCont->push_back(new xAOD::CaloCluster());  // new empty cluster
      clptr->addCellLink(std::move(lptr));                                       // transfer cell links to CaloCluster
      clptr->setClusterSize(csize);                                              // set the cluster size spec
      CaloRec::Helpers::calculateKine(clptr,false);                              // calculate kinematics and other signals from cells
      if ( m_removeSamplingData ) {                                              // remove sampling data and invalidate tower center 
    clptr->clearSamplingData(); clptr->setEta0(0.); clptr->setPhi0(0.); 
      } else {                                                                   // keep sampling data and valid tower center
    clptr->setEta0(towerGeo->towerEta(ipc)); clptr->setPhi0(towerGeo->towerPhi(ipc));              
      }
    }
  } // proto-cluster loop
 
  // clean up proto-cluster container
  pProtoCont.clear();

  // Sorting //
 
  // All towers/clusters at this point are on EM scale. Sorting LCW towers by pT should be done in the 
  // CaloTopoClusterFromTowerCalibrator tool to assure desired ordering on the final scale.
  // The link between tower location and index of tower representation (CaloCluster) in its
  // container is definitively broken after sorting (was never ok in mixed cluster/tower mode).
  if ( m_orderByPt ) { 
    std::sort(pClusCont->begin(),pClusCont->end(),[](xAOD::CaloCluster* pc1,xAOD::CaloCluster* pc2) {
    volatile double pt1(pc1->pt()); // FIXME needed? (this was just copied)
    volatile double pt2(pc2->pt()); // FIXME needed? (this was just copied)
    return ( pt1 > pt2 );  
      }
      );
  } // end ordered by pT
 
  return StatusCode::SUCCESS;
} // end execute

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

filterProtoCluster()

bool CaloTopoTowerFromClusterMaker::filterProtoCluster ( const CaloClusterCellLink & clnk )

staticprivate

Checks for and removes invalid cell links.

Definition at line 498 of file CaloTopoTowerFromClusterMaker.cxx.

{ return clnk.size() > 0; }

finalize()

StatusCode CaloTopoTowerFromClusterMaker::finalize ( )

overridevirtual

Finalize the tool (no action).

Definition at line 160 of file CaloTopoTowerFromClusterMaker.cxx.

{ return StatusCode::SUCCESS; }

getClusterSize() [1/2]

xAOD::CaloCluster::ClusterSize CaloTopoTowerFromClusterMaker::getClusterSize ( uint_t etaBins, uint_t phiBins )

staticprivate

Returns a cluster size tag from number of eta and phi bins in tower grid.

Definition at line 442 of file CaloTopoTowerFromClusterMaker.cxx.

{ return CaloTopoTowerFromClusterMaker::getClusterSize(etaBins*phiBins); }

getClusterSize() [2/2]

xAOD::CaloCluster::ClusterSize CaloTopoTowerFromClusterMaker::getClusterSize ( uint_t towerBins )

staticprivate

Returns a cluster size tag from number of towers (bins) in tower grid.

Definition at line 445 of file CaloTopoTowerFromClusterMaker.cxx.

{
  // check for tower sizes
  return nTowers == 6400                    // known "standard" towers 0,1 x 0.1
    ? xAOD::CaloCluster::Tower_01_01 
    : nTowers == 25600                      // known "fine" towers 0.05 x 0.05
    ? xAOD::CaloCluster::Tower_005_005 
    : xAOD::CaloCluster::Tower_fixed_area;  // unspecified towers 
}

initialize()

StatusCode CaloTopoTowerFromClusterMaker::initialize ( )

overridevirtual

Setting up the operational mode and corresponding parameters.

Definition at line 58 of file CaloTopoTowerFromClusterMaker.cxx.

{
  //--------------------//
  // Set up handle keys //
  //--------------------//
 
  ATH_CHECK(m_cellContainerKey.initialize());
  
  //---------------------//
  // Check configuration //
  //---------------------//
 
  ATH_CHECK(m_towerGeoKey.initialize());
  ATH_CHECK(m_caloMgrKey.initialize());
 
  // tower builder configurations
  if ( m_useCellsFromClusters ) {
    // topo-tower
    ATH_MSG_INFO("Configure for building topo-towers (filtered mode):");
    // energy threshold not (yet) implemented for topo-towers
    if ( m_applyCellEnergyThreshold ) {
      ATH_MSG_WARNING("[ignore] cannot apply energy thresholds to topo-towers!");
      m_applyCellEnergyThreshold = false;
    }
    ATH_CHECK(m_clusterContainerKey.initialize());
    // // check on request for LCW
    // if ( m_prepareLCW ) { 
    //   ATH_CHECK(m_cellClusterWeightKey.initialize());
    //   ATH_MSG_INFO("[accept] prepare for LCW calibration - initialize CaloCellClusterWeights key object <" << m_cellClusterWeightKey << ">");
    // } else {
    //   ATH_MSG_INFO("[accept] use EM scale");
    // }
  } else { 
    // inclusive/exclusive towers
    ATH_MSG_INFO("Configure for building cell towers:");
    if ( m_applyCellEnergyThreshold ) { 
      ATH_MSG_INFO("[accept] configure exclusive towers: use cell energy threshold");
      if ( m_energyThreshold < m_energyThresholdDef ) { 
    ATH_MSG_ERROR("######## [reject] invalid cell energy threshold " << m_energyThreshold/Athena::Units::GeV 
              << " GeV is smaller than default (no-op) " << m_energyThresholdDef/Athena::Units::GeV << " GeV - fatal");
    return StatusCode::FAILURE;
      }
      ATH_MSG_INFO("######## [accept] energy threshold for cells to contribute to towers is " << m_energyThreshold/Athena::Units::GeV << " GeV");
    } else {
      ATH_MSG_INFO("[accept] configure inclusive towers");
    } // end inclusive/exclusive tower configuration
  } // end tower builder configuration
 
  // local data (constant parameters)
  //m_numberOfCells  = m_towerGeometrySvc->totalNumberCells();
  //m_maxCellHash    = m_towerGeometrySvc->maxCellHash();
  //m_numberOfTowers = m_towerGeometrySvc->towerBins();
  // ATH_MSG_INFO("Additional tool parameters:");
  // if ( m_numberOfCells > 0 ) { 
  //   ATH_MSG_INFO("[accept] maximum cell hash index is " << m_maxCellHash);
  //   ATH_MSG_INFO("[accept] maximum number of cells is " << m_numberOfCells);
  // } else { 
  //   ATH_MSG_ERROR("[reject] invalid maximum cell hash index/total number of cells " << m_maxCellHash << "/" << m_numberOfCells << " - fatal");
  //   return StatusCode::FAILURE;
  // }
  // if ( m_numberOfTowers > 0 ) { 
  //   ATH_MSG_INFO("[accept] maximum number of towers is " << m_numberOfTowers);
  // } else {
  //   ATH_MSG_ERROR("[reject] invalid maximum number of towers " << m_numberOfTowers << " - fatal");
  //   return StatusCode::FAILURE;
  // }
 
  if ( m_excludedSamplingsName.empty() ) { 
    m_excludedSamplings.clear();
    m_excludedSamplingsPattern.reset();
    ATH_MSG_INFO("Cells from all samplings used for topo-cluster included"); 
  } else {
    size_t nex(std::min(m_excludedSamplingsName.size(), m_excludedSamplingsPattern.size()));
    if ( m_excludedSamplingsName.size() > m_excludedSamplingsPattern.size() ) { 
      ATH_MSG_WARNING( CaloRec::Helpers::fmtMsg("Configuration problem: number of excluded sampling names %zu exceeds expected maximum %zu - ignore last %zu name(s)",
                        m_excludedSamplingsName.size(), m_excludedSamplingsPattern.size(),m_excludedSamplingsName.size()-m_excludedSamplingsPattern.size()) );
    }
    m_excludedSamplings.resize(nex);
    m_excludedSamplingsPattern.reset();
    for ( size_t i(0); i<nex; ++i ) {
      m_excludedSamplings[i] = CaloRec::Lookup::getSamplingId(m_excludedSamplingsName.value().at(i));
      m_excludedSamplingsPattern.set(i);
      ATH_MSG_INFO( CaloRec::Helpers::fmtMsg("CaloSampling \042%10.10s\042 has id %2zu (name in lookup table \042%10.10s\042)",
                          m_excludedSamplingsName.value().at(i).c_str(),(size_t)m_excludedSamplings.at(i),CaloRec::Lookup::getSamplingName(m_excludedSamplings.at(i)).c_str()) );
    }
  }
 
  ATH_MSG_INFO("Other properties:");
  std::map<bool,std::string> blu { { true, "true" }, { false, "false" } };
  ATH_MSG_INFO( CaloRec::Helpers::fmtMsg("PrepareLCW ................. %s",             blu[m_prepareLCW.value()].c_str())               ); 
  ATH_MSG_INFO( CaloRec::Helpers::fmtMsg("BuildTopoTowers ............ %s",             blu[m_useCellsFromClusters.value()].c_str())     );
  ATH_MSG_INFO( CaloRec::Helpers::fmtMsg("ApplyCellEnergyThreshold ... %s",             blu[m_applyCellEnergyThreshold.value()].c_str()) );
  ATH_MSG_INFO( CaloRec::Helpers::fmtMsg("OrderClusterByPt ........... %s",             blu[m_orderByPt.value()].c_str())                );
  ATH_MSG_INFO( CaloRec::Helpers::fmtMsg("DoCellIndexCheck ........... %s",             blu[m_doCellIndexCheck.value()].c_str())         );
  ATH_MSG_INFO( CaloRec::Helpers::fmtMsg("BuildCombinedTopoSignal .... %s",             blu[m_buildCombinedSignal.value()].c_str())      );
  ATH_MSG_INFO( CaloRec::Helpers::fmtMsg("TopoClusterRange ........... %.2f",           m_clusterRange.value())                          );
  ATH_MSG_INFO( CaloRec::Helpers::fmtMsg("ExcludedSamplings .......... %zu (number of)",m_excludedSamplingsName.size())          );
  ATH_MSG_INFO( CaloRec::Helpers::fmtMsg("RemoveSamplingData ......... %s",             blu[m_removeSamplingData.value()].c_str())       );
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

interfaceID()

const InterfaceID & CaloTowerCollectionProcessor::interfaceID ( )

inlinestaticinherited

Standard Gaudi interface ID method.

Definition at line 44 of file CaloTowerCollectionProcessor.h.

{return IID_CaloTowerCollectionProcessor;}

isValidIndex()

bool CaloTopoTowerFromClusterMaker::isValidIndex ( uint_t idx ) const

inlineprivate

Checks if argument is a valid index value.

Definition at line 146 of file CaloTopoTowerFromClusterMaker.h.

{ return idx != badIndexValue(); }

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::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< AlgTool > >::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< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 368 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 298 of file AthCommonDataStore.h.

                                               {
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_applyCellEnergyThreshold

Gaudi::Property<bool> CaloTopoTowerFromClusterMaker::m_applyCellEnergyThreshold {this, "ApplyCellEnergyThreshold", false, "Turn on/off cell energy thresholds"}

private

Apply cell energy threshold, default is false.

Definition at line 73 of file CaloTopoTowerFromClusterMaker.h.

{this, "ApplyCellEnergyThreshold", false, "Turn on/off cell energy thresholds"}; 

m_buildCombinedSignal

Gaudi::Property<bool> CaloTopoTowerFromClusterMaker::m_buildCombinedSignal {this, "BuildCombinedTopoSignal", false, "Build topo-clusters and topo-towers"}

private

Build topo-clusters within given \( y \) range, else topo-towers.

Definition at line 75 of file CaloTopoTowerFromClusterMaker.h.

{this, "BuildCombinedTopoSignal", false, "Build topo-clusters and topo-towers"}; 

m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> CaloTopoTowerFromClusterMaker::m_caloMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager"}

private

Definition at line 66 of file CaloTopoTowerFromClusterMaker.h.

{this,"CaloDetDescrManager", "CaloDetDescrManager"};

m_cellContainerKey

SG::ReadHandleKey<CaloCellContainer> CaloTopoTowerFromClusterMaker::m_cellContainerKey {this, "CaloCellContainerKey", "AllCalo", "SG Key for CaloCellContainer (input)"}

private

Calorimeter cell container.

Definition at line 69 of file CaloTopoTowerFromClusterMaker.h.

{this, "CaloCellContainerKey", "AllCalo", "SG Key for CaloCellContainer (input)"}; 

m_clusterContainerKey

SG::ReadHandleKey<xAOD::CaloClusterContainer> CaloTopoTowerFromClusterMaker::m_clusterContainerKey {this, "CaloTopoClusterContainerKey", "CaloTopoClusters", "SG Key for CaloClusterContainer (input)"}

private

Topo-cluster container key.

Definition at line 68 of file CaloTopoTowerFromClusterMaker.h.

{this, "CaloTopoClusterContainerKey", "CaloTopoClusters", "SG Key for CaloClusterContainer (input)"}; 

m_clusterRange

Gaudi::Property<double> CaloTopoTowerFromClusterMaker::m_clusterRange {this, "TopoClusterRange", m_clusterRangeDef, "Rapidity range for using topo-clusters in combined signal mode"}

private

Range where topo-clusters are used when m_buildCombinedSignal = true.

Definition at line 77 of file CaloTopoTowerFromClusterMaker.h.

{this, "TopoClusterRange", m_clusterRangeDef, "Rapidity range for using topo-clusters in combined signal mode"}; 

m_clusterRangeDef

const double CaloTopoTowerFromClusterMaker::m_clusterRangeDef = 5.

staticprivate

Default cluster \( y \) range.

Definition at line 88 of file CaloTopoTowerFromClusterMaker.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

m_doCellIndexCheck

Gaudi::Property<bool> CaloTopoTowerFromClusterMaker::m_doCellIndexCheck {this, "DoCellIndexCheck", false, "Check cell hash indices for consistency"}

private

Check cell hash index consistency if true (default false).

Definition at line 74 of file CaloTopoTowerFromClusterMaker.h.

{this, "DoCellIndexCheck", false, "Check cell hash indices for consistency"}; 

m_energyThreshold

Gaudi::Property<double> CaloTopoTowerFromClusterMaker::m_energyThreshold {this, "CellEnergyThreshold", m_energyThresholdDef-1., "Energy threshold for cells filled in clusters"}

private

Cell energy threshold, default is set in m_energyThresholdDef.

Definition at line 76 of file CaloTopoTowerFromClusterMaker.h.

{this, "CellEnergyThreshold", m_energyThresholdDef-1., "Energy threshold for cells filled in clusters"}; 

m_energyThresholdDef

const double CaloTopoTowerFromClusterMaker::m_energyThresholdDef = -100000000.

staticprivate

Default energy threshold.

Definition at line 87 of file CaloTopoTowerFromClusterMaker.h.

m_errorValueUINT

const CaloTopoTowerFromClusterMaker::uint_t CaloTopoTowerFromClusterMaker::m_errorValueUINT = uint_t(-1)

staticprivate

Error value for uint_t type values.

Definition at line 89 of file CaloTopoTowerFromClusterMaker.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

m_excludedSamplings

std::vector<CaloSampling::CaloSample> CaloTopoTowerFromClusterMaker::m_excludedSamplings

private

List of excluded samplings (CaloSampling::CaloSample enumerators).

Definition at line 135 of file CaloTopoTowerFromClusterMaker.h.

m_excludedSamplingsName

Gaudi::Property<std::vector<std::string> > CaloTopoTowerFromClusterMaker::m_excludedSamplingsName {this, "ExcludedSamplings", {}, "Excluded samplings by name"}

private

List of excluded samplings (human-readable names).

Definition at line 136 of file CaloTopoTowerFromClusterMaker.h.

{this, "ExcludedSamplings", {}, "Excluded samplings by name"}; 

m_excludedSamplingsPattern

std::bitset< _CALOTOPOTOWERFROMCLUSTERMAKER_BITSET_SIZE > CaloTopoTowerFromClusterMaker::m_excludedSamplingsPattern

private

Bit pattern indicates if sampling is excluded.

Definition at line 137 of file CaloTopoTowerFromClusterMaker.h.

m_numberOfSamplings

uint_t CaloTopoTowerFromClusterMaker::m_numberOfSamplings {static_cast<uint_t>(CaloSampling::Unknown)}

private

Number of samplings.

Definition at line 85 of file CaloTopoTowerFromClusterMaker.h.

{static_cast<uint_t>(CaloSampling::Unknown)}; 

m_orderByPt

Gaudi::Property<bool> CaloTopoTowerFromClusterMaker::m_orderByPt {this, "OrderClusterByPt", false, "Turn on/off pT-ordering of CaloClusterContainer (output)"}

private

Orders cluster container by \( p_{\text{T}} \), default true.

Definition at line 70 of file CaloTopoTowerFromClusterMaker.h.

{this, "OrderClusterByPt", false, "Turn on/off pT-ordering of CaloClusterContainer (output)"}; 

m_prepareLCW

Gaudi::Property<bool> CaloTopoTowerFromClusterMaker::m_prepareLCW {this, "PrepareLCW", false, "Prepare data structure to apply LCW"}

private

Prepare LCW calibration, default is false.

Definition at line 71 of file CaloTopoTowerFromClusterMaker.h.

{this, "PrepareLCW", false, "Prepare data structure to apply LCW"}; 

m_removeSamplingData

Gaudi::Property<bool> CaloTopoTowerFromClusterMaker::m_removeSamplingData {this, "RemoveSamplingData", true, "Remove the associated sampling data"}

private

Remove sampling data for towers.

Definition at line 78 of file CaloTopoTowerFromClusterMaker.h.

{this, "RemoveSamplingData", true, "Remove the associated sampling data"}; 

m_towerGeoKey

SG::ReadCondHandleKey<CaloTowerGeometry> CaloTopoTowerFromClusterMaker::m_towerGeoKey {this,"TowerGeometry","CaloTowerGeometry"}

private

the name of the key of the CaloTowerGeometry object in the ConditonsStore

Definition at line 65 of file CaloTopoTowerFromClusterMaker.h.

{this,"TowerGeometry","CaloTowerGeometry"};

m_useCellsFromClusters

Gaudi::Property<bool> CaloTopoTowerFromClusterMaker::m_useCellsFromClusters {this, "BuildTopoTowers", true, "Turn on/off topo-tower formation"}

private

Use cells from topo-clusters if true, else use all cells, default is true.

Definition at line 72 of file CaloTopoTowerFromClusterMaker.h.

{this, "BuildTopoTowers", true, "Turn on/off topo-tower formation"}; 

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 387 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 386 of file AthCommonDataStore.h.

---

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

• CaloTopoTowerFromClusterMaker.h
• CaloTopoTowerFromClusterMaker.cxx