CaloClusterMomentsMaker Class Reference

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.
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode	execute (xAOD::CaloClusterContainer *collection) final
	Execute on an entire collection of clusters.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
	DeclareInterfaceID (CaloClusterCollectionProcessor, 1, 0)

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

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

Private Attributes
std::vector< std::string >	m_momentsNames
	vector holding the input list of names of moments to calculate.
std::vector< xAOD::CaloCluster::MomentType >	m_validMoments
	set of moments which will be calculated.
const CaloCell_ID *	m_calo_id
double	m_maxAxisAngle
	the maximal allowed deviation from the IP-to-ClusterCenter-axis.
double	m_minRLateral
	the minimal \(r\) in the definition of the Lateral moment
double	m_minLLongitudinal
	the minimal \(\lambda\) in the definition of the Longitudinal moment
double	m_minBadLArQuality
	the minimal cell quality in the LAr for declaring a cell bad
bool	m_calculateSignificance
	Set to true if significance moments are need.
bool	m_calculateIsolation
	Set to true if cluster isolation is to be calculated.
bool	m_calculateLArHVFraction
	Set to true to calculate E and N of cells affected by LAr HV corrections.
bool	m_twoGaussianNoise
	if set to true use 2-gaussian noise description for TileCal
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.
ToolHandle< ILArHVFraction >	m_larHVFraction
std::string	m_momentsNamesAOD
	Not used anymore (with xAOD), but required when configured from COOL.
bool	m_absOpt
	if set to true use abs E value of cells to calculate cluster moments
bool	m_secondTime = { false }
	Retrieve second moment of cell times and store as moment.
bool	m_nCellsPerSampling = { false }
	store number of cells per sampling layer as moment
double	m_etaInnerWheel = { 2.52 }
	Transition from outer to inner wheel in EME2.
Gaudi::Property< bool >	m_useGPUCriteria {this, "UseGPUCriteria", false, "Adopt a set of criteria that is consistent with the GPU implementation."}
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

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

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

DeclareInterfaceID()

CaloClusterCollectionProcessor::DeclareInterfaceID ( CaloClusterCollectionProcessor , 1 , 0  )

inherited

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute() [1/2]

StatusCode 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 = cellIter.index()
                //Using the index instead of the hash ID as disambiguation criterion
                //is relevant for the GPU now that we no longer assume the two are the same,
                //and this gives us better performance.
              });
 
        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 || (m_useGPUCriteria && 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);
    }
 
  if (w == 0) {
      w = 1.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 ( 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 != 0 ? w : 1.0);
      
      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() [2/2]

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

inlinefinalvirtual

Execute on an entire collection of clusters.

Parameters

collection

The container of clusters. (deprecated)

Reimplemented from CaloClusterCollectionProcessor.

Definition at line 50 of file CaloClusterCollectionProcessor.h.

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

extraDeps_update_handler()

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

protectedinherited

Add StoreName to extra input/output deps as needed.

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

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

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

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

overridevirtualinherited

Perform system initialization for an algorithm.

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

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

sysStart()

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

overridevirtualinherited

Handle START transition.

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

updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

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

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

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.

{ 2.52 };

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.

{ false };

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.

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

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.

{ false };

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.

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

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:

• CaloClusterMomentsMaker.h
• CaloClusterMomentsMaker.cxx