CaloTopoClusterMaker Class Reference

topological cluster maker. More...

#include <CaloTopoClusterMaker.h>

Inheritance diagram for CaloTopoClusterMaker:

Public Member Functions
	CaloTopoClusterMaker (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	execute (const EventContext &ctx, xAOD::CaloClusterContainer *theClusters) const override
	Execute on an entire collection of clusters.
virtual StatusCode	initialize () override
void	getClusterSize ()
virtual StatusCode	execute (xAOD::CaloClusterContainer *collection) final
	Execute on an entire collection of clusters.
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
	DeclareInterfaceID (CaloClusterCollectionProcessor, 1, 0)

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

Private Member Functions
bool	passCellTimeCut (const CaloCell *, const CaloCellContainer *) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
const CaloCell_ID *	m_calo_id
SG::ReadHandleKey< CaloCellContainer >	m_cellsKey
	vector of names of the cell containers to use as input.
std::vector< std::string >	m_caloNames
	vector of names of the calorimeters to consider.
bool	m_subcaloUsed [CaloCell_ID::NSUBCALO]
	Flag which subdetectors are to be used.
float	m_cellThresholdOnEorAbsEinSigma
	all cells have to satisfy \(|E| > N_{\rm cell}\,\sigma\)
float	m_neighborThresholdOnEorAbsEinSigma
	cells with \(|E| > N_{\rm neighbor}\,\sigma\) extend the cluster
float	m_seedThresholdOnEorAbsEinSigma
	cells with \(|E| > N_{\rm seed}\,\sigma\) start a cluster
float	m_seedThresholdOnTAbs
	threshold used for timing cut on seed cells.
float	m_timeCutUpperLimit
	upper limit on the energy significance, for applying the cell time cut
float	m_xtalkDeltaT
	additional max.
float	m_xtalk2Eratio1
	cut on Eneighbor/E to revover out of time cell close to energetic first phi neighbor cell
float	m_xtalk2Eratio2
	cut on Eneighbor/E to revover out of time cell close to energetic second phi neighbor cell
float	m_xtalk3Eratio
	cut on Eneighbor/E to revover out of time layer 3cell close to energetic previous sampling neighbor
float	m_xtalkEtaEratio
	cut on Eneighbor/E to revover out of time layer 2 cell close in eta to energetic neighor cell
float	m_xtalk2DEratio
	cut on Eneighbor/E to remove out of time layer layer2 all 2D neighbors
SG::ReadCondHandleKey< CaloNoise >	m_noiseCDOKey {this,"CaloNoiseKey","totalNoise","SG Key of CaloNoise data object"}
	Key of the CaloNoise Conditions data object.
std::string	m_neighborOption
	type of neighbor relations to use.
LArNeighbours::neighbourOption	m_nOption
bool	m_restrictHECIWandFCalNeighbors
	if set to true limit the neighbors in HEC IW and FCal2&3.
bool	m_restrictPSNeighbors
	if set to true limit the neighbors in presampler Barrel and Endcap.
bool	m_seedCutsInAbsE
	if set to true seed cuts are on \(|E|\) and \(|E|_\perp\).
bool	m_neighborCutsInAbsE
	if set to true neighbor cuts are on \(|E|\) and \(|E|_\perp\).
bool	m_cellCutsInAbsE
	if set to true cell cuts are on \(|E|\) and \(|E|_\perp\).
bool	m_clusterCutsInAbsE
	if set to true final cluster cuts are on \(|E|_\perp\).
float	m_clusterEtorAbsEtCut
	\(E_\perp\) cut on the final cluster.
bool	m_twogaussiannoise
	if set to true use 2-gaussian noise description for TileCal
bool	m_treatL1PredictedCellsAsGood
	if set to true treat cells with a dead OTX which can be predicted by L1 trigger info as good instead of bad cells
bool	m_seedCutsInT
	if set to true, time cut is applied to seed cells, no cut otherwise
bool	m_cutOOTseed
	if set to true, seed cells failing the time cut are also excluded from cluster at all
bool	m_useTimeCutUpperLimit
	if set to true, the time cut is not applied on cell of large significance
bool	m_xtalkEM2
	if set to true, the time window is softened in the EMB2 and EME2_OW due to xtalk from direct neighbour cells in phi
bool	m_xtalkEM2D
	if set to true, the time window is softened in the EMB2 and EME2_OW due to xtalk from all 2D neighors
bool	m_xtalkEM2n
	if set to true (together with m_xtalkEM2) we also extend the time window for 2nd phi neighbors
bool	m_xtalkEM3
	if set to true we extend the time window for direct layer 3 neighbors of high energy layer 2 cells
bool	m_xtalkEMEta
	if set to true, the time window is softened in the EMB2 and EME2_OW due to xtalk from direct neighbour cells in eta
std::vector< std::string >	m_samplingNames
	vector of names of the calorimeter samplings to consider for seeds.
std::set< int >	m_validSamplings
	actual set of samplings to be used for seeds
int	m_minSampling
	smallest valid seed sampling found
int	m_maxSampling
	largest valid seed sampling found
std::vector< bool >	m_useSampling
	flag for all samplings - true for used ones, false for excluded ones
IdentifierHash	m_hashMin
IdentifierHash	m_hashMax
xAOD::CaloCluster::ClusterSize	m_clusterSize
	Cluster size enum. Set based on energy cut jobO.
Gaudi::Property< bool >	m_useGPUCriteria {this, "UseGPUCriteria", false, "Adopt a set of criteria that is consistent with the GPU implementation."}
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

Detailed Description

topological cluster maker.

Version

$Id: CaloTopoClusterMaker.h,v 1.24 2009-05-15 12:09:48 artamono Exp $

Author

Sven Menke menke.nosp@m.@mpp.nosp@m.mu.mp.nosp@m.g.de

Date

23-December-2003

Make clusters from CaloCells based on topological neighboring and noise motivated thresholds in units of sigma applied to the absolute value of the energy for each cell. The clusters will have at least one cell with \( E > N_{\rm seed}\,\sigma \) (or \(|E| > N_{\rm seed}\,\sigma \) if SeedCutsInAbsE is true). Cells with \( |E| > N_{\rm neighbor}\,\sigma \) will expand the cluster by means of their neighbors. All cells in the cluster must fulfill \( |E| > N_{\rm cell}\,\sigma \). The actual clustering is performed by expanding around seed cells. The neighboring cells above neighbor threshold (if not used so far) are stored in a list and used in the next expansion step. The algorithm terminates if no more unused neighbor cells are found. The final clusters are copied to the cluster collection if they pass the \(E_\perp\) (or \(|E|_\perp\) if SeedCutsInAbsE is true) cut.

Like all other cluster maker tools this class derives from CaloClusterCollectionProcessor.

Definition at line 48 of file CaloTopoClusterMaker.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

CaloTopoClusterMaker()

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

Definition at line 51 of file CaloTopoClusterMaker.cxx.

  : AthAlgTool(type, name, parent),
    m_calo_id(nullptr),
    m_cellsKey(""),
    m_subcaloUsed(),
    m_cellThresholdOnEorAbsEinSigma    (    0.),
    m_neighborThresholdOnEorAbsEinSigma(    3.),
    m_seedThresholdOnEorAbsEinSigma    (    6.),
    m_seedThresholdOnTAbs              (  12.5*ns),
    m_timeCutUpperLimit                (    20.),
    m_xtalkDeltaT                      (  15.*ns),
    m_xtalk2Eratio1                    ( 4.),
    m_xtalk2Eratio2                    ( 25.),
    m_xtalk3Eratio                     ( 10.),
    m_xtalkEtaEratio                   (4.),
    m_xtalk2DEratio                    (4.),
    m_neighborOption                   ("super3D"),
    m_nOption                          (LArNeighbours::super3D),
    m_restrictHECIWandFCalNeighbors    (false),
    m_restrictPSNeighbors              (false),
    m_seedCutsInAbsE                   (false),
    m_neighborCutsInAbsE               (true),
    m_cellCutsInAbsE                   (true),
    m_clusterCutsInAbsE                (true),
    m_clusterEtorAbsEtCut              (    0.*MeV),
    m_twogaussiannoise                 (false),
    m_treatL1PredictedCellsAsGood      (true),
    m_seedCutsInT                      (false),
    m_cutOOTseed                       (false),
    m_useTimeCutUpperLimit             (false),
    m_xtalkEM2                         (false),
    m_xtalkEM2D                        (false),
    m_xtalkEM2n                        (false),
    m_xtalkEM3                         (false),
    m_xtalkEMEta                       (false),
    m_minSampling                      (0),
    m_maxSampling                      (0),
    m_hashMin                          (999999),
    m_hashMax                          (0),
    m_clusterSize                      ()
{
  declareInterface<CaloClusterCollectionProcessor> (this);
  // Name(s) of Cell Containers
  declareProperty("CellsName",m_cellsKey);
  
  // Name(s) of Calorimeters to consider
  declareProperty("CalorimeterNames",m_caloNames);
 
  // Name(s) of Calorimeter Samplings to consider for seeds
  declareProperty("SeedSamplingNames",m_samplingNames);
 
  // Energy thresholds (in units of noise Sigma) 
  declareProperty("SeedThresholdOnEorAbsEinSigma",
          m_seedThresholdOnEorAbsEinSigma);
  declareProperty("NeighborThresholdOnEorAbsEinSigma",
          m_neighborThresholdOnEorAbsEinSigma);
  declareProperty("CellThresholdOnEorAbsEinSigma",
          m_cellThresholdOnEorAbsEinSigma);
 
  // Seed and cluster cuts are in E or Abs E
  declareProperty("SeedCutsInAbsE",m_seedCutsInAbsE);
 
  // Time thresholds (in abs. val.)
  declareProperty("SeedThresholdOnTAbs",m_seedThresholdOnTAbs);
 
  // Significance upper limit for applying time cut
  declareProperty("TimeCutUpperLimit",m_timeCutUpperLimit);
 
  //do Seed cuts on Time              
  declareProperty("SeedCutsInT",m_seedCutsInT);
  //exclude out-of-time seeds from neighbouring and cell stage              
  declareProperty("CutOOTseed",m_cutOOTseed);
  //do not apply time cut on cells of large significance
  declareProperty("UseTimeCutUpperLimit",m_useTimeCutUpperLimit);
  //relax time window (if timing is used) in EM2 when xTalk is present
  declareProperty("XTalkEM2",m_xtalkEM2);
  //relax time window (if timing is used) in EM2 when xTalk is present for all 2D neighbirs
  declareProperty("XTalkEM2D",m_xtalkEM2D);
  //relax time window (if timing is used) in EM2 Eta directionwhen xTalk is present
  declareProperty("XTalkEMEta",m_xtalkEMEta);
  //relax time window (if timing is used) in EM2 when xTalk is present also for 2nd phi neighbors (if XTalkEM2 is also set)
  declareProperty("XTalkEM2n",m_xtalkEM2n);
  //relax time window (if timing is used) in EM3 when xTalk is present for layer 3 neighbor of high energy layer 2 cells
  declareProperty("XTalkEM3",m_xtalkEM3);
  //delta T to add to upper time threshold for EM2 cells affected by xtalk
  declareProperty("XTalkDeltaT",m_xtalkDeltaT);
  //Eratio for first phi neighbor in layer2
  declareProperty("XTalk2Eratio1",m_xtalk2Eratio1);
  //Eratio for second phi neighbor in layer2
  declareProperty("XTalk2Eratio2",m_xtalk2Eratio2);
  //Eratio for previous sampling neighbor in layer 3
  declareProperty("XTalk3Eratio",m_xtalk3Eratio);
  //Eratio for cross-talk in eta layer 2
  declareProperty("XTalkEtaEratio",m_xtalkEtaEratio);
  //Eratio for cross-talk in all 2D layer 2 neighbors
  declareProperty("XTalk2DEratio",m_xtalk2DEratio);
 
  // Neighbor cuts are in E or Abs E
  declareProperty("NeighborCutsInAbsE",m_neighborCutsInAbsE);
 
  // Cell cuts are in E or Abs E
  declareProperty("CellCutsInAbsE",m_cellCutsInAbsE);
 
  // Neighbor Option
  declareProperty("NeighborOption",m_neighborOption);
 
  // Restrict HEC IW and FCal Neighbors
  declareProperty("RestrictHECIWandFCalNeighbors",m_restrictHECIWandFCalNeighbors);
 
  // Restrict PS Neighbors
  declareProperty("RestrictPSNeighbors",m_restrictPSNeighbors);
 
  //Cluster cuts are in E_t or Abs E_t 
  declareProperty("ClusterCutsInAbsEt",m_clusterCutsInAbsE);
  
  // Cluster E_t or Abs E_t cut
  declareProperty("ClusterEtorAbsEtCut",m_clusterEtorAbsEtCut);
 
  // use 2-gaussian noise for Tile
  declareProperty("TwoGaussianNoise",m_twogaussiannoise);
 
  // Treat bad cells with dead OTX if predicted from L1 as good
  declareProperty("TreatL1PredictedCellsAsGood",m_treatL1PredictedCellsAsGood);
}

Member Function Documentation

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());
 
  }

DeclareInterfaceID()

CaloClusterCollectionProcessor::DeclareInterfaceID ( CaloClusterCollectionProcessor , 1 , 0  )

inherited

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() [1/2]

StatusCode CaloTopoClusterMaker::execute ( const EventContext & ctx, xAOD::CaloClusterContainer * collection ) const

overridevirtual

Execute on an entire collection of clusters.

Parameters

collection

The container of clusters. param ctx The event context.

Implements CaloClusterCollectionProcessor.

Definition at line 362 of file CaloTopoClusterMaker.cxx.

{
  // minimal significance - should be > 0 in order to avoid 
  // throwing away of bad cells
  const float epsilon = 0.00001;
 
  //ATH_MSG_DEBUG( "Executing " << name());
 
  using HashCell = CaloTopoTmpHashCell<CaloTopoTmpClusterCell>;
  using HashCluster = CaloTopoTmpHashCluster;
 
  CaloPrefetch::ArenaHandlePrefetch<CaloTopoTmpClusterCell, SG::ArenaPoolAllocator, 2> tmpcell_pool;
  CaloPrefetch::ArenaHandlePrefetch<HashCluster,            SG::ArenaPoolAllocator, 2> tmpclus_pool;
  CaloTopoTmpHashCluster::pool_type                               tmplist_pool;
 
  // create cell list for cells above seed  cut (for seed growing algo)
  std::vector<HashCell> mySeedCells;
  mySeedCells.reserve (2000);
  // create initial cluster list (one cell per cluster)
  std::vector<HashCluster *> myHashClusters;
  myHashClusters.reserve (10000);
 
  // create vector to hold all cells.
  std::vector<HashCell> cellVector (m_hashMax - m_hashMin);
  HashCell* hashCells = cellVector.data() - m_hashMin;
 
  
  SG::ReadCondHandle<CaloNoise> noiseHdl{m_noiseCDOKey,ctx};
  const CaloNoise* noiseCDO=*noiseHdl;
 
  //---- Get the CellContainers ----------------
 
  //  for (const std::string& cellsName : m_cellsNames) {
  SG::ReadHandle<CaloCellContainer> cellColl(m_cellsKey, ctx);
  if( !cellColl.isValid()){ 
    ATH_MSG_ERROR( " Can not retrieve CaloCellContainer: "
                   << cellColl.name()  );
    return StatusCode::RECOVERABLE;      
  }    
 
  const DataLink<CaloCellContainer> cellCollLink (cellColl.name(),ctx);
 
  //ATH_MSG_DEBUG("CaloCell container: "<< cellsName 
  //          <<" contains " << cellColl->size() << " cells");
 
  for (int isubdet = 0; isubdet < CaloCell_ID::NSUBCALO; ++isubdet) {
    CaloCell_ID::SUBCALO subdet = (CaloCell_ID::SUBCALO)isubdet;
    if (m_subcaloUsed[subdet] && cellColl->hasCalo(subdet)) {
      auto cellIter = cellColl->beginConstCalo (subdet);
      auto cellIterEnd = cellColl->endConstCalo (subdet);
      for (int iCell = cellColl->indexFirstCellCalo(subdet);
       cellIter != cellIterEnd;
       ++iCell, ++cellIter)
        {
          CaloPrefetch::nextDDE(cellIter, cellIterEnd, 2);
      const CaloCell* pCell = *cellIter;
      const float noiseSigma = m_twogaussiannoise ? \
        noiseCDO->getEffectiveSigma(pCell->ID(),pCell->gain(),pCell->energy()) : \
        noiseCDO->getNoise(pCell->ID(),pCell->gain());
 
      float signedE = pCell->energy();
      float signedEt = pCell->et();
      float signedRatio = epsilon; // not 0 in order to keep bad cells 
      if ( finite(noiseSigma) && noiseSigma > 0 && !CaloBadCellHelper::isBad(pCell,m_treatL1PredictedCellsAsGood) ) 
        signedRatio = signedE/noiseSigma;
 
      bool passedCellCut = (m_cellCutsInAbsE?std::abs(signedRatio):signedRatio) > m_cellThresholdOnEorAbsEinSigma;
      bool passedNeighborCut = (m_neighborCutsInAbsE?std::abs(signedRatio):signedRatio) > m_neighborThresholdOnEorAbsEinSigma;
      bool passedSeedCut = (m_seedCutsInAbsE?std::abs(signedRatio):signedRatio) > m_seedThresholdOnEorAbsEinSigma;
 
      bool applyTimeCut = m_seedCutsInT && (!m_useTimeCutUpperLimit || signedRatio <= m_timeCutUpperLimit);
      bool passTimeCut_seedCell = (!applyTimeCut || passCellTimeCut(pCell,cellColl.cptr()));
      bool passedSeedAndTimeCut = (passedSeedCut && passTimeCut_seedCell);
 
      bool passedNeighborAndTimeCut = passedNeighborCut;
      if(m_cutOOTseed && passedSeedCut && !passTimeCut_seedCell) passedNeighborAndTimeCut=false; //exclude Out-Of-Time seeds from neighbouring stage as well (if required)
 
      bool passedCellAndTimeCut = passedCellCut;
      if(m_cutOOTseed && passedSeedCut && !passTimeCut_seedCell) passedCellAndTimeCut=false; //exclude Out-Of-Time seeds from cluster (if required)
 
      if ( passedCellAndTimeCut || passedNeighborAndTimeCut || passedSeedAndTimeCut ) {
        const CaloDetDescrElement* dde = pCell->caloDDE();
        IdentifierHash hashid = dde ? dde->calo_hash() : m_calo_id->calo_cell_hash(pCell->ID());
        CaloTopoTmpClusterCell *tmpClusterCell =
              new (tmpcell_pool.allocate())
              CaloTopoTmpClusterCell(hashid,subdet,iCell,signedRatio,signedEt);
#if 0
        // some debug printout - can also be used to construct neighbor
        // tables offline ...
        if ( m_doALotOfPrintoutInFirstEvent ) {
          ATH_MSG_DEBUG( " [ExtId|Id|SubDet|HashId|eta|phi|E/noise|Et]: "
                 << "[" << m_calo_id->show_to_string(pCell->ID(),0,'/')
                 << "|" << mypCell->ID().getString()
                 << "|" << subdet
                 << "|" << (unsigned int)hashid
                 << "|" << pCell->eta()
                 << "|" << pCell->phi()
                 << "|" << signedRatio
                 << "|" << signedEt
                 << "]");
      
        }
#endif
        HashCell hashCell(tmpClusterCell);
        if ( passedNeighborAndTimeCut || passedSeedAndTimeCut ) {
          HashCluster *tmpCluster =
                new (tmpclus_pool.allocate()) HashCluster (tmplist_pool);
          tmpClusterCell->setCaloTopoTmpHashCluster(tmpCluster);
          tmpCluster->add(hashCell);
          myHashClusters.push_back(tmpCluster);
          int caloSample = dde ? dde->getSampling() : m_calo_id->calo_sample(pCell->ID());
          if ( passedSeedAndTimeCut 
           && caloSample >= m_minSampling 
           && caloSample <= m_maxSampling 
           && m_useSampling[caloSample-m_minSampling]) {
        tmpClusterCell->setUsed();
        mySeedCells.push_back(hashCell);
          }
        }
        hashCells[hashid] = hashCell;
      }
    }//end loop over cells
    }//end if use subcalo
  }//end loop over subcalos
 
 
  // sort initial seed cells to start with the cell of largest S/N
  // this makes the resulting clusters independent of the initial
  // ordering of the cells
  if ( m_useGPUCriteria) {
    if ( m_seedCutsInAbsE) {
      CaloTopoTmpHashCellSort::compareAbsWithIndex<CaloTopoTmpClusterCell> compareSoverN;
      std::sort(mySeedCells.begin(),mySeedCells.end(),compareSoverN); 
    }
    else {
      CaloTopoTmpHashCellSort::compareWithIndex<CaloTopoTmpClusterCell> compareSoverN;
      std::sort(mySeedCells.begin(),mySeedCells.end(),compareSoverN); 
    }
  }
  else {
    if ( m_seedCutsInAbsE) {
      CaloTopoTmpHashCellSort::compareAbs<CaloTopoTmpClusterCell> compareSoverN;
      std::sort(mySeedCells.begin(),mySeedCells.end(),compareSoverN); 
    }
    else {
      CaloTopoTmpHashCellSort::compare<CaloTopoTmpClusterCell> compareSoverN;
      std::sort(mySeedCells.begin(),mySeedCells.end(),compareSoverN); 
    }
  }
 
#if 1
  if (msgLvl(MSG::DEBUG)) {
    for (const HashCell& hc : mySeedCells) {
      ATH_MSG_DEBUG( " SeedCell [" 
              << hc.getCaloTopoTmpClusterCell()->getSubDet() 
              << "|" 
              << (unsigned int)hc.getCaloTopoTmpClusterCell()->getID() 
              << "] has S/N = " 
              << hc.getCaloTopoTmpClusterCell()->getSignedRatio() 
                     );
    }
  }
#endif
 
  std::vector<HashCell> myNextCells;
  myNextCells.reserve (1000);
 
  std::vector<IdentifierHash> theNeighbors;
  theNeighbors.reserve(22);
#if 0
  std::vector<IdentifierHash> theNNeighbors;
  theNNeighbors.reserve(22);
#endif
 
  bool doRestrictHECIWandFCal = m_restrictHECIWandFCalNeighbors &&
    (m_nOption & LArNeighbours::nextInSamp);
 
  bool doRestrictPS = m_restrictPSNeighbors && 
    (m_nOption & LArNeighbours::nextInSamp);
 
  while ( !mySeedCells.empty() ) {
    // create cell list for next neighbor cells to consider
    myNextCells.clear();
 
    // loop over all current neighbor cells (for Seed Growing Algo)
    for (HashCell& hc : mySeedCells) {
      CaloTopoTmpClusterCell* pCell= hc.getCaloTopoTmpClusterCell();
      IdentifierHash hashid = pCell->getID();
      HashCluster *myCluster = pCell->getCaloTopoTmpHashCluster();
      CaloCell_ID::SUBCALO mySubDet = pCell->getSubDet();
      // in case we use all3d or super3D and the current cell is in the 
      // HEC IW or FCal2 & 3 or PS and we want to restrict their neighbors, 
      // use only next in sampling neighbors 
      LArNeighbours::neighbourOption opt = m_nOption;
      if (( mySubDet != CaloCell_ID::LAREM &&
        doRestrictHECIWandFCal &&
        ( ( mySubDet == CaloCell_ID::LARHEC  &&
        m_calo_id->region(m_calo_id->cell_id(hashid)) == 1 )  ||
          ( mySubDet == CaloCell_ID::LARFCAL &&
        m_calo_id->sampling(m_calo_id->cell_id(hashid)) > 1 ) ) ) ||
      ( doRestrictPS && 
        ( ( mySubDet == CaloCell_ID::LAREM && 
        m_calo_id->sampling(m_calo_id->cell_id(hashid)) == 0 ) ) ) ) {
    opt = LArNeighbours::nextInSamp;
      }
      m_calo_id->get_neighbours(hashid,opt,theNeighbors);
      // loop over all neighbors of that cell (Seed Growing Algo)
      for (IdentifierHash nId : theNeighbors) {
        CaloCell_ID::SUBCALO otherSubDet =
          (CaloCell_ID::SUBCALO)m_calo_id->sub_calo(nId);
    if ( otherSubDet < CaloCell_ID::NSUBCALO &&
             m_subcaloUsed[otherSubDet] )
        {
      HashCell neighborCell = hashCells[nId];
      if ( neighborCell.getCaloTopoTmpClusterCell() ) {
        CaloTopoTmpClusterCell* pNCell = neighborCell.getCaloTopoTmpClusterCell();
        // check neighbor threshold only since seed cells are already in
        // the original list 
        bool isAboveNeighborThreshold = 
          (m_neighborCutsInAbsE?std::abs(pNCell->getSignedRatio()):pNCell->getSignedRatio()) > m_neighborThresholdOnEorAbsEinSigma;
        // checking the neighbors
        if ( isAboveNeighborThreshold && !pNCell->getUsed() ) {
          pNCell->setUsed();
          myNextCells.push_back(neighborCell);
        }
        HashCluster *otherCluster = pNCell->getCaloTopoTmpHashCluster();
        if ( myCluster != otherCluster ) {
          HashCluster *toKill = nullptr;
          HashCluster *toKeep = nullptr;
          if ( !otherCluster || isAboveNeighborThreshold ) {
        
        auto compareClusters = [&](const auto & c1, const auto & c2) {
          if (m_useGPUCriteria) {
            //The seed cell with the largest SNR wins
            if (m_seedCutsInAbsE) {
              CaloTopoTmpHashCellSort::compareAbsWithIndex<CaloTopoTmpClusterCell> compare;
              return compare(*(c1->begin()), *(c2->begin()));
            }
            else {
              CaloTopoTmpHashCellSort::compareWithIndex<CaloTopoTmpClusterCell> compare;
              return compare(*(c1->begin()), *(c2->begin()));
            }
          }
          else {
            //We merge the smallest cluster to the largest...
            return c1->size() > c2->size();
          }
        };
        
        if ( !otherCluster || compareClusters(myCluster, otherCluster) ) {
          toKill = otherCluster;
          toKeep = myCluster;
        }
        else {
          toKill = myCluster;
          toKeep = otherCluster;
        }
        if ( toKill ) {
                  for (auto *hc : *toKill)
                    hc->setCaloTopoTmpHashCluster(toKeep);
          toKeep->add(*toKill);
          toKill->removeAll();
        }
        else {
          toKeep->add(neighborCell);
          pNCell->setCaloTopoTmpHashCluster(toKeep);
        }
        myCluster = toKeep;
          }
        }
      }
    }
      }
    }
    mySeedCells.swap (myNextCells);
  }
 
 
  //Create temporary list of proto-clusters 
  //Clusters below Et cut will be dropped. 
  //The remaining clusters will be sorted in E_t before storing 
  std::vector<std::unique_ptr<CaloProtoCluster> > sortClusters;
  sortClusters.reserve (myHashClusters.size());
 
  for (HashCluster* tmpCluster : myHashClusters) {
    bool addCluster(false);
    if ( tmpCluster->size() > 1 )
      addCluster = true;
    else if ( tmpCluster->size() == 1 ) {
      // need to check if seed cell was good
      HashCluster::iterator clusCellIter=tmpCluster->begin();
      if ( clusCellIter->getUsed() )
    addCluster = true;
    }
    if ( addCluster) {
      std::unique_ptr<CaloProtoCluster> myCluster = std::make_unique<CaloProtoCluster>(cellCollLink);
      //CaloProtoCluster* myCluster = new CaloProtoCluster(cellCollLink);
      myCluster->getCellLinks()->reserve(tmpCluster->size());
 
      for (CaloTopoTmpClusterCell* cell : *tmpCluster) {
    const size_t iCell = cell->getCaloCell();
    myCluster->addCell(iCell,1.);
      }
      const float cl_et = myCluster->et();
      if ( (m_clusterCutsInAbsE ? std::abs(cl_et) : cl_et) > m_clusterEtorAbsEtCut ) {
    sortClusters.push_back(std::move(myCluster));
      } 
    }
  }
 
  // Sort the clusters according to Et 
  std::sort(sortClusters.begin(),sortClusters.end(),[](const std::unique_ptr<CaloProtoCluster>& pc1, 
                               const std::unique_ptr<CaloProtoCluster>& pc2) {
      //As in CaloUtils/CaloClusterEtSort. 
      //assign to volatile to avoid excess precison on in FP unit on x386 machines
      volatile double et1(pc1->et());
      volatile double et2(pc2->et());
      //return (et1 < et2);  //This is the order we had from CaloRec-02-13-11 to  CaloRec-03-00-31
      return (et1 > et2); //This is the order we should have
    }
    );
 // add to cluster container
  clusColl->reserve(sortClusters.size());
 
  for (const auto& protoCluster: sortClusters) {
    xAOD::CaloCluster* xAODCluster=new xAOD::CaloCluster();
    clusColl->push_back(xAODCluster);
    xAODCluster->addCellLink(protoCluster->releaseCellLinks());//Hand over ownership to xAOD::CaloCluster
    xAODCluster->setClusterSize(m_clusterSize);
    CaloClusterKineHelper::calculateKine(xAODCluster,false,true, m_useGPUCriteria); //No weight at this point! 
  }
  
  tmpclus_pool.erase();
  tmpcell_pool.erase();
 
  return StatusCode::SUCCESS;
}

execute() [2/2]

virtual StatusCode CaloClusterCollectionProcessor::execute ( xAOD::CaloClusterContainer * collection )

inlinefinalvirtual

Execute on an entire collection of clusters.

Parameters

collection

The container of clusters. (deprecated)

Reimplemented from CaloClusterCollectionProcessor.

Definition at line 50 of file CaloClusterCollectionProcessor.h.

  {
    return execute (Gaudi::Hive::currentContext(), collection);
  }

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

getClusterSize()

void CaloTopoClusterMaker::getClusterSize

(

)

Definition at line 701 of file CaloTopoClusterMaker.cxx.

                                         {
  m_clusterSize = xAOD::CaloCluster::CSize_Unknown;
 
  if(m_seedThresholdOnEorAbsEinSigma==6. 
     && m_neighborThresholdOnEorAbsEinSigma==3. 
     && m_cellThresholdOnEorAbsEinSigma==3.){
    
    m_clusterSize = xAOD::CaloCluster::Topo_633;
    
  }else if(m_seedThresholdOnEorAbsEinSigma==4. 
       && m_neighborThresholdOnEorAbsEinSigma==2. 
       && m_cellThresholdOnEorAbsEinSigma==0.){
    
    m_clusterSize = xAOD::CaloCluster::Topo_420;    
  }
  ATH_MSG_DEBUG( "Cluster size = " << m_clusterSize);  
}

initialize()

StatusCode CaloTopoClusterMaker::initialize ( )

overridevirtual

Definition at line 181 of file CaloTopoClusterMaker.cxx.

{
  ATH_MSG_INFO( "Initializing " << name()  );
  ATH_MSG_INFO( "Treat L1 Predicted Bad Cells as Good set to" << ((m_treatL1PredictedCellsAsGood) ? "true" : "false")  );
  ATH_MSG_INFO( "Two-Gaussian noise for Tile set to " << ((m_twogaussiannoise) ? "true" : "false")  );
  ATH_CHECK( m_cellsKey.initialize() );
  getClusterSize();
 
  ATH_CHECK( detStore()->retrieve (m_calo_id, "CaloCell_ID") );
 
  ATH_MSG_INFO( "Threshold choices:"
                << (m_seedCutsInAbsE?" SeedThresholdOnAbsEinSigma=":
                    " SeedThresholdOnEinSigma=")
                << m_seedThresholdOnEorAbsEinSigma
                << (m_neighborCutsInAbsE?", NeighborThresholdOnAbsEinSigma=":
                    ", NeighborThresholdOnEinSigma=")
                << m_neighborThresholdOnEorAbsEinSigma
                << (m_cellCutsInAbsE?", CellThresholdOnAbsEinSigma=":
                    ", CellThresholdOnEinSigma=")
                << m_cellThresholdOnEorAbsEinSigma
                );
 
  ATH_MSG_INFO( "Time cut option: " << ((!m_seedCutsInT) ? "None" : (m_cutOOTseed ? "Seed Extended" : "Seed")));
  ATH_MSG_INFO( "E/sigma veto on T cut: m_useTimeCutUpperLimit=" << (m_useTimeCutUpperLimit ? "true" : "false") << ", m_timeCutUpperLimit=" << m_timeCutUpperLimit);
 
  //--- set Neighbor Option
 
  if ( m_neighborOption == "all2D" ) 
    m_nOption = LArNeighbours::all2D;
  else if ( m_neighborOption == "all3D" ) 
    m_nOption = LArNeighbours::all3D;
  else if ( m_neighborOption == "super3D" ) 
    m_nOption = LArNeighbours::super3D;
  else {
    ATH_MSG_ERROR( "Invalid Neighbor Option "
                   << m_neighborOption << ", exiting ..."  );
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_INFO( "Neighbor Option "
                << m_neighborOption << " is selected!"  );
 
  //--- check calorimeter names to use
  for (const std::string& caloName : m_caloNames) {
    if ( caloName == "LAREM" ) 
      m_subcaloUsed[CaloCell_ID::LAREM] = true;
    else if ( caloName == "LARHEC" )
      m_subcaloUsed[CaloCell_ID::LARHEC] = true;
    else if ( caloName == "LARFCAL" )
      m_subcaloUsed[CaloCell_ID::LARFCAL] = true;
    else if ( caloName == "TILE" )
      m_subcaloUsed[CaloCell_ID::TILE] = true;
    else 
      ATH_MSG_ERROR( "Calorimeter " << caloName
                     << " is not a valid Calorimeter name and will be ignored! "
                     << "Valid names are: LAREM, LARHEC, LARFCAL, and TILE."  );
  }
 
  //--- check sampling names to use for seeds
  for (const std::string& sampName : m_samplingNames) {
    if ( sampName == "PreSamplerB" ) 
      m_validSamplings.insert(CaloCell_ID::PreSamplerB);
    else if ( sampName == "EMB1" ) 
      m_validSamplings.insert(CaloCell_ID::EMB1);
    else if ( sampName == "EMB2" ) 
      m_validSamplings.insert(CaloCell_ID::EMB2);
    else if ( sampName == "EMB3" ) 
      m_validSamplings.insert(CaloCell_ID::EMB3);
    else if ( sampName == "PreSamplerE" ) 
      m_validSamplings.insert(CaloCell_ID::PreSamplerE);
    else if ( sampName == "EME1" ) 
      m_validSamplings.insert(CaloCell_ID::EME1);
    else if ( sampName == "EME2" ) 
      m_validSamplings.insert(CaloCell_ID::EME2);
    else if ( sampName == "EME3" ) 
      m_validSamplings.insert(CaloCell_ID::EME3);
    else if ( sampName == "HEC0" ) 
      m_validSamplings.insert(CaloCell_ID::HEC0);
    else if ( sampName == "HEC1" ) 
      m_validSamplings.insert(CaloCell_ID::HEC1);
    else if ( sampName == "HEC2" ) 
      m_validSamplings.insert(CaloCell_ID::HEC2);
    else if ( sampName == "HEC3" ) 
      m_validSamplings.insert(CaloCell_ID::HEC3);
    else if ( sampName == "TileBar0" ) 
      m_validSamplings.insert(CaloCell_ID::TileBar0);
    else if ( sampName == "TileBar1" ) 
      m_validSamplings.insert(CaloCell_ID::TileBar1);
    else if ( sampName == "TileBar2" ) 
      m_validSamplings.insert(CaloCell_ID::TileBar2);
    else if ( sampName == "TileGap1" ) 
      m_validSamplings.insert(CaloCell_ID::TileGap1);
    else if ( sampName == "TileGap2" ) 
      m_validSamplings.insert(CaloCell_ID::TileGap2);
    else if ( sampName == "TileGap3" ) 
      m_validSamplings.insert(CaloCell_ID::TileGap3);
    else if ( sampName == "TileExt0" ) 
      m_validSamplings.insert(CaloCell_ID::TileExt0);
    else if ( sampName == "TileExt1" ) 
      m_validSamplings.insert(CaloCell_ID::TileExt1);
    else if ( sampName == "TileExt2" ) 
      m_validSamplings.insert(CaloCell_ID::TileExt2);
    else if ( sampName == "FCAL0" ) 
      m_validSamplings.insert(CaloCell_ID::FCAL0);
    else if ( sampName == "FCAL1" ) 
      m_validSamplings.insert(CaloCell_ID::FCAL1);
    else if ( sampName == "FCAL2" ) 
      m_validSamplings.insert(CaloCell_ID::FCAL2);
    else 
      ATH_MSG_ERROR( "Calorimeter sampling" << sampName 
                     << " is not a valid Calorimeter sampling name and will be ignored! "
                     << "Valid names are: "
                     << "PreSamplerB, EMB1, EMB2, EMB3, "
                     << "PreSamplerE, EME1, EME2, EME3, "
                     << "HEC0, HEC1, HEC2, HEC3, "
                     << "TileBar0, TileBar1, TileBar2, "
                     << "TileGap1, TileGap2, TileGap3, "
                     << "TileExt0, TileExt1, TileExt2, "
                     << "FCAL0, FCAL1, FCAL2."  );
  }
 
  msg(MSG::INFO) << "Samplings to consider for seeds:";
  for (const std::string& sampName : m_samplingNames)
    msg() << " " << sampName;
  msg() << endmsg;
 
  m_minSampling=0;
  m_maxSampling=0;
  for (int s : m_validSamplings) {
    if ( s > m_maxSampling ) 
      m_maxSampling = s;
    if ( s < m_minSampling ) 
      m_minSampling = s;
  }
 
  m_useSampling.resize(m_maxSampling-m_minSampling+1,false);
 
  for (int s : m_validSamplings) {
    m_useSampling[s-m_minSampling] = true;
  }
 
  ATH_MSG_INFO( "CellCollection to use: " << m_cellsKey.key()  );
 
  msg(MSG::INFO) << "Calorimeters to consider:";
  for (const std::string& caloName : m_caloNames)
    msg() << " " << caloName;
  msg() << endmsg;
 
  //---- retrieve the noise CDO  ----------------
  
  ATH_CHECK(m_noiseCDOKey.initialize());
 
  ATH_MSG_INFO( (m_clusterCutsInAbsE?"ClusterAbsEtCut= ":"ClusterEtCut= ")
                << m_clusterEtorAbsEtCut << " MeV"  );
 
  m_hashMin = 999999;
  m_hashMax = 0;
  for (int subdet = 0; subdet < CaloCell_ID::NSUBCALO; ++subdet) {
    if (m_subcaloUsed[subdet]) {
      IdentifierHash thismin, thismax;
      m_calo_id->calo_cell_hash_range ((CaloCell_ID::SUBCALO)subdet,
                                       thismin, thismax);
      m_hashMin = std::min (m_hashMin, thismin);
      m_hashMax = std::max (m_hashMax, thismax);
    }
  }
 
  //ATH_CHECK( m_cablingKey.initialize() );
 
  // silence possible warnings from AuxSelection (ATLASRECTS-7180)
  xAOD::CaloCluster dummyCluster;
  static const SG::ConstAccessor<ElementLink<CaloClusterCellLinkContainer> > accCellLinks("CellLink");
  (void) accCellLinks.isAvailable(dummyCluster);
 
  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.

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.

passCellTimeCut()

bool CaloTopoClusterMaker::passCellTimeCut ( const CaloCell * pCell, const CaloCellContainer * cellColl ) const

inlineprivate

Definition at line 720 of file CaloTopoClusterMaker.cxx.

                                                                                                                {
  // get the cell time to cut on (the same as in CaloEvent/CaloCluster.h)                             
  bool isInTime = true; 
  // need sampling number already for time
  CaloSampling::CaloSample sam = pCell->caloDDE()->getSampling();
  // check for unknown sampling                                                 
  if (sam != CaloSampling::PreSamplerB && sam != CaloSampling::PreSamplerE && sam != CaloSampling::Unknown) {
    const unsigned pmask= pCell->caloDDE()->is_tile() ? 0x8080 : 0x2000; 
    //0x2000 is used to tell that time and quality information are available for this channel
    //(from TWiki: https://twiki.cern.ch/twiki/bin/viewauth/AtlasComputing/CaloEventDataModel#The_Raw_Data_Model)       
    // Is time defined?                                                                         
    if(pCell->provenance() & pmask) {
      isInTime = (std::abs(pCell->time())<m_seedThresholdOnTAbs);
      if ( m_xtalkEM2 && (!isInTime) && (pCell->energy() > 0 && (sam == CaloSampling::EMB2 || (sam == CaloSampling::EME2 && std::abs(pCell->eta()) < 2.5)))) {
    // relax time constraints in EMB2 and EME2_OW due to xTalk from direct phi neighbours
    // check if |E| is less than 0.25 times one of the |E| values of direct
    // phi-neighbours. In case that phi-neigbour is in-time, expand upper limit by m_xtalkDeltaT
    IdentifierHash hashid = pCell->caloDDE()->calo_hash();
    std::vector<IdentifierHash> theNeighbors;
    LArNeighbours::neighbourOption opt = (LArNeighbours::neighbourOption)(((int)LArNeighbours::prevInPhi)|((int)LArNeighbours::nextInPhi)); // shoud make a proper enum in LarNeighbours.h for this one ...
    m_calo_id->get_neighbours(hashid,opt,theNeighbors);
    // loop over all neighbors of that cell (Seed Growing Algo)
    for (IdentifierHash nId : theNeighbors) {
      const CaloCell * pNCell = cellColl->findCell(nId);
      if ( pNCell ) {
        if ( pNCell->energy() > m_xtalk2Eratio1*pCell->energy() ) {
          if ( (!(pNCell->provenance() & pmask)) || std::abs(pNCell->time()) < m_seedThresholdOnTAbs) {
        isInTime = ((pCell->time() > -m_seedThresholdOnTAbs) && (pCell->time() < m_seedThresholdOnTAbs + m_xtalkDeltaT));
        if ( isInTime ) {
          // exit after first phi neighbour in case that already made
          // the time-cut pass
          break;
        }
          }
        }
 
            // check second neighbor
            if (m_xtalkEM2n) {
             std::vector<IdentifierHash> theNextNeighbors;
             m_calo_id->get_neighbours(nId,opt,theNextNeighbors);
             for (IdentifierHash n2Id : theNextNeighbors) {
              if (n2Id != hashid) {
                const CaloCell * p2NCell = cellColl->findCell(n2Id);
                if (p2NCell) {
                  if (p2NCell->energy() > m_xtalk2Eratio2*pCell->energy()) {
                      if ( (!(p2NCell->provenance() & pmask)) || std::abs(p2NCell->time()) < m_seedThresholdOnTAbs) {
                          isInTime = ((pCell->time() > -m_seedThresholdOnTAbs) && (pCell->time() < m_seedThresholdOnTAbs + m_xtalkDeltaT));
                          if (isInTime) break;
                      }
                  }
                }
              }
             }    // loop over 2nd neighbors
            }
      }      // if (pNcell)
    }        // loop over first neighbors
      }          // special case for layer 2
 
      // check cross talk in eta
      if ( m_xtalkEMEta && (!isInTime) && (pCell->energy() > 0 && (sam == CaloSampling::EMB2 || (sam == CaloSampling::EME2 && std::abs(pCell->eta()) < 2.5)))) {
          IdentifierHash hashid = pCell->caloDDE()->calo_hash();
          std::vector<IdentifierHash> theNeighbors;
          LArNeighbours::neighbourOption opt = (LArNeighbours::neighbourOption)(((int)LArNeighbours::prevInEta)|((int)LArNeighbours::nextInEta));
          m_calo_id->get_neighbours(hashid,opt,theNeighbors);
          for (IdentifierHash nId : theNeighbors) {
            const CaloCell * pNCell = cellColl->findCell(nId);
            if ( pNCell ) {
                if ( pNCell->energy() > m_xtalkEtaEratio*pCell->energy() ) {
                 if ( (!(pNCell->provenance() & pmask)) || std::abs(pNCell->time()) < m_seedThresholdOnTAbs) {
                    isInTime = ((pCell->time() > -m_seedThresholdOnTAbs) && (pCell->time() < m_seedThresholdOnTAbs + m_xtalkDeltaT));
                    if ( isInTime ) {
                     // exit after first phi neighbour in case that already made
                     // the time-cut pass
                     break;
                    }
                 }
                }
            }
          }
      }
 
      // option for all2D
      if ( m_xtalkEM2D && (!isInTime) && (pCell->energy() > 0 && (sam == CaloSampling::EMB2 || (sam == CaloSampling::EME2 && std::abs(pCell->eta()) < 2.5)))) {
         IdentifierHash hashid = pCell->caloDDE()->calo_hash();
         std::vector<IdentifierHash> theNeighbors;
         LArNeighbours::neighbourOption opt =LArNeighbours::all2D;
         m_calo_id->get_neighbours(hashid,opt,theNeighbors);
         for (IdentifierHash nId : theNeighbors) {
           const CaloCell * pNCell = cellColl->findCell(nId);
           if ( pNCell ) {
               if ( pNCell->energy() > m_xtalk2DEratio*pCell->energy() ) {
                   if ( (!(pNCell->provenance() & pmask)) || std::abs(pNCell->time()) < m_seedThresholdOnTAbs) {
                        isInTime = ((pCell->time() > -m_seedThresholdOnTAbs) && (pCell->time() < m_seedThresholdOnTAbs + m_xtalkDeltaT));
                        if ( isInTime )  break;
                   }
               }
           }
         } 
      }
 
      // relax also time constraint for EMB3 and EME2_OW
      if ( m_xtalkEM3 && (!isInTime) && (pCell->energy() > 0 && (sam == CaloSampling::EMB3 || (sam == CaloSampling::EME3 && std::abs(pCell->eta()) < 2.5)))) {
         // check previous sampling cell, should be >10 times more (TBC)
         IdentifierHash hashid = pCell->caloDDE()->calo_hash();
         std::vector<IdentifierHash> theNeighbors;
         LArNeighbours::neighbourOption opt = LArNeighbours::prevInSamp;
         m_calo_id->get_neighbours(hashid,opt,theNeighbors);
         for (IdentifierHash nId : theNeighbors) {
           const CaloCell * pNCell = cellColl->findCell(nId);
           if ( pNCell ) {
            if ( pNCell->energy() > m_xtalk3Eratio*pCell->energy() ) {
              if ( (!(pNCell->provenance() & pmask)) || std::abs(pNCell->time()) < m_seedThresholdOnTAbs) {
                 isInTime = ((pCell->time() > -m_seedThresholdOnTAbs) && (pCell->time() < m_seedThresholdOnTAbs + m_xtalkDeltaT));
                 if (isInTime) break;
              }   
            }  // Eratio cut at 10
           }
         }     // loop over neighors
      }        // cell is layer 3 EM
 
    }
  }
  return isInTime;
}

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 380 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 364 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 >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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 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_calo_id

const CaloCell_ID* CaloTopoClusterMaker::m_calo_id

private

Definition at line 65 of file CaloTopoClusterMaker.h.

m_caloNames

std::vector<std::string> CaloTopoClusterMaker::m_caloNames

private

vector of names of the calorimeters to consider.

The default is to use all calorimeters (i.e. LAREM, LARHEC, LARFCAL, TILE). Cells which belong to one of the input cell containers and to one of the calorimeters in this vector are used as input for the cluster maker. This property is used in order to ignore a certain subsystem (e.g. for LAREM only clusters specify only LAREM in the jobOptions).

Definition at line 81 of file CaloTopoClusterMaker.h.

m_cellCutsInAbsE

bool CaloTopoClusterMaker::m_cellCutsInAbsE

private

if set to true cell cuts are on \(|E|\) and \(|E|_\perp\).

The cell cuts will be on absolute energy and absolute transverse energy if this is set to true. If set to false the cuts will be on energy and transverse energy instead.

Definition at line 243 of file CaloTopoClusterMaker.h.

m_cellsKey

SG::ReadHandleKey<CaloCellContainer> CaloTopoClusterMaker::m_cellsKey

private

vector of names of the cell containers to use as input.

Definition at line 70 of file CaloTopoClusterMaker.h.

m_cellThresholdOnEorAbsEinSigma

float CaloTopoClusterMaker::m_cellThresholdOnEorAbsEinSigma

private

all cells have to satisfy \(|E| > N_{\rm cell}\,\sigma\)

This cut determines how much the cluster will extend beyond the last cell passing the neighbor threshold. The smaller this cut is the more cells will be allowed in the tail of the cluster. It should be smaller or equal to the neighbor threshold. If a cell passing this cut is neighbor of two or more cells passing the neighbor cut it will be inserted in the cluster which has the neighbor cell that was asked first for its neighbors. Since the original list of seed cells is ordered in descending order of \(E/\sigma\) (or \(|E|/\sigma\)) the distance of the cell (in number of cell generations passing the neighbor cut until this cell will be reached) usually determines in which cluster the cell will end up in. The cell cut should be lower or equal to the neighbor cut.

Definition at line 106 of file CaloTopoClusterMaker.h.

m_clusterCutsInAbsE

bool CaloTopoClusterMaker::m_clusterCutsInAbsE

private

if set to true final cluster cuts are on \(|E|_\perp\).

The final cluster cuts will be on absolute transverse energy if this is set to true. If set to false the cuts will be on transverse energy instead.

Definition at line 251 of file CaloTopoClusterMaker.h.

m_clusterEtorAbsEtCut

float CaloTopoClusterMaker::m_clusterEtorAbsEtCut

private

\(E_\perp\) cut on the final cluster.

The final cluster has to pass this cut (which is on \(E_\perp\) or \(|E|_\perp\) of the cluster depending on the above switch) in order to be inserted into the CaloClusterContainer.

Definition at line 259 of file CaloTopoClusterMaker.h.

m_clusterSize

xAOD::CaloCluster::ClusterSize CaloTopoClusterMaker::m_clusterSize

private

Cluster size enum. Set based on energy cut jobO.

Definition at line 360 of file CaloTopoClusterMaker.h.

m_cutOOTseed

bool CaloTopoClusterMaker::m_cutOOTseed

private

if set to true, seed cells failing the time cut are also excluded from cluster at all

Definition at line 279 of file CaloTopoClusterMaker.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_hashMax

IdentifierHash CaloTopoClusterMaker::m_hashMax

private

Definition at line 356 of file CaloTopoClusterMaker.h.

m_hashMin

IdentifierHash CaloTopoClusterMaker::m_hashMin

private

Definition at line 355 of file CaloTopoClusterMaker.h.

m_maxSampling

int CaloTopoClusterMaker::m_maxSampling

private

largest valid seed sampling found

This is needed to adjust the range of the vector<bool> for a quick lookup if a cell belongs to a valid sampling for seeds or not.

Definition at line 346 of file CaloTopoClusterMaker.h.

m_minSampling

int CaloTopoClusterMaker::m_minSampling

private

smallest valid seed sampling found

This is needed to adjust the range of the vector<bool> for a quick lookup if a cell belongs to a valid sampling for seeds or not.

Definition at line 338 of file CaloTopoClusterMaker.h.

m_neighborCutsInAbsE

bool CaloTopoClusterMaker::m_neighborCutsInAbsE

private

if set to true neighbor cuts are on \(|E|\) and \(|E|_\perp\).

The neighbor cuts will be on absolute energy and absolute transverse energy if this is set to true. If set to false the cuts will be on energy and transverse energy instead.

Definition at line 235 of file CaloTopoClusterMaker.h.

m_neighborOption

std::string CaloTopoClusterMaker::m_neighborOption

private

type of neighbor relations to use.

The CaloIdentifier package defines different types of neighbors for the calorimeter cells. Currently supported neighbor relations for topological clustering are:

• "all2D" for all cells in the same layer (sampling or module) of one calorimeter subsystem. Note that endcap and barrel will be unconnected in this case even for the LAREM.

• "all3D" for all cells in the same calorimeter. This means all the "all2D" neighbors for each cell plus the cells in adjacent samplings overlapping at least partially in \(\eta\) and \(\phi\) with the cell. Note that endcap and barrel will be connected in this case for the LAREM.

• "super3D" for all cells. This means all the "all3D" neighbors for each cell plus the cells in adjacent samplings from other subsystems overlapping at least partially in \(\eta\) and \(\phi\) with the cell. All calorimeters are connected in this case.

The default setting is "super3D".

Definition at line 196 of file CaloTopoClusterMaker.h.

m_neighborThresholdOnEorAbsEinSigma

float CaloTopoClusterMaker::m_neighborThresholdOnEorAbsEinSigma

private

cells with \(|E| > N_{\rm neighbor}\,\sigma\) extend the cluster

This cut determines how many cells are asked for their neighbors to expand the cluster. The smaller this cut is the more cells will be asked for their neighbors. If a cell passing this cut is neighbor of two other cells passing this cut from different clusters, the two clusters are merged. The neighbor cut should be lower or equal to the seed cut.

Definition at line 117 of file CaloTopoClusterMaker.h.

m_noiseCDOKey

SG::ReadCondHandleKey<CaloNoise> CaloTopoClusterMaker::m_noiseCDOKey {this,"CaloNoiseKey","totalNoise","SG Key of CaloNoise data object"}

private

Key of the CaloNoise Conditions data object.

Typical values are '"electronicNoise', 'pileupNoise', or '"totalNoise' (default)

Definition at line 167 of file CaloTopoClusterMaker.h.

{this,"CaloNoiseKey","totalNoise","SG Key of CaloNoise data object"};

m_nOption

LArNeighbours::neighbourOption CaloTopoClusterMaker::m_nOption

private

Definition at line 197 of file CaloTopoClusterMaker.h.

m_restrictHECIWandFCalNeighbors

bool CaloTopoClusterMaker::m_restrictHECIWandFCalNeighbors

private

if set to true limit the neighbors in HEC IW and FCal2&3.

The cells in HEC IW and FCal2&3 get very large in terms of eta and phi. Since this might pose problems on certain jet algorithms one might need to avoid expansion in eta and phi for those cells. If this property is set to true the 2d neighbors of these cells are not used - only the next sampling neighbors are probed.

Definition at line 208 of file CaloTopoClusterMaker.h.

m_restrictPSNeighbors

bool CaloTopoClusterMaker::m_restrictPSNeighbors

private

if set to true limit the neighbors in presampler Barrel and Endcap.

The presampler cells add a lot of PileUp in the Hilum samples. With this option set to true the presampler cells do not expand the cluster in the presampler layer. Only the next sampling is used as valid neighbor source.

Definition at line 217 of file CaloTopoClusterMaker.h.

m_samplingNames

std::vector<std::string> CaloTopoClusterMaker::m_samplingNames

private

vector of names of the calorimeter samplings to consider for seeds.

The default is to use all calorimeter samplings. Excluding a sampling from this vector prevents the definition of a seed cell in this sampling. Cells in those samplings are still used and incorporated in the topo clusters (both on the neighbor and the cell level) they can therefore even expand a cluster but not seed one ...

Definition at line 323 of file CaloTopoClusterMaker.h.

m_seedCutsInAbsE

bool CaloTopoClusterMaker::m_seedCutsInAbsE

private

if set to true seed cuts are on \(|E|\) and \(|E|_\perp\).

The seed cuts and the \(E_\perp\) cut on the final clusters before insertion to the CaloClusterContainer will be on absolute energy and absolute transverse energy if this is set to true. If set to false the cuts will be on energy and transverse energy instead.

Definition at line 227 of file CaloTopoClusterMaker.h.

m_seedCutsInT

bool CaloTopoClusterMaker::m_seedCutsInT

private

if set to true, time cut is applied to seed cells, no cut otherwise

Definition at line 274 of file CaloTopoClusterMaker.h.

m_seedThresholdOnEorAbsEinSigma

float CaloTopoClusterMaker::m_seedThresholdOnEorAbsEinSigma

private

cells with \(|E| > N_{\rm seed}\,\sigma\) start a cluster

This cut determines how many clusters are formed initially. The smaller this cut is the more clusters will be created. During the accumulation of cells inside the clusters it can happen that clusters are merged if a cell passing the neighbor threshold would be included in both clusters.

Definition at line 127 of file CaloTopoClusterMaker.h.

m_seedThresholdOnTAbs

float CaloTopoClusterMaker::m_seedThresholdOnTAbs

private

threshold used for timing cut on seed cells.

Implemented as |seed_cell_time|<m_seedThresholdOnTAbs. No such cut on neighbouring cells.

Definition at line 132 of file CaloTopoClusterMaker.h.

m_subcaloUsed

bool CaloTopoClusterMaker::m_subcaloUsed[CaloCell_ID::NSUBCALO]

private

Flag which subdetectors are to be used.

This is initialized according to the names given in the property m_caloNames.

Definition at line 88 of file CaloTopoClusterMaker.h.

m_timeCutUpperLimit

float CaloTopoClusterMaker::m_timeCutUpperLimit

private

upper limit on the energy significance, for applying the cell time cut

Definition at line 136 of file CaloTopoClusterMaker.h.

m_treatL1PredictedCellsAsGood

bool CaloTopoClusterMaker::m_treatL1PredictedCellsAsGood

private

if set to true treat cells with a dead OTX which can be predicted by L1 trigger info as good instead of bad cells

Definition at line 269 of file CaloTopoClusterMaker.h.

m_twogaussiannoise

bool CaloTopoClusterMaker::m_twogaussiannoise

private

if set to true use 2-gaussian noise description for TileCal

Definition at line 264 of file CaloTopoClusterMaker.h.

m_useGPUCriteria

Gaudi::Property<bool> CaloTopoClusterMaker::m_useGPUCriteria {this, "UseGPUCriteria", false, "Adopt a set of criteria that is consistent with the GPU implementation."}

private

Definition at line 362 of file CaloTopoClusterMaker.h.

{this, "UseGPUCriteria", false, "Adopt a set of criteria that is consistent with the GPU implementation."};

m_useSampling

std::vector<bool> CaloTopoClusterMaker::m_useSampling

private

flag for all samplings - true for used ones, false for excluded ones

This vector serves as a quick lookup table to find out if a cell belongs to a sampling that should be used for seeds.

Definition at line 353 of file CaloTopoClusterMaker.h.

m_useTimeCutUpperLimit

bool CaloTopoClusterMaker::m_useTimeCutUpperLimit

private

if set to true, the time cut is not applied on cell of large significance

Definition at line 284 of file CaloTopoClusterMaker.h.

m_validSamplings

std::set<int> CaloTopoClusterMaker::m_validSamplings

private

actual set of samplings to be used for seeds

This set is created according to the names given in the property m_samplingNames.

Definition at line 330 of file CaloTopoClusterMaker.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_xtalk2DEratio

float CaloTopoClusterMaker::m_xtalk2DEratio

private

cut on Eneighbor/E to remove out of time layer layer2 all 2D neighbors

Definition at line 161 of file CaloTopoClusterMaker.h.

m_xtalk2Eratio1

float CaloTopoClusterMaker::m_xtalk2Eratio1

private

cut on Eneighbor/E to revover out of time cell close to energetic first phi neighbor cell

Definition at line 145 of file CaloTopoClusterMaker.h.

m_xtalk2Eratio2

float CaloTopoClusterMaker::m_xtalk2Eratio2

private

cut on Eneighbor/E to revover out of time cell close to energetic second phi neighbor cell

Definition at line 149 of file CaloTopoClusterMaker.h.

m_xtalk3Eratio

float CaloTopoClusterMaker::m_xtalk3Eratio

private

cut on Eneighbor/E to revover out of time layer 3cell close to energetic previous sampling neighbor

Definition at line 153 of file CaloTopoClusterMaker.h.

m_xtalkDeltaT

float CaloTopoClusterMaker::m_xtalkDeltaT

private

additional max.

delta t added to the upper limit time window in case of xtalk in EM2 should be accounted for

Definition at line 141 of file CaloTopoClusterMaker.h.

m_xtalkEM2

bool CaloTopoClusterMaker::m_xtalkEM2

private

if set to true, the time window is softened in the EMB2 and EME2_OW due to xtalk from direct neighbour cells in phi

Definition at line 289 of file CaloTopoClusterMaker.h.

m_xtalkEM2D

bool CaloTopoClusterMaker::m_xtalkEM2D

private

if set to true, the time window is softened in the EMB2 and EME2_OW due to xtalk from all 2D neighors

Definition at line 294 of file CaloTopoClusterMaker.h.

m_xtalkEM2n

bool CaloTopoClusterMaker::m_xtalkEM2n

private

if set to true (together with m_xtalkEM2) we also extend the time window for 2nd phi neighbors

Definition at line 299 of file CaloTopoClusterMaker.h.

m_xtalkEM3

bool CaloTopoClusterMaker::m_xtalkEM3

private

if set to true we extend the time window for direct layer 3 neighbors of high energy layer 2 cells

Definition at line 304 of file CaloTopoClusterMaker.h.

m_xtalkEMEta

bool CaloTopoClusterMaker::m_xtalkEMEta

private

if set to true, the time window is softened in the EMB2 and EME2_OW due to xtalk from direct neighbour cells in eta

Definition at line 310 of file CaloTopoClusterMaker.h.

m_xtalkEtaEratio

float CaloTopoClusterMaker::m_xtalkEtaEratio

private

cut on Eneighbor/E to revover out of time layer 2 cell close in eta to energetic neighor cell

Definition at line 157 of file CaloTopoClusterMaker.h.

---

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

• CaloTopoClusterMaker.h
• CaloTopoClusterMaker.cxx