Calculate moments for CaloCluster objects. More...

#include <CaloClusterMomentsMaker.h>

Inheritance diagram for CaloClusterMomentsMaker:

Collaboration diagram for CaloClusterMomentsMaker:

Public Member Functions
	CaloClusterMomentsMaker (const std::string &type, const std::string &name, const IInterface *parent)

virtual StatusCode	execute (const EventContext &ctx, xAOD::CaloClusterContainer *theClusColl) const override final
	Execute on an entire collection of clusters. More...

virtual StatusCode	initialize () override

virtual StatusCode	finalize () override

virtual StatusCode	execute (const EventContext &ctx, xAOD::CaloClusterContainer *collection) const=0
	Execute on an entire collection of clusters. More...

virtual StatusCode	execute (xAOD::CaloClusterContainer *collection) final
	Execute on an entire collection of clusters. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

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

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

	DeclareInterfaceID (CaloClusterCollectionProcessor, 1, 0)

virtual StatusCode	execute (xAOD::CaloClusterContainer *collection) final
	Execute on an entire collection of clusters. More...

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
std::vector< std::string >	m_momentsNames
	vector holding the input list of names of moments to calculate. More...

std::vector< xAOD::CaloCluster::MomentType >	m_validMoments
	set of moments which will be calculated. More...

const CaloCell_ID *	m_calo_id

double	m_maxAxisAngle
	the maximal allowed deviation from the IP-to-ClusterCenter-axis. More...

double	m_minRLateral
	the minimal \(r\) in the definition of the Lateral moment More...

double	m_minLLongitudinal
	the minimal \(\lambda\) in the definition of the Longitudinal moment More...

double	m_minBadLArQuality
	the minimal cell quality in the LAr for declaring a cell bad More...

bool	m_calculateSignificance
	Set to true if significance moments are need. More...

bool	m_calculateIsolation
	Set to true if cluster isolation is to be calculated. More...

bool	m_calculateLArHVFraction
	Set to true to calculate E and N of cells affected by LAr HV corrections. More...

bool	m_twoGaussianNoise
	if set to true use 2-gaussian noise description for TileCal More...

ToolHandle< CaloDepthTool >	m_caloDepthTool

SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloMgrKey

SG::ReadCondHandleKey< CaloNoise >	m_noiseCDOKey {this,"CaloNoiseKey","totalNoise","SG Key of CaloNoise data object"}
	Key of the CaloNoise Conditions data object. More...

ToolHandle< ILArHVFraction >	m_larHVFraction

std::string	m_momentsNamesAOD
	Not used anymore (with xAOD), but required when configured from COOL. More...

bool	m_absOpt
	if set to true use abs E value of cells to calculate cluster moments More...

bool	m_secondTime = { false }
	Retrieve second moment of cell times and store as moment. More...

bool	m_nCellsPerSampling = { false }
	store number of cells per sampling layer as moment More...

double	m_etaInnerWheel = { 2.52 }
	Transition from outer to inner wheel in EME2. More...

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) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Calculate moments for CaloCluster objects.

Author: Sven Menke menke.nosp@m.@mpp.nosp@m.mu.mp.nosp@m.g.de; Peter Loch loch@.nosp@m.phys.nosp@m.ics.a.nosp@m.rizo.nosp@m.na.ed.nosp@m.u

Date: 23-March-2021 This is a CaloClusterCollectionProcessor which can be plugged into a CaloClusterMaker for calculating moments for each CaloCluster. Typically a cluster moment of a certain degree \(n\) over a variable \(x\) defined for each CaloCell member of a CaloCluster is defined as:

\[ \langle x^n\rangle = \frac{1}{E_{\rm norm}} \times \!\!\!\sum\limits_{\{{\rm cell}|E_{\rm cell}>0\}}{\!\!\!E_{\rm cell}\, x^n},\]

with

\[ E_{\rm norm} = \!\!\!\sum\limits_{\{{\rm cell}|E_{\rm cell}>0\}}{\!\!\!E_{\rm cell}}. \]

Note that only cells with positive energy are used in this definition. Common variables to calculate first and second moments of are \(\phi\), \(\eta\), and radial and longitudinal distances from the shower axis and the shower center, respectively.

Since: 23-March-2021: second moment of cell time distribution is calculated

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

Date: 28-February-2005 This is a CaloClusterCollectionProcessor which can be plugged into a CaloClusterMaker for calculating moments for each CaloCluster. Typically a cluster moment of a certain degree \(n\) over a variable \(x\) defined for each CaloCell member of a CaloCluster is defined as:

\[ \langle x^n\rangle = \frac{1}{E_{\rm norm}} \times \!\!\!\sum\limits_{\{{\rm cell}|E_{\rm cell}>0\}}{\!\!\!E_{\rm cell}\, x^n},\]

with

\[ E_{\rm norm} = \!\!\!\sum\limits_{\{{\rm cell}|E_{\rm cell}>0\}}{\!\!\!E_{\rm cell}}. \]

Note that only cells with positive energy are used in this definition. Common variables to calculate first and second moments of are \(\phi\), \(\eta\), and radial and longitudinal distances from the shower axis and the shower center, respectively.

Definition at line 49 of file CaloClusterMomentsMaker.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

◆ CaloClusterMomentsMaker()

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

Definition at line 141 of file CaloClusterMomentsMaker.cxx.

   : AthAlgTool(type, name, parent),
     m_calo_id(nullptr),
     m_maxAxisAngle(20*deg), 
     m_minRLateral(4*cm), 
     m_minLLongitudinal(10*cm),
     m_minBadLArQuality(4000),
     m_calculateSignificance(false),
     m_calculateIsolation(false),
     m_calculateLArHVFraction(false),
     m_twoGaussianNoise(false),
     m_caloDepthTool("CaloDepthTool",this),
     m_larHVFraction("LArHVFraction",this),
     m_absOpt(false) 
 {
   declareInterface<CaloClusterCollectionProcessor> (this);
   // Name(s) of Moments to calculate
   declareProperty("MomentsNames",m_momentsNames);
  
   // Maximum allowed angle between shower axis and the vector pointing
   // to the shower center from the IP in degrees. This property is needed
   // to protect against cases where all significant cells are in one sampling
   // and the shower axis can thus not be defined.
   declareProperty("MaxAxisAngle",m_maxAxisAngle);
   declareProperty("MinRLateral",m_minRLateral);
   declareProperty("MinLLongitudinal",m_minLLongitudinal);
   declareProperty("MinBadLArQuality",m_minBadLArQuality);
   // Use 2-gaussian noise for Tile
   declareProperty("TwoGaussianNoise",m_twoGaussianNoise);
   declareProperty("LArHVFraction",m_larHVFraction,"Tool Handle for LArHVFraction");
   // Not used anymore (with xAOD), but required when configured from  COOL.
   declareProperty("AODMomentsNames",m_momentsNamesAOD);
   // Use weighting of neg. clusters option?
   declareProperty("WeightingOfNegClusters", m_absOpt);
   // Set eta boundary for transition from outer to inner wheel in EME2
   declareProperty("EMECAbsEtaWheelTransition",m_etaInnerWheel);
 }

Member Function Documentation

◆ declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ DeclareInterfaceID()

CaloClusterCollectionProcessor::DeclareInterfaceID	(	CaloClusterCollectionProcessor	,
		1	,
		0
	)

inherited

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

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.

95 { return m_detStore; }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute() [1/4]

virtual StatusCode CaloClusterCollectionProcessor::execute

Execute on an entire collection of clusters.

Parameters

collection The container of clusters. param ctx The event context.

◆ execute() [2/4]

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

finaloverridevirtual

Execute on an entire collection of clusters.

Parameters

collection The container of clusters. param ctx The event context.

Implements CaloClusterCollectionProcessor.

Definition at line 340 of file CaloClusterMomentsMaker.cxx.

 { 
   ATH_MSG_DEBUG("Executing " << name());
  
   // Maps cell IdentifierHash to cluster index in cluster collection.
   // Only used when cluster isolation moment is calculated.
   using clusterIdx_t = std::uint16_t;
   typedef std::pair<clusterIdx_t, clusterIdx_t> clusterPair_t;
   std::vector<clusterPair_t> clusterIdx;
   const clusterIdx_t noCluster = std::numeric_limits<clusterIdx_t>::max();
  
   const CaloNoise* noise=nullptr;
   if (m_calculateSignificance) {
     SG::ReadCondHandle<CaloNoise> noiseHdl{m_noiseCDOKey,ctx};
     noise=*noiseHdl;
   }
  
   SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{ m_caloMgrKey, ctx };
   const CaloDetDescrManager* caloDDMgr = *caloMgrHandle;
   // Counters for number of empty and non-empty neighbor cells per sampling
   // layer Only used when cluster isolation moment is calculated.
   int nbEmpty[CaloCell_ID::Unknown];
   int nbNonEmpty[CaloCell_ID::Unknown];
  
   // prepare stuff from entire collection in case isolation moment
   // should be calculated
  
   if ( m_calculateIsolation ) {
  
     if (theClusColl->size() >= noCluster) {
       msg(MSG::ERROR) << "Too many clusters" << endmsg;
       return StatusCode::FAILURE;
     }
  
     // initialize with "empty" values
     clusterIdx.resize(m_calo_id->calo_cell_hash_max(),
                       clusterPair_t(noCluster, noCluster));
  
     int iClus = 0;
     for (xAOD::CaloCluster* theCluster : *theClusColl) {
       // loop over all cell members and fill cell vector for used cells
       xAOD::CaloCluster::cell_iterator cellIter    = theCluster->cell_begin();
       xAOD::CaloCluster::cell_iterator cellIterEnd = theCluster->cell_end();
       for(; cellIter != cellIterEnd; cellIter++ ){
         CxxUtils::prefetchNext(cellIter, cellIterEnd);
         const CaloCell* pCell = *cellIter;
  
     Identifier myId = pCell->ID();
     IdentifierHash myHashId = m_calo_id->calo_cell_hash(myId); 
     if ( clusterIdx[(unsigned int)myHashId].first != noCluster) {
       // check weight and assign to current cluster if weight is > 0.5
       double weight = cellIter.weight();
       if ( weight > 0.5 )
         clusterIdx[(unsigned int)myHashId].first = iClus;
     }
     else {
       clusterIdx[(unsigned int)myHashId].first = iClus;
     }
       }
       ++iClus;
     }
   }
  
   // Move allocation of temporary arrays outside the cluster loop.
   // That way, we don't need to delete and reallocate them
   // each time through the loop.
  
   std::vector<CaloClusterMomentsMaker_detail::cellinfo> cellinfo;
   std::vector<double> maxSampE (CaloCell_ID::Unknown);
   std::vector<double> myMoments(m_validMoments.size(),0);
   std::vector<double> myNorms(m_validMoments.size(),0);
   std::vector<std::tuple<int,int> > nCellsSamp; nCellsSamp.reserve(CaloCell_ID::Unknown);
   std::vector<IdentifierHash> theNeighbors;
   // loop over individual clusters
   xAOD::CaloClusterContainer::iterator clusIter = theClusColl->begin();
   xAOD::CaloClusterContainer::iterator clusIterEnd = theClusColl->end();
   int iClus = 0;
   for( ;clusIter!=clusIterEnd;++clusIter,++iClus) {
     xAOD::CaloCluster * theCluster = *clusIter;
  
     double w(0),xc(0),yc(0),zc(0),mx(0),my(0),mz(0),mass(0);
     double eBad(0),ebad_dac(0),ePos(0),eBadLArQ(0),sumSig2(0),maxAbsSig(0);
     double eLAr2(0),eLAr2Q(0);
     double eTile2(0),eTile2Q(0);
     double eBadLArHV(0);
     int nbad(0),nbad_dac(0),nBadLArHV(0);
     unsigned int i,nSigSampl(0);
     unsigned int theNumOfCells = theCluster->size();
     
     // these two are needed for the LATERAL moment
     int iCellMax(-1);
     int iCellScndMax(-1);
  
     cellinfo.clear();
     if (cellinfo.capacity() == 0)
       cellinfo.reserve (theNumOfCells*2);
     
     for(i=0;i<(unsigned int)CaloCell_ID::Unknown;i++) 
       maxSampE[i] = 0;
     
     if ( !m_momentsNames.empty() ) {
       std::fill (myMoments.begin(), myMoments.end(), 0);
       std::fill (myNorms.begin(),   myNorms.end(),   0);
       if ( m_calculateIsolation ) {
         std::fill_n(nbNonEmpty, CaloCell_ID::Unknown, 0);
         std::fill_n(nbEmpty, CaloCell_ID::Unknown, 0);
       }
       
       // loop over all cell members and calculate the center of mass
       xAOD::CaloCluster::cell_iterator cellIter    = theCluster->cell_begin();
       xAOD::CaloCluster::cell_iterator cellIterEnd = theCluster->cell_end();
       for(; cellIter != cellIterEnd; cellIter++ ){
         CaloPrefetch::nextDDE(cellIter, cellIterEnd);
  
         const CaloCell* pCell = (*cellIter);
     Identifier myId = pCell->ID();
     const CaloDetDescrElement* myCDDE = pCell->caloDDE();
     double ene = pCell->e();
         if(m_absOpt) ene = std::abs(ene);  
     double weight = cellIter.weight();//theCluster->getCellWeight(cellIter);
     if ( pCell->badcell() ) {
       eBad += ene*weight;
       nbad++;
       if(ene!=0){
         ebad_dac+=ene*weight;
         nbad_dac++;
       }
     }
     else {
       if ( myCDDE && ! (myCDDE->is_tile()) 
            && ((pCell->provenance() & 0x2000) == 0x2000) 
            && !((pCell->provenance() & 0x0800) == 0x0800)) {
         if ( pCell->quality() > m_minBadLArQuality ) {
           eBadLArQ += ene*weight;
         }
         eLAr2  += ene*weight*ene*weight;
         eLAr2Q += ene*weight*ene*weight*pCell->quality();
       }
       if ( myCDDE && myCDDE->is_tile() ) {
         uint16_t tq = pCell->quality();
         uint8_t tq1 = (0xFF00&tq)>>8; // quality in channel 1
         uint8_t tq2 = (0xFF&tq); // quality in channel 2
         // reject cells with either 0xFF00 or 0xFF
         if ( ((tq1&0xFF) != 0xFF) && ((tq2&0xFF) != 0xFF) ) {    
           eTile2  += ene*weight*ene*weight;
           // take the worse of both qualities (one might be 0 in
           // 1-channel cases)
           eTile2Q += ene*weight*ene*weight*(tq1>tq2?tq1:tq2);
         }
       } 
     }
     if ( ene > 0 ) {
       ePos += ene*weight;
     }
       
     if ( m_calculateSignificance ) {
       const float sigma = m_twoGaussianNoise ?\
         noise->getEffectiveSigma(pCell->ID(),pCell->gain(),pCell->energy()) : \
         noise->getNoise(pCell->ID(),pCell->gain());
  
       sumSig2 += sigma*sigma;
       // use geometry weighted energy of cell for leading cell significance
       double Sig = (sigma>0?ene*weight/sigma:0);
       if (m_useGPUCriteria) {
         unsigned int thisSampl = myCDDE->getSampling();
         if ( ( std::abs(Sig) > std::abs(maxAbsSig) )                                                 ||
          ( std::abs(Sig) == std::abs(maxAbsSig) && thisSampl > nSigSampl )                       ||
          ( std::abs(Sig) == std::abs(maxAbsSig) && thisSampl == nSigSampl && Sig > maxAbsSig )      ) {
           maxAbsSig = Sig;
           nSigSampl = thisSampl;
         }
  
       }
       else {
         if ( std::abs(Sig) > std::abs(maxAbsSig) ) {
           maxAbsSig = Sig;
           nSigSampl = myCDDE->getSampling();
         }
       }
     }
     if ( m_calculateIsolation ) {
       // get all 2D Neighbours if the cell is not inside another cluster with
       // larger weight
  
       IdentifierHash myHashId = m_calo_id->calo_cell_hash(myId);
       if ( clusterIdx[myHashId].first == iClus ) {
             theNeighbors.clear();
         m_calo_id->get_neighbours(myHashId, LArNeighbours::all2D, theNeighbors);
         for (const auto& nhash: theNeighbors) {
               clusterPair_t& idx = clusterIdx[nhash];
  
           // only need to look at each cell once per cluster
           if ( idx.second == iClus ) continue;
           idx.second = iClus;
  
           if ( idx.first == noCluster ) {
             ++ nbEmpty[m_calo_id->calo_sample(nhash)];
           } else if ( idx.first != iClus ) {
                 ++ nbNonEmpty[m_calo_id->calo_sample(nhash)];
           }
  
         }
       }
     }
  
     if ( myCDDE != nullptr ) { 
       if ( m_nCellsPerSampling ) { 
         CaloCell_ID::CaloSample sam = myCDDE->getSampling();
         size_t idx((size_t)sam);
         if ( idx >= nCellsSamp.size() ) { nCellsSamp.resize(idx+1, { 0, 0 } ); }
         std::get<0>(nCellsSamp[idx])++;
         // special count for inner wheel cells in EME2
         if ( sam == CaloCell_ID::EME2 && std::abs(myCDDE->eta()) > m_etaInnerWheel ) { std::get<1>(nCellsSamp[idx])++; }
       }
       if ( ene > 0. && weight > 0) {
         // get all geometric information needed ...
             cellinfo.push_back (CaloClusterMomentsMaker_detail::cellinfo {
                 .x = myCDDE->x(),
                 .y = myCDDE->y(),
                 .z = myCDDE->z(),
                 .energy = ene*weight,
                 .eta = myCDDE->eta(),
                 .phi = myCDDE->phi(),
                 .r = 0,       // These two are filled in later.
                 .lambda = 0,
                 .volume = myCDDE->volume(),
                 .sample = myCDDE->getSampling(),
                 .identifier = m_calo_id->calo_cell_hash(myId)});
  
         CaloClusterMomentsMaker_detail::cellinfo& ci = cellinfo.back();
  
         if ( ci.energy > maxSampE[(unsigned int)ci.sample] )
           maxSampE[(unsigned int)ci.sample] = ci.energy;
  
         if (m_useGPUCriteria) {
           if (iCellMax < 0                                                                              ||
           ci.energy > cellinfo[iCellMax].energy                                                     ||
           (ci.energy == cellinfo[iCellMax].energy && ci.identifier > cellinfo[iCellMax].identifier)    ) {
         iCellScndMax = iCellMax;
         iCellMax = cellinfo.size()-1;
           }
           else if (iCellScndMax < 0                                                                                  ||
                ci.energy > cellinfo[iCellScndMax].energy                                                         ||
                (ci.energy == cellinfo[iCellScndMax].energy && ci.identifier > cellinfo[iCellScndMax].identifier)    )
         {
           iCellScndMax = cellinfo.size()-1;
         }
         }
         else {
           if (iCellMax < 0 || ci.energy > cellinfo[iCellMax].energy ) {
         iCellScndMax = iCellMax;
         iCellMax = cellinfo.size()-1;
           }
           else if (iCellScndMax < 0 ||
                ci.energy > cellinfo[iCellScndMax].energy )
         {
           iCellScndMax = cellinfo.size()-1;
         }
         }
       
         xc += ci.energy*ci.x;
         yc += ci.energy*ci.y;
         zc += ci.energy*ci.z;
  
         double dir = ci.x*ci.x+ci.y*ci.y+ci.z*ci.z;
         
         if ( dir > 0) {
           dir = sqrt(dir);
           dir = 1./dir;
         }
         mx += ci.energy*ci.x*dir;
         my += ci.energy*ci.y*dir;
         mz += ci.energy*ci.z*dir;
         
         w  += ci.energy;
       } // cell has E>0 and weight != 0
     } // cell has valid DDE
       } //end of loop over all cells
       if (m_calculateLArHVFraction) {
     const auto hvFrac=m_larHVFraction->getLArHVFrac(theCluster->getCellLinks(),ctx);
     eBadLArHV= hvFrac.first;
     nBadLArHV=hvFrac.second;
       }
  
       if ( w > 0 ) {
     mass = w*w - mx*mx - my*my - mz*mz;
     if ( mass > 0) {
       mass = sqrt(mass);
     }
     else {
       // make mass negative if m^2 was negative
       mass = -sqrt(-mass);
     }
  
     xc/=w;
     yc/=w;
     zc/=w;
     Amg::Vector3D showerCenter(xc,yc,zc);
     w=0;
     
  
     //log << MSG::WARNING << "Found bad cells " <<  xbad_dac << " " << ybad_dac << " " << zbad_dac << " " << ebad_dac <<  endmsg;
     //log << MSG::WARNING << "Found Cluster   " <<  xbad_dac << " " << ybad_dac << " " << zbad_dac << " " <<  endmsg;
     // shower axis is just the vector pointing from the IP to the shower center
     // in case there are less than 3 cells in the cluster
     
     Amg::Vector3D showerAxis(xc,yc,zc);
     Amg::setMag(showerAxis,1.0);
  
     // otherwise the principal direction with the largest absolute 
     // eigenvalue will be used unless it's angle w.r.t. the vector pointing
     // from the IP to the shower center is larger than allowed by the 
     // property m_maxAxisAngle
  
     double angle(0),deltaPhi(0),deltaTheta(0);
     if ( cellinfo.size() > 2 ) {
       Eigen::Matrix3d C=Eigen::Matrix3d::Zero();
       for(const CaloClusterMomentsMaker_detail::cellinfo& ci : cellinfo) {
             const double e2 = ci.energy * ci.energy;
             
         C(0,0) += e2*(ci.x-xc)*(ci.x-xc);
         C(1,0) += e2*(ci.x-xc)*(ci.y-yc);
         C(2,0) += e2*(ci.x-xc)*(ci.z-zc);
         
         C(1,1) += e2*(ci.y-yc)*(ci.y-yc);
         C(2,1) += e2*(ci.y-yc)*(ci.z-zc);
         
         C(2,2) += e2*(ci.z-zc)*(ci.z-zc);
         w += e2;
       } 
       C/=w;
       
       Eigen::SelfAdjointEigenSolver<Eigen::Matrix3d> eigensolver(C);
       if (eigensolver.info() != Eigen::Success) {
         msg(MSG::WARNING) << "Failed to compute Eigenvalues -> Can't determine shower axis" << endmsg;
       }
       else {
         // don't use the principal axes if at least one of the 3 
         // diagonal elements is 0
  
         const Eigen::Vector3d& S=eigensolver.eigenvalues(); 
         const Eigen::Matrix3d& U=eigensolver.eigenvectors();
  
             const double epsilon = 1.E-6;
  
         if ( std::abs(S[0]) >= epsilon && std::abs(S[1]) >= epsilon && std::abs(S[2]) >= epsilon ) { 
         
           Amg::Vector3D prAxis(showerAxis);
           int iEigen = -1;
         
           for (i=0;i<3;i++) {
         Amg::Vector3D tmpAxis=U.col(i);
  
         // calculate the angle      
         double tmpAngle=Amg::angle(tmpAxis,showerAxis);
         
         if ( tmpAngle > 90*deg ) { 
           tmpAngle = 180*deg - tmpAngle;
           tmpAxis = -tmpAxis;
         }
         
         if ( iEigen == -1 || tmpAngle < angle ) {
           iEigen = i;
           angle = tmpAngle;
           prAxis = tmpAxis;
         }
           }//end for loop     
         
           // calculate theta and phi angle differences
           
           deltaPhi = CaloPhiRange::diff(showerAxis.phi(),prAxis.phi());
         
           deltaTheta = showerAxis.theta() - prAxis.theta();
         
           // check the angle
         
           if ( angle < m_maxAxisAngle ) {
         showerAxis = prAxis;
           }
           else 
         ATH_MSG_DEBUG("principal Direction (" << prAxis[Amg::x] << ", " 
                   << prAxis[Amg::y] << ", " << prAxis[Amg::z] << ") deviates more than " 
                   << m_maxAxisAngle*(1./deg) 
                   << " deg from IP-to-ClusterCenter-axis (" << showerAxis[Amg::x] << ", "
                   << showerAxis[Amg::y] << ", " << showerAxis[Amg::z] << ")");
         }//end if std::abs(S)<epsilon
         else {
           ATH_MSG_DEBUG("Eigenvalues close to 0, do not use principal axis");
         }
       }//end got eigenvalues
     } //end if cellinfo.size()>2
       
     ATH_MSG_DEBUG("Shower Axis = (" << showerAxis[Amg::x] << ", "
               << showerAxis[Amg::y] << ", " << showerAxis[Amg::z] << ")");
     
  
     // calculate radial distance from and the longitudinal distance
     // along the shower axis for each cell. The cluster center is 
     // at r=0 and lambda=0
     
     for (auto& ci : cellinfo) {
       const Amg::Vector3D currentCell(ci.x,ci.y,ci.z);
       // calculate distance from shower axis r
       ci.r = ((currentCell-showerCenter).cross(showerAxis)).mag();
       // calculate distance from shower center along shower axis
       ci.lambda = (currentCell-showerCenter).dot(showerAxis);
     }  
     
     // loop over all positive energy cells and calculate all desired moments
     
     // define common norm for all simple moments
     double commonNorm = 0;
         double phi0 = cellinfo.size() > 0 ? cellinfo[0].phi : 0;
  
     for(unsigned i=0;i<cellinfo.size();i++) {
       const CaloClusterMomentsMaker_detail::cellinfo& ci = cellinfo[i];
       // loop over all valid moments
       commonNorm += ci.energy;
       for(size_t iMoment = 0, size = m_validMoments.size();
               iMoment != size;
               ++ iMoment)
           {
         // now calculate the actual moments
         switch (m_validMoments[iMoment]) {
         case FIRST_ETA:
           myMoments[iMoment] += ci.energy*ci.eta;
           break;
         case FIRST_PHI:
           // first cell decides the sign in order to avoid
           // overlap problem at phi = -pi == +pi
           // need to be normalized to the range [-pi,+pi] in the end
               myMoments[iMoment] += ci.energy * proxim (ci.phi, phi0);
           break;
         case SECOND_R:
           myMoments[iMoment] += ci.energy*ci.r*ci.r;
           break;
         case SECOND_LAMBDA:
           myMoments[iMoment] += ci.energy*ci.lambda*ci.lambda;
           break;
         case LATERAL:
           if ( (int)i != iCellMax && (int)i != iCellScndMax ) {
         myMoments[iMoment] += ci.energy*ci.r*ci.r;
         myNorms[iMoment] += ci.energy*ci.r*ci.r;
           }
           else {
         double rm = ci.r;
         if ( rm < m_minRLateral ) 
           rm = m_minRLateral;
         myNorms[iMoment] += rm*rm*ci.energy;
           }
           break;
         case LONGITUDINAL:
           if ( (int)i != iCellMax && (int)i != iCellScndMax ) {
         myMoments[iMoment] += ci.energy*ci.lambda*ci.lambda;
         myNorms[iMoment] += ci.energy*ci.lambda*ci.lambda;
           }
           else {
         double lm = ci.lambda;
         if ( lm < m_minLLongitudinal ) 
           lm = m_minLLongitudinal;
         myNorms[iMoment] += lm*lm*ci.energy;
           }
           break;
         case FIRST_ENG_DENS:
           if ( ci.volume > 0 ) {
         myMoments[iMoment] += ci.energy*ci.energy/ci.volume;
         myNorms[iMoment] += ci.energy;
           }
           break;
         case SECOND_ENG_DENS:
           if ( ci.volume > 0 ) {
         myMoments[iMoment] += ci.energy*std::pow(ci.energy/ci.volume,2);
         myNorms[iMoment] += ci.energy;
           }
           break;
         case ENG_FRAC_EM:
           if ( ci.sample == CaloCell_ID::EMB1 
            || ci.sample == CaloCell_ID::EMB2 
            || ci.sample == CaloCell_ID::EMB3 
            || ci.sample == CaloCell_ID::EME1
            || ci.sample == CaloCell_ID::EME2
            || ci.sample == CaloCell_ID::EME3
            || ci.sample == CaloCell_ID::FCAL0 )
         myMoments[iMoment] += ci.energy;
           break;
         case ENG_FRAC_MAX:
           if ( (int)i == iCellMax ) 
         myMoments[iMoment] = ci.energy;
           break;
         case PTD:
           // do not convert to pT since clusters are small and
           // there is virtually no difference and cosh just costs
           // time ...
           myMoments[iMoment] += ci.energy*ci.energy;
           myNorms[iMoment] += ci.energy;
           break;
         default:
           // nothing to be done for other moments
           break;
         }
       }
     } //end of loop over cell
       
     
     // assign moments which don't need the loop over the cells
         for (size_t iMoment = 0, size = m_validMoments.size();
              iMoment != size;
              ++ iMoment)
         {
       // now calculate the actual moments
           switch (m_validMoments[iMoment]) {
       case FIRST_ETA:
       case FIRST_PHI:
       case SECOND_R:
       case SECOND_LAMBDA:
       case ENG_FRAC_EM:
       case ENG_FRAC_MAX:
         myNorms[iMoment] = commonNorm;
         break;
       case DELTA_PHI:
         myMoments[iMoment] = deltaPhi;
         break;
       case DELTA_THETA:
         myMoments[iMoment] = deltaTheta;
         break;
       case DELTA_ALPHA:
         myMoments[iMoment] = angle;
         break;
       case CENTER_X:
         myMoments[iMoment] = showerCenter.x();
         break;
       case CENTER_Y:
         myMoments[iMoment] = showerCenter.y();
         break;
       case CENTER_Z:
         myMoments[iMoment] = showerCenter.z();
         break;
       case CENTER_MAG:
         myMoments[iMoment] = showerCenter.mag();
         break;
       case CENTER_LAMBDA:
         // calculate the longitudinal distance along the shower axis
         // of the shower center from the calorimeter start
         
         // first need calo boundary at given eta phi try LAREM barrel
         // first, then LAREM endcap OW, then LAREM endcap IW, then
         // FCal
         {
           double r_calo(0),z_calo(0),lambda_c(0); 
           r_calo = m_caloDepthTool->get_entrance_radius(CaloCell_ID::EMB1,
                                 showerCenter.eta(),
                                 showerCenter.phi(),
                   caloDDMgr);
           if ( r_calo == 0 ) {
         z_calo = m_caloDepthTool->get_entrance_z(CaloCell_ID::EME1,
                              showerCenter.eta(),
                              showerCenter.phi(),
                caloDDMgr);
         if ( z_calo == 0 ) 
           z_calo = m_caloDepthTool->get_entrance_z(CaloCell_ID::EME2,
                                showerCenter.eta(),
                                showerCenter.phi(),
                  caloDDMgr);
         if ( z_calo == 0 ) 
           z_calo = m_caloDepthTool->get_entrance_z(CaloCell_ID::FCAL0,
                                showerCenter.eta(),
                                showerCenter.phi(),
                  caloDDMgr);
         if ( z_calo == 0 ) // for H6 TB without EMEC outer wheel 
           z_calo = m_caloDepthTool->get_entrance_z(CaloCell_ID::HEC0,
                                showerCenter.eta(),
                                showerCenter.phi(),
                  caloDDMgr);
         if ( z_calo != 0 && showerAxis.z() != 0 ) {
           lambda_c = std::abs((z_calo-showerCenter.z())/showerAxis.z());
         }
           }
           else {
         double r_s2 = showerAxis.x()*showerAxis.x()
           +showerAxis.y()*showerAxis.y();
         double r_cs = showerAxis.x()*showerCenter.x()
           +showerAxis.y()*showerCenter.y();
         double r_cr = showerCenter.x()*showerCenter.x()
           +showerCenter.y()*showerCenter.y()-r_calo*r_calo;
         if ( r_s2 > 0 ) {
           double det = r_cs*r_cs/(r_s2*r_s2) - r_cr/r_s2;
           if ( det > 0 ) {
             det = sqrt(det);
             double l1(-r_cs/r_s2);
             double l2(l1);
             l1 += det;
             l2 -= det;
             if ( std::abs(l1) < std::abs(l2) ) 
               lambda_c = std::abs(l1);
             else
               lambda_c = std::abs(l2);
           }
         }
           }
           myMoments[iMoment] = lambda_c;
         }
         break;
       case ENG_FRAC_CORE:
         for(i=0;i<(int)CaloCell_ID::Unknown;i++) 
           myMoments[iMoment] += maxSampE[i];
         myNorms[iMoment] = commonNorm;
         break;
       case ISOLATION:
         {
           // loop over empty and filled perimeter cells and
           // get a weighted ratio by means of energy fraction per layer
           for(unsigned int i=0; i != CaloSampling::Unknown; ++ i) {
         const xAOD::CaloCluster::CaloSample s=( xAOD::CaloCluster::CaloSample)(i);
         if (theCluster->hasSampling(s)) {
           const double eSample = theCluster->eSample(s);
           if (eSample > 0) {
             int nAll = nbEmpty[i]+nbNonEmpty[i];
             if (nAll > 0) {
               myMoments[iMoment] += (eSample*nbEmpty[i])/nAll;
               myNorms[iMoment] += eSample;
             }
           }//end of eSample>0
         }//end has sampling
           }//end loop over samplings
         }
         break;
       case ENG_BAD_CELLS:
         myMoments[iMoment] = eBad;
         break;
       case N_BAD_CELLS:
         myMoments[iMoment] = nbad;
             break;
           case N_BAD_CELLS_CORR:
             myMoments[iMoment] = nbad_dac;
             break;
       case BAD_CELLS_CORR_E:
         myMoments[iMoment] = ebad_dac;
             break;
       case BADLARQ_FRAC:
         myMoments[iMoment] = eBadLArQ/(theCluster->e()!=0.?theCluster->e():1.);
             break;
       case ENG_POS:
         myMoments[iMoment] = ePos;
             break;
       case SIGNIFICANCE:
         myMoments[iMoment] = (sumSig2>0?theCluster->e()/sqrt(sumSig2):0.);
             break;
       case CELL_SIGNIFICANCE:
         myMoments[iMoment] = maxAbsSig;
             break;
       case CELL_SIG_SAMPLING:
         myMoments[iMoment] = nSigSampl;
             break;
       case AVG_LAR_Q:
         myMoments[iMoment] = eLAr2Q/(eLAr2>0?eLAr2:1);
             break;
       case AVG_TILE_Q:
         myMoments[iMoment] = eTile2Q/(eTile2>0?eTile2:1);
             break;
       case ENG_BAD_HV_CELLS:
         myMoments[iMoment] = eBadLArHV;
         break;
       case N_BAD_HV_CELLS:
         myMoments[iMoment] = nBadLArHV;
             break;
       case PTD:
         myMoments[iMoment] = sqrt(myMoments[iMoment]);
             break;
       case MASS:
         myMoments[iMoment] = mass;
         break;
       default:
         // nothing to be done for other moments
         break;
       }
     }
       }
  
       // normalize moments and copy to Cluster Moment Store
       size_t size= m_validMoments.size();
       for (size_t iMoment = 0; iMoment != size; ++iMoment) {
         xAOD::CaloCluster::MomentType moment = m_validMoments[iMoment];
     if ( myNorms[iMoment] != 0 ) 
       myMoments[iMoment] /= myNorms[iMoment];
     if ( moment == FIRST_PHI ) 
       myMoments[iMoment] = CaloPhiRange::fix(myMoments[iMoment]);
     theCluster->insertMoment(moment,myMoments[iMoment]);
       } // loop on moments for cluster
     } // check on requested moments
     // check on second moment of time if requested
     if ( m_secondTime ) { theCluster->insertMoment(SECOND_TIME,theCluster->secondTime()); }
     // check on number of cells per sampling moment if requested
     if ( m_nCellsPerSampling ) {
       for ( size_t isam(0); isam < nCellsSamp.size(); ++isam ) { 
     theCluster->setNumberCellsInSampling((CaloCell_ID::CaloSample)isam,std::get<0>(nCellsSamp.at(isam)),false);
     if ( isam == (size_t)CaloCell_ID::EME2 && std::get<1>(nCellsSamp.at(isam)) > 0 ) { 
       theCluster->setNumberCellsInSampling((CaloCell_ID::CaloSample)isam,std::get<1>(nCellsSamp.at(isam)),true); 
     }
       } // loop on samplings
       nCellsSamp.clear();
     }
   } // loop on clusters
  
   return StatusCode::SUCCESS;
 }

◆ execute() [3/4]

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

inlinefinalvirtualinherited

Execute on an entire collection of clusters.

Parameters

collection The container of clusters. (deprecated)

Definition at line 50 of file CaloClusterCollectionProcessor.h.

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

◆ execute() [4/4]

virtual StatusCode CaloClusterCollectionProcessor::execute

inlinefinal

Execute on an entire collection of clusters.

Parameters

collection The container of clusters. (deprecated)

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

◆ finalize()

StatusCode CaloClusterMomentsMaker::finalize ( )

overridevirtual

Definition at line 313 of file CaloClusterMomentsMaker.cxx.

 {
   return StatusCode::SUCCESS;
 }

◆ initialize()

StatusCode CaloClusterMomentsMaker::initialize ( )

overridevirtual

Definition at line 183 of file CaloClusterMomentsMaker.cxx.

 {
   xAOD::CaloCluster dummyCluster;
  
   // loop list of requested moments
   std::string::size_type nstr(0); int nmom(0);
   for (const auto& mom : m_momentsNames) {
     ATH_MSG_DEBUG("Moment " << mom << " requested");
     // check if moment is known (enumerator available)
     auto fmap(momentNameToEnumMap.find(mom));
     if (fmap != momentNameToEnumMap.end()) {
       // valid moment found
       nstr = std::max(nstr, mom.length());
       ++nmom;
       if (fmap->second == SECOND_TIME) {
         // special flag for second moment of cell times - this moment is not
         // calculated in this tool! Do not add to internal (!) valid moments
         // list. Its value is available from xAOD::CaloCluster::secondTime()!
         m_secondTime = true;
  
         // Make sure the variable used for the moment is declared
         // to the auxiliary variable registry.  Otherwise, if we don't
         // set the moment for the first event (perhaps because there
         // are no clusters), then we can get warnings from AuxSelection.
         (void)dummyCluster.getMomentValue (fmap->second);
       } else if (fmap->second == NCELL_SAMPLING) {
         // flag indicates if number of cells in a sampling should be counted.
         // This is a vector of integers counts that is filled in this tool but
         // does not need any post-processing (e.g. normalization). It is not
         // added to the valid moments list for this reason.
         ATH_MSG_DEBUG("moment " << fmap->first << " found");
         m_nCellsPerSampling = true;
         xAOD::CaloCluster::ncells_store_t cellsdum;
  
         // Make sure the variable used for the moment is declared
         // to the auxiliary variable registry.
         (void)dummyCluster.retrieveMoment (fmap->second, cellsdum);
       } else if (fmap->second == EM_PROBABILITY) {
         ATH_MSG_WARNING(mom
                         << " not calculated in this tool - misconfiguration?");
       } else {
         // Make sure the variable used for the moment is declared
         // to the auxiliary variable registry.
         (void)dummyCluster.getMomentValue (fmap->second);
  
         // all other valid moments
         m_validMoments.push_back(fmap->second);
         // flag some special requests
         switch (fmap->second) {
           case SIGNIFICANCE:
           case CELL_SIGNIFICANCE:
             m_calculateSignificance = true;
             break;
           case ISOLATION:
             m_calculateIsolation = true;
             break;
           case ENG_BAD_HV_CELLS:
             m_calculateLArHVFraction = true;
             break;
           default:
             break;
         }  // set special processing flags
       }    // moment calculated with this tool
     } else {
       ATH_MSG_ERROR("Moment name " << mom << " not known; known moments are:");
       char buffer[128];
       std::string::size_type lstr(nstr);
       // determine field size
       for (const auto& fmom : momentNameToEnumMap) {
         lstr = std::max(lstr, fmom.first.length());
       }
       // print available moments
       for (const auto& fmom : momentNameToEnumMap) {
         sprintf(buffer, "moment name: %-*.*s - enumerator: %i", (int)lstr,
                 (int)lstr, fmom.first.c_str(), (int)fmom.second);
         ATH_MSG_ERROR(buffer);
       }
       auto fmom(momentNameToEnumMap.find("SECOND_TIME"));
       sprintf(buffer, "moment name: %-*.*s - enumerator: %i", (int)nstr,
               (int)nstr, fmom->first.c_str(), (int)fmom->second);
       ATH_MSG_ERROR(buffer);
       fmom = momentNameToEnumMap.find("NCELL_SAMPLING");
       sprintf(buffer, "moment name: %-*.*s - enumerator: %i", (int)nstr,
               (int)nstr, fmom->first.c_str(), (int)fmom->second);
       ATH_MSG_ERROR(buffer);
       return StatusCode::FAILURE;
     }  // found unknown moment name
   }    // loop configured moment names
  
   // sort and remove duplicates
   std::sort(m_validMoments.begin(), m_validMoments.end());
   m_validMoments.erase(
       std::unique(m_validMoments.begin(), m_validMoments.end()),
       m_validMoments.end());
  
   // print configured moments
   ATH_MSG_INFO("Construct and save " << nmom << " cluster moments: ");
   char buffer[128];
   for (auto menum : m_validMoments) {
     sprintf(buffer, "moment name: %-*.*s - enumerator: %i", (int)nstr,
             (int)nstr, momentEnumToNameMap.at(menum).c_str(), (int)menum);
     ATH_MSG_INFO(buffer);
   }
   if (m_secondTime) {
     auto fmom(momentNameToEnumMap.find("SECOND_TIME"));
     sprintf(buffer, "moment name: %-*.*s - enumerator: %i (save only)",
             (int)nstr, (int)nstr, fmom->first.c_str(), (int)fmom->second);
     ATH_MSG_INFO(buffer);
   }
   if (m_nCellsPerSampling) {
     auto fmom(momentNameToEnumMap.find("NCELL_SAMPLING"));
     sprintf(buffer, "moment name: %-*.*s - enumerator: %i", (int)nstr,
             (int)nstr, fmom->first.c_str(), (int)fmom->second);
     ATH_MSG_INFO(buffer);
   }
  
   // retrieve CaloCell ID server
   CHECK(detStore()->retrieve(m_calo_id,"CaloCell_ID"));
   
   // retrieve the calo depth tool
   CHECK(m_caloDepthTool.retrieve());
   ATH_CHECK(m_caloMgrKey.initialize());
  
   // retrieve specific servers and tools for selected processes
   ATH_CHECK(m_noiseCDOKey.initialize(m_calculateSignificance));
   if (m_calculateLArHVFraction) { ATH_CHECK(m_larHVFraction.retrieve()); } else { m_larHVFraction.disable(); }
  
   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() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ 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 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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ 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_absOpt

bool CaloClusterMomentsMaker::m_absOpt

private

if set to true use abs E value of cells to calculate cluster moments

Definition at line 146 of file CaloClusterMomentsMaker.h.

◆ m_calculateIsolation

bool CaloClusterMomentsMaker::m_calculateIsolation

private

Set to true if cluster isolation is to be calculated.

Definition at line 115 of file CaloClusterMomentsMaker.h.

◆ m_calculateLArHVFraction

bool CaloClusterMomentsMaker::m_calculateLArHVFraction

private

Set to true to calculate E and N of cells affected by LAr HV corrections.

Definition at line 118 of file CaloClusterMomentsMaker.h.

◆ m_calculateSignificance

bool CaloClusterMomentsMaker::m_calculateSignificance

private

Set to true if significance moments are need.

Definition at line 112 of file CaloClusterMomentsMaker.h.

◆ m_calo_id

const CaloCell_ID* CaloClusterMomentsMaker::m_calo_id

private

Definition at line 79 of file CaloClusterMomentsMaker.h.

◆ m_caloDepthTool

ToolHandle<CaloDepthTool> CaloClusterMomentsMaker::m_caloDepthTool

private

Definition at line 125 of file CaloClusterMomentsMaker.h.

◆ m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> CaloClusterMomentsMaker::m_caloMgrKey

private

Initial value:

{
    this,
    "CaloDetDescrManager",
    "CaloDetDescrManager"
  }

Definition at line 127 of file CaloClusterMomentsMaker.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_etaInnerWheel

double CaloClusterMomentsMaker::m_etaInnerWheel = { 2.52 }

private

Transition from outer to inner wheel in EME2.

Definition at line 158 of file CaloClusterMomentsMaker.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_larHVFraction

ToolHandle<ILArHVFraction> CaloClusterMomentsMaker::m_larHVFraction

private

Definition at line 138 of file CaloClusterMomentsMaker.h.

◆ m_maxAxisAngle

double CaloClusterMomentsMaker::m_maxAxisAngle

private

the maximal allowed deviation from the IP-to-ClusterCenter-axis.

Definition at line 83 of file CaloClusterMomentsMaker.h.

◆ m_minBadLArQuality

double CaloClusterMomentsMaker::m_minBadLArQuality

private

the minimal cell quality in the LAr for declaring a cell bad

This defines the minimal quality (large values mean worse shape) a cell needs to exceed in order to be considered as not compatible with a normal ionization signal.

Definition at line 109 of file CaloClusterMomentsMaker.h.

◆ m_minLLongitudinal

double CaloClusterMomentsMaker::m_minLLongitudinal

private

the minimal \(\lambda\) in the definition of the Longitudinal moment

This defines the minimal distance along the shower axis from the cluster center the two leading cells might have before this value is used instead of their real distance in the normalization of the LONGITUDINAL moment.

Definition at line 101 of file CaloClusterMomentsMaker.h.

◆ m_minRLateral

double CaloClusterMomentsMaker::m_minRLateral

private

the minimal \(r\) in the definition of the Lateral moment

This defines the minimal distance the two leading cells might have before this value is used instead of their real distance in the normalization of the LATERAL moment.

Definition at line 91 of file CaloClusterMomentsMaker.h.

◆ m_momentsNames

std::vector<std::string> CaloClusterMomentsMaker::m_momentsNames

private

vector holding the input list of names of moments to calculate.

This is the list of desired names of moments given in the jobOptions.

Definition at line 69 of file CaloClusterMomentsMaker.h.

◆ m_momentsNamesAOD

std::string CaloClusterMomentsMaker::m_momentsNamesAOD

private

Not used anymore (with xAOD), but required when configured from COOL.

Definition at line 141 of file CaloClusterMomentsMaker.h.

◆ m_nCellsPerSampling

bool CaloClusterMomentsMaker::m_nCellsPerSampling = { false }

private

store number of cells per sampling layer as moment

Definition at line 154 of file CaloClusterMomentsMaker.h.

◆ m_noiseCDOKey

SG::ReadCondHandleKey<CaloNoise> CaloClusterMomentsMaker::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 136 of file CaloClusterMomentsMaker.h.

◆ m_secondTime

bool CaloClusterMomentsMaker::m_secondTime = { false }

private

Retrieve second moment of cell times and store as moment.

Definition at line 150 of file CaloClusterMomentsMaker.h.

◆ m_twoGaussianNoise

bool CaloClusterMomentsMaker::m_twoGaussianNoise

private

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

Definition at line 123 of file CaloClusterMomentsMaker.h.

◆ m_useGPUCriteria

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

private

Definition at line 161 of file CaloClusterMomentsMaker.h.

◆ m_validMoments

std::vector<xAOD::CaloCluster::MomentType> CaloClusterMomentsMaker::m_validMoments

private

set of moments which will be calculated.

This set will hold each valid enum indexed if its name was found on the input list (m_momentsNames) and in the list of valid moment names (m_validNames).

Definition at line 77 of file CaloClusterMomentsMaker.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.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ CaloClusterMomentsMaker()

Member Function Documentation

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ DeclareInterfaceID()

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute() [1/4]

◆ execute() [2/4]

◆ execute() [3/4]

◆ execute() [4/4]

◆ extraDeps_update_handler()

◆ finalize()

◆ initialize()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_absOpt

◆ m_calculateIsolation

◆ m_calculateLArHVFraction

◆ m_calculateSignificance

◆ m_calo_id

◆ m_caloDepthTool

◆ m_caloMgrKey

◆ m_detStore

◆ m_etaInnerWheel

◆ m_evtStore

◆ m_larHVFraction

◆ m_maxAxisAngle

◆ m_minBadLArQuality

◆ m_minLLongitudinal

◆ m_minRLateral

◆ m_momentsNames

◆ m_momentsNamesAOD

◆ m_nCellsPerSampling

◆ m_noiseCDOKey

◆ m_secondTime

◆ m_twoGaussianNoise

◆ m_useGPUCriteria

◆ m_validMoments

◆ m_varHandleArraysDeclared

◆ m_vhka