#include <JetCaloQualityUtils.h>

Inheritance diagram for jet::JetCalcCentroid:

Collaboration diagram for jet::JetCalcCentroid:

Public Types
typedef double	weight_t

Public Member Functions
virtual bool	setupEvent ()
virtual bool	setupJet (const xAOD::Jet *)=0
virtual bool	processConstituent (xAOD::JetConstituentVector::iterator &)
	Perform 1 calculation step using 1 constituent.
virtual double	jetCalculation () const
	return the result of the calculation
virtual double	operator() (const xAOD::Jet *jet, xAOD::JetConstitScale s=xAOD::UncalibratedJetConstituent)
	convenience function to perform the full calculation on a given jet
virtual std::string	name () const
void	setName (const std::string &n)
void	setExtractor (const CaloConstitHelpers::CaloConstitExtractor *ex)
virtual JetCaloCalculator *	clone () const =0
	Clone. Base class should not be cloned.

Protected Member Functions
	JETCALCFUNCDECL (JetCalcCentroid, JetAttribute::CentroidR, m_totE=0;)

Protected Attributes
double	m_totE {}
double	m_centroid_x {}
double	m_centroid_y {}
double	m_centroid_z {}
std::string	m_name
xAOD::JetAttribute::AttributeID	m_id {}
const CaloConstitHelpers::CaloConstitExtractor *	m_constitExtractor {}

Detailed Description

Definition at line 162 of file JetCaloQualityUtils.h.

Member Typedef Documentation

◆ weight_t

typedef double jet::JetCaloCalculator::weight_t

inherited

Definition at line 79 of file JetCaloCalculations.h.

Member Function Documentation

◆ clone()

virtual JetCaloCalculator * jet::JetCaloCalculator::clone ( ) const

pure virtualinherited

Clone. Base class should not be cloned.

Implemented in jet::JetCalcQualityHEC, and jet::JetCaloCellCalculator.

◆ JETCALCFUNCDECL()

jet::JetCalcCentroid::JETCALCFUNCDECL	(	JetCalcCentroid	,
		JetAttribute::CentroidR	,
		m_totE	= 0; )

protected

◆ jetCalculation()

virtual double jet::JetCaloCalculator::jetCalculation ( ) const

inlinevirtualinherited

return the result of the calculation

Definition at line 97 of file JetCaloCalculations.h.

97{return 0;};

◆ name()

virtual std::string jet::JetCaloCalculator::name ( ) const

inlinevirtualinherited

Definition at line 102 of file JetCaloCalculations.h.

102{return m_name;}

jet::JetCaloCalculator::m_name

std::string m_name

Definition JetCaloCalculations.h:113

◆ operator()()

double jet::JetCaloCalculator::operator()	(	const xAOD::Jet *	jet,
		xAOD::JetConstitScale	s = xAOD::UncalibratedJetConstituent )

virtualinherited

convenience function to perform the full calculation on a given jet

Reimplemented in jet::JetCaloCellCalculator.

Definition at line 222 of file JetCaloCalculations.cxx.

                                                                                          {
 
    if (! setupJet( jet ) ) return 0;
    size_t nConstit = jet->numConstituents();
    if( nConstit == 0) return true;
 
    // retrieve the cluster moment extractor for this jet.
    m_constitExtractor = CaloConstitHelpers::extractorForJet(jet);
      
    
    xAOD::JetConstituentVector constits = jet->getConstituents();
    // Use the constituent iterator
    // IMPORTANT : use UncalibratedJetConstituent.
    // By default the calculators will just use the kinematic from the iterator they are
    // given. This allows to choose what scale we give them.
    // Here we use UncalibratedJetConstituent as default, because most (or all) calo quantity to be calculated
    // are based on EM scale cluster moments.
    xAOD::JetConstituentVector::iterator it  = constits.begin(constitscale );
    xAOD::JetConstituentVector::iterator itE = constits.end(constitscale);
    
    for(; it != itE; ++it)
      {         
        if( m_constitExtractor->valid(it) )
          processConstituent(it); // (no support for weight now)          
      }
    
    return jetCalculation();
  
  }

◆ processConstituent()

virtual bool jet::JetCaloCalculator::processConstituent ( xAOD::JetConstituentVector::iterator & )

inlinevirtualinherited

Perform 1 calculation step using 1 constituent.

Implementation of these functions should use the kinematics from the iterator NOT from the underlying cluster
It is expected that the input is valid, i.e. : CaloConstitExtractor::valid(it) == true.

Reimplemented in jet::JetCalcQualityHEC.

Definition at line 93 of file JetCaloCalculations.h.

93{return true;};