#include <CaloClusterMomentsMaker_DigiHSTruth.h>

Inheritance diagram for CaloClusterMomentsMaker_DigiHSTruth:

Collaboration diagram for CaloClusterMomentsMaker_DigiHSTruth:

Public Member Functions
	CaloClusterMomentsMaker_DigiHSTruth (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 > &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

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

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	Standard Gaudi interface ID method. 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 > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

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

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

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &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::ReadHandleKey< CaloCellContainer >	m_signalCellKey {this,"SignalCells","AllCalo_DigiHSTruth"}

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

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

Definition at line 44 of file CaloClusterMomentsMaker_DigiHSTruth.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_DigiHSTruth()

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

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

Definition at line 113 of file CaloClusterMomentsMaker_DigiHSTruth.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) 
 {
   // Name(s) of Moments to calculate
   declareProperty("MomentsNames",m_momentsNames);
  
   // Name(s) of Moments which can be stored on the AOD - all others go to ESD
   // m_momentsNamesAOD.push_back(std::string("FIRST_PHI"));
   // m_momentsNamesAOD.push_back(std::string("FIRST_ETA"));
   // m_momentsNamesAOD.push_back(std::string("SECOND_R"));
   // m_momentsNamesAOD.push_back(std::string("SECOND_LAMBDA"));
   // m_momentsNamesAOD.push_back(std::string("CENTER_LAMBDA"));
   // m_momentsNamesAOD.push_back(std::string("FIRST_ENG_DENS"));
   // m_momentsNamesAOD.push_back(std::string("ENG_BAD_CELLS"));
   // m_momentsNamesAOD.push_back(std::string("N_BAD_CELLS"));
  
   //declareProperty("AODMomentsNames",m_momentsNamesAOD);
   // maximum allowed angle between shower axis and the vector pointing
   // to the shower center from the IP in degrees. This property is need
   // to protect against cases where all significant cells are in one sampling
   // and the shower axis can not be defined from them
   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");
  
   declareProperty("AODMomentsNames",m_momentsNamesAOD);
   // Use weighting of neg. clusters option?
   declareProperty("WeightingOfNegClusters", m_absOpt);
 }

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	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 > &	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 > &	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 > &	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);
   }

◆ 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 > & 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_DigiHSTruth::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 276 of file CaloClusterMomentsMaker_DigiHSTruth.cxx.

 {
  
   ATH_MSG_DEBUG("Executing " << name());
  
   SG::ReadHandle<CaloCellContainer> signalCells(m_signalCellKey,ctx);
  
   // 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 iCluster = 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* myCell = *cellIter;
  
         const CaloDetDescrElement * caloDDE = myCell->caloDDE();
         IdentifierHash hashid=caloDDE->calo_hash() ;
         if(! hashid.is_valid() ) continue;
         if(hashid >= (signalCells)->size()) continue;
         myCell = (*signalCells).findCell(hashid);
         if(!myCell) continue;
  
  
     Identifier myId = myCell->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 = iCluster;
     }
     else {
       clusterIdx[(unsigned int)myHashId].first = iCluster;
     }
       }
       ++iCluster;
     }
   }
  
   // 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_DigiHSTruth_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<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);
     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 ncell(0),i,nSigSampl(0);
     unsigned int theNumOfCells = theCluster->size();
         double theClusterEnergy = 0;
         double theClusterAbsEnergy = 0;
         double theClusterEta = 0;
         double theClusterPhi = 0;
     
     // these two are needed for the LATERAL moment
     int iCellMax(-1);
     int iCellScndMax(-1);
  
     if (cellinfo.capacity() == 0)
       cellinfo.reserve (theNumOfCells*2);
     cellinfo.resize (theNumOfCells);
     
     double phi0 = theCluster->phi();;
     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);
         const CaloDetDescrElement * caloDDE = pCell->caloDDE();
         IdentifierHash hashid=caloDDE->calo_hash() ;
         if(! hashid.is_valid() ) continue;
  
         if(hashid >= (signalCells)->size()) continue;
         pCell = (*signalCells).findCell(hashid);
  
         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);
  
         double thePhi;
         double cellPhi = myCDDE->phi();
         thePhi = proxim (cellPhi, phi0);
  
         theClusterEnergy += weight * ene;
         theClusterAbsEnergy += weight*std::abs(ene);
         theClusterEta += weight*std::abs(ene)*pCell->eta(); 
         theClusterPhi += weight*std::abs(ene)* thePhi; 
         if ( pCell->badcell() )       {
           eBad += ene*weight;
           nbad++;
           if(ene!=0){
             ebad_dac+=ene*weight;
             nbad_dac++;
             }
         }
     else {
       if ( ! (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->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 geomtery weighted energy of cell for leading cell significance
       double Sig = (sigma>0?ene*weight/sigma:0);
       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 && ene > 0. && weight > 0) {
       // get all geometric information needed ...
           CaloClusterMomentsMaker_DigiHSTruth_detail::cellinfo& ci = cellinfo[ncell];
       ci.x      = myCDDE->x();
       ci.y      = myCDDE->y();
       ci.z      = myCDDE->z();
       ci.eta    = myCDDE->eta();
       ci.phi    = myCDDE->phi();
       ci.energy = ene*weight;
       ci.volume = myCDDE->volume();
       ci.sample = myCDDE->getSampling();
       if ( ci.energy > maxSampE[(unsigned int)ci.sample] )
         maxSampE[(unsigned int)ci.sample] = ci.energy;
       
       if (iCellMax < 0 || ci.energy > cellinfo[iCellMax].energy ) {
         iCellScndMax = iCellMax;
         iCellMax = ncell;
       }
       else if (iCellScndMax < 0 ||
                    ci.energy > cellinfo[iCellScndMax].energy )
           {
         iCellScndMax = ncell;
       }
       
       xc += ci.energy*ci.x;
       yc += ci.energy*ci.y;
       zc += ci.energy*ci.z;
       w  += ci.energy;
      
       ncell++;
     }
       } //end of loop over all cells
  
       if ( w > 0 ) {
     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 ( ncell > 2 ) {
       Eigen::Matrix3d C=Eigen::Matrix3d::Zero();
       for(i=0;i<ncell;i++) {
             const CaloClusterMomentsMaker_DigiHSTruth_detail::cellinfo& ci = cellinfo[i];
             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 !S[i]==0
       }// end else got Eigenvalues
     } //end if ncell>2
       
     ATH_MSG_DEBUG("Shower Axis = (" << showerAxis.x() << ", "
               << showerAxis.y() << ", " << showerAxis.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 = ncell > 0 ? cellinfo[0].phi : 0;
     for(i=0;i<ncell;i++) {
           const CaloClusterMomentsMaker_DigiHSTruth_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 xAOD::CaloCluster::FIRST_ETA_DigiHSTruth:
         myMoments[iMoment] += ci.energy*ci.eta;
         break;
         case xAOD::CaloCluster::FIRST_PHI_DigiHSTruth:
           // 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 xAOD::CaloCluster::SECOND_R_DigiHSTruth:
           myMoments[iMoment] += ci.energy*ci.r*ci.r;
           break;
         case xAOD::CaloCluster::SECOND_LAMBDA_DigiHSTruth:
           myMoments[iMoment] += ci.energy*ci.lambda*ci.lambda;
           break;
         case xAOD::CaloCluster::LATERAL_DigiHSTruth:
           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 xAOD::CaloCluster::LONGITUDINAL_DigiHSTruth:
           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 xAOD::CaloCluster::FIRST_ENG_DENS_DigiHSTruth:
           if ( ci.volume > 0 ) {
         myMoments[iMoment] += ci.energy*ci.energy/ci.volume;
         myNorms[iMoment] += ci.energy;
           }
           break;
         case xAOD::CaloCluster::SECOND_ENG_DENS_DigiHSTruth:
           if ( ci.volume > 0 ) {
         myMoments[iMoment] += ci.energy*std::pow(ci.energy/ci.volume,2);
         myNorms[iMoment] += ci.energy;
           }
           break;
         case xAOD::CaloCluster::ENG_FRAC_EM_DigiHSTruth:
           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 xAOD::CaloCluster::ENG_FRAC_MAX_DigiHSTruth:
           if ( (int)i == iCellMax ) 
         myMoments[iMoment] = ci.energy;
           break;
         default:
           // nothing to be done for other moments
           break;
         }
       }
     } //end of loop over cell
  
     const auto hvFrac=m_larHVFraction->getLArHVFrac(theCluster->getCellLinks(),ctx);
     eBadLArHV= hvFrac.first;
     nBadLArHV=hvFrac.second;
  
     
     // 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 xAOD::CaloCluster::FIRST_ETA_DigiHSTruth:
       case xAOD::CaloCluster::FIRST_PHI_DigiHSTruth:
       case xAOD::CaloCluster::SECOND_R_DigiHSTruth:
       case xAOD::CaloCluster::SECOND_LAMBDA_DigiHSTruth:
       case xAOD::CaloCluster::ENG_FRAC_EM_DigiHSTruth:
       case xAOD::CaloCluster::ENG_FRAC_MAX_DigiHSTruth:
         myNorms[iMoment] = commonNorm;
         break;
       case xAOD::CaloCluster::DELTA_PHI_DigiHSTruth:
         myMoments[iMoment] = deltaPhi;
         break;
       case xAOD::CaloCluster::DELTA_THETA_DigiHSTruth:
         myMoments[iMoment] = deltaTheta;
         break;
       case xAOD::CaloCluster::DELTA_ALPHA_DigiHSTruth:
         myMoments[iMoment] = angle;
         break;
       case xAOD::CaloCluster::CENTER_X_DigiHSTruth:
         myMoments[iMoment] = showerCenter.x();
         break;
       case xAOD::CaloCluster::CENTER_Y_DigiHSTruth:
         myMoments[iMoment] = showerCenter.y();
         break;
       case xAOD::CaloCluster::CENTER_Z_DigiHSTruth:
         myMoments[iMoment] = showerCenter.z();
         break;
       case xAOD::CaloCluster::CENTER_MAG_DigiHSTruth:
         myMoments[iMoment] = showerCenter.mag();
         break;
       case xAOD::CaloCluster::CENTER_LAMBDA_DigiHSTruth:
         // 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 xAOD::CaloCluster::ENG_FRAC_CORE_DigiHSTruth:
         for(i=0;i<(int)CaloCell_ID::Unknown;i++) 
           myMoments[iMoment] += maxSampE[i];
         myNorms[iMoment] = commonNorm;
         break;
       case xAOD::CaloCluster::ISOLATION_DigiHSTruth:
         {
           // 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 xAOD::CaloCluster::ENG_BAD_CELLS_DigiHSTruth:
         myMoments[iMoment] = eBad;
         break;
       case xAOD::CaloCluster::N_BAD_CELLS_DigiHSTruth:
         myMoments[iMoment] = nbad;
             break;
           case xAOD::CaloCluster::N_BAD_CELLS_CORR_DigiHSTruth:
             myMoments[iMoment] = nbad_dac;
             break;
       case xAOD::CaloCluster::BAD_CELLS_CORR_E_DigiHSTruth:
         myMoments[iMoment] = ebad_dac;
             break;
       case xAOD::CaloCluster::BADLARQ_FRAC_DigiHSTruth:
         myMoments[iMoment] = eBadLArQ/(theCluster->e()!=0.?theCluster->e():1.);
             break;
       case xAOD::CaloCluster::ENG_POS_DigiHSTruth:
         myMoments[iMoment] = ePos;
             break;
       case xAOD::CaloCluster::SIGNIFICANCE_DigiHSTruth:
         myMoments[iMoment] = (sumSig2>0?theCluster->e()/sqrt(sumSig2):0.);
             break;
       case xAOD::CaloCluster::CELL_SIGNIFICANCE_DigiHSTruth:
         myMoments[iMoment] = maxAbsSig;
             break;
       case xAOD::CaloCluster::CELL_SIG_SAMPLING_DigiHSTruth:
         myMoments[iMoment] = nSigSampl;
             break;
       case xAOD::CaloCluster::AVG_LAR_Q_DigiHSTruth:
         myMoments[iMoment] = eLAr2Q/(eLAr2>0?eLAr2:1);
             break;
       case xAOD::CaloCluster::AVG_TILE_Q_DigiHSTruth:
         myMoments[iMoment] = eTile2Q/(eTile2>0?eTile2:1);
             break;
       case xAOD::CaloCluster::ENG_BAD_HV_CELLS_DigiHSTruth:
         myMoments[iMoment] = eBadLArHV;
         break;
       case xAOD::CaloCluster::N_BAD_HV_CELLS_DigiHSTruth:
         myMoments[iMoment] = nBadLArHV;
             break;
       case xAOD::CaloCluster::ENERGY_DigiHSTruth:
         myMoments[iMoment] = theClusterEnergy;
             break;
       case xAOD::CaloCluster::ETA_DigiHSTruth:
       if(theClusterAbsEnergy > 0)
         myMoments[iMoment] = theClusterEta / theClusterAbsEnergy;
       else{
         myMoments[iMoment] = 0;
             }
             break;
       case xAOD::CaloCluster::PHI_DigiHSTruth:
       if(theClusterAbsEnergy > 0)
         myMoments[iMoment] = CaloPhiRange::fix(theClusterPhi / theClusterAbsEnergy);
       else{
         myMoments[iMoment] = 0;
             }
             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 == xAOD::CaloCluster::FIRST_PHI_DigiHSTruth ) 
       myMoments[iMoment] = CaloPhiRange::fix(myMoments[iMoment]);
     
     theCluster->insertMoment(moment,myMoments[iMoment]);
       }
     }
   }
  
   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 49 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 49 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_DigiHSTruth::finalize ( )

overridevirtual

Definition at line 945 of file CaloClusterMomentsMaker_DigiHSTruth.cxx.

 {
   return StatusCode::SUCCESS;
 }

◆ initialize()

StatusCode CaloClusterMomentsMaker_DigiHSTruth::initialize ( )

overridevirtual

Definition at line 164 of file CaloClusterMomentsMaker_DigiHSTruth.cxx.

 {
  
   //FIXME: All that could be done at initialize!
   m_calculateSignificance = false;
   m_calculateIsolation = false;
  
   // translate all moment names specified in MomentsNames property to moment enums,
   // check that they are all valid and there are no repeating names
   for(const auto& name: m_momentsNames) {
     const MomentName* it =
       std::lower_bound (moment_names, moment_names_end, name);
       //std::find(moment_names, moment_names_end, name);
       //moment_names.find(name);
  
         for(const auto& testName: moment_names){
             if(name == testName.name) it = &testName;
         }
     if (it != moment_names_end) {
       m_validMoments.push_back (it->mom);
       switch (it->mom) {
       case xAOD::CaloCluster::SIGNIFICANCE_DigiHSTruth:
       case xAOD::CaloCluster::CELL_SIGNIFICANCE_DigiHSTruth:
         m_calculateSignificance = true;
         break;
       case xAOD::CaloCluster::ISOLATION_DigiHSTruth:
         m_calculateIsolation = true;
         break;
       case xAOD::CaloCluster::ENG_BAD_HV_CELLS_DigiHSTruth:
         m_calculateLArHVFraction = true;
       default:
         break;
       }
     }
     else {
       msg(MSG::ERROR) << "Moment " << name
               << " is not a valid Moment name and will be ignored! "
               << "Valid names are:";
       int count = 0;
       for (const MomentName& m : moment_names)
     msg() << ((count++)==0?" ":", ") << m.name;
       msg() << endmsg;
     }
   }
  
   // sort and remove duplicates, order is not required for any of the code below
   // but still may be useful property
   std::stable_sort(m_validMoments.begin(), m_validMoments.end());
 /*
   m_validMoments.erase(std::unique(m_validMoments.begin(),
                                    m_validMoments.end()),
                        m_validMoments.end());
 */
  
   
   /*
   // translate moment names in AODMomentsNames property into set of enums,
   // only take valid names which are also in MomentsNames property
   m_momentsAOD.reserve(m_momentsNamesAOD.size());
   for(const auto& name: m_momentsNamesAOD) {
     const MomentName* it =
       std::lower_bound (moment_names, moment_names_end, name);
     if (it != moment_names_end) {
       if (std::find(m_validMoments.begin(), m_validMoments.end(), it->mom)
           != m_validMoments.end())
       {
         m_momentsAOD.push_back(it->mom);
       }
     }
   }
   */
   
   ATH_CHECK(detStore()->retrieve(m_calo_id,"CaloCell_ID"));
   
   ATH_CHECK(m_caloDepthTool.retrieve());
   ATH_CHECK(m_caloMgrKey.initialize());
  
   if (m_calculateSignificance) {
     ATH_CHECK(m_noiseCDOKey.initialize());
   }
  
   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.

◆ interfaceID()

static const InterfaceID& CaloClusterCollectionProcessor::interfaceID ( )

inlinestaticinherited

Standard Gaudi interface ID method.

Definition at line 58 of file CaloClusterCollectionProcessor.h.

58 {return IID_CaloClusterCollectionProcessor;}

◆ 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_DigiHSTruth::m_absOpt

private

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

* cluster moments

Definition at line 141 of file CaloClusterMomentsMaker_DigiHSTruth.h.

◆ m_calculateIsolation

bool CaloClusterMomentsMaker_DigiHSTruth::m_calculateIsolation

private

Set to true if cluster isolation is to be calculated.

Definition at line 111 of file CaloClusterMomentsMaker_DigiHSTruth.h.

◆ m_calculateLArHVFraction

bool CaloClusterMomentsMaker_DigiHSTruth::m_calculateLArHVFraction

private

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

Definition at line 114 of file CaloClusterMomentsMaker_DigiHSTruth.h.

◆ m_calculateSignificance

bool CaloClusterMomentsMaker_DigiHSTruth::m_calculateSignificance

private

Set to true if significance moments are need.

Definition at line 108 of file CaloClusterMomentsMaker_DigiHSTruth.h.

◆ m_calo_id

const CaloCell_ID* CaloClusterMomentsMaker_DigiHSTruth::m_calo_id

private

Definition at line 75 of file CaloClusterMomentsMaker_DigiHSTruth.h.

◆ m_caloDepthTool

ToolHandle<CaloDepthTool> CaloClusterMomentsMaker_DigiHSTruth::m_caloDepthTool

private

Definition at line 121 of file CaloClusterMomentsMaker_DigiHSTruth.h.

◆ m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> CaloClusterMomentsMaker_DigiHSTruth::m_caloMgrKey

private

Initial value:

{
    this,
    "CaloDetDescrManager",
    "CaloDetDescrManager"
  }

Definition at line 123 of file CaloClusterMomentsMaker_DigiHSTruth.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_larHVFraction

ToolHandle<ILArHVFraction> CaloClusterMomentsMaker_DigiHSTruth::m_larHVFraction

private

Definition at line 134 of file CaloClusterMomentsMaker_DigiHSTruth.h.

◆ m_maxAxisAngle

double CaloClusterMomentsMaker_DigiHSTruth::m_maxAxisAngle

private

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

Definition at line 79 of file CaloClusterMomentsMaker_DigiHSTruth.h.

◆ m_minBadLArQuality

double CaloClusterMomentsMaker_DigiHSTruth::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 105 of file CaloClusterMomentsMaker_DigiHSTruth.h.

◆ m_minLLongitudinal

double CaloClusterMomentsMaker_DigiHSTruth::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 97 of file CaloClusterMomentsMaker_DigiHSTruth.h.

◆ m_minRLateral

double CaloClusterMomentsMaker_DigiHSTruth::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 87 of file CaloClusterMomentsMaker_DigiHSTruth.h.

◆ m_momentsNames

std::vector<std::string> CaloClusterMomentsMaker_DigiHSTruth::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 65 of file CaloClusterMomentsMaker_DigiHSTruth.h.

◆ m_momentsNamesAOD

std::string CaloClusterMomentsMaker_DigiHSTruth::m_momentsNamesAOD

private

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

Definition at line 137 of file CaloClusterMomentsMaker_DigiHSTruth.h.

◆ m_noiseCDOKey

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

◆ m_signalCellKey

SG::ReadHandleKey<CaloCellContainer> CaloClusterMomentsMaker_DigiHSTruth::m_signalCellKey {this,"SignalCells","AllCalo_DigiHSTruth"}

private

Definition at line 129 of file CaloClusterMomentsMaker_DigiHSTruth.h.

◆ m_twoGaussianNoise

bool CaloClusterMomentsMaker_DigiHSTruth::m_twoGaussianNoise

private

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

Definition at line 119 of file CaloClusterMomentsMaker_DigiHSTruth.h.

◆ m_validMoments

std::vector<xAOD::CaloCluster::MomentType> CaloClusterMomentsMaker_DigiHSTruth::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 73 of file CaloClusterMomentsMaker_DigiHSTruth.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

Static Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ CaloClusterMomentsMaker_DigiHSTruth()

Member Function Documentation

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ 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()

◆ interfaceID()

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

◆ m_larHVFraction

◆ m_maxAxisAngle

◆ m_minBadLArQuality

◆ m_minLLongitudinal

◆ m_minRLateral

◆ m_momentsNames

◆ m_momentsNamesAOD

◆ m_noiseCDOKey

◆ m_signalCellKey

◆ m_twoGaussianNoise

◆ m_validMoments

◆ m_varHandleArraysDeclared

◆ m_vhka