jet::JetCaloCalculations Class Reference

Holds a list of JetCalculators. More...

#include <JetCaloCalculations.h>

Inheritance diagram for jet::JetCaloCalculations:

Collaboration diagram for jet::JetCaloCalculations:

Public Member Functions
	JetCaloCalculations (bool ownCalc=true)
virtual	~JetCaloCalculations ()
void	addCalculator (JetCaloCalculator *c)
bool	setupEvent ()
virtual std::vector< double >	process (const xAOD::Jet *jet) const
	Perform all tasks correspondings to the associated JetCaloCalculators on Jet jet.
void	clear ()
size_t	numCalculators () const
const JetCaloCalculator *	at (size_t i) const

Protected Attributes
std::vector< JetCaloCalculator * >	m_calculators
bool	m_owncalculators

Detailed Description

Holds a list of JetCalculators.

For a given jet, performs a single, optimized loop over constituents and calls the processConstituent function of all its calculators.

When processing constituents, it passes JetConstituentVector::iterator at the UncalibratedJetConstituent scale : this is a choice (most quantities are build from cluster moments calculated at EM scale).

See also JetCaloCellCalculations in JetCaloCellQualityUtils.h for a similar object using calculators acting on CaloCell directly

Definition at line 145 of file JetCaloCalculations.h.

Constructor & Destructor Documentation

JetCaloCalculations()

jet::JetCaloCalculations::JetCaloCalculations ( bool ownCalc = true )

inline

Definition at line 148 of file JetCaloCalculations.h.

: m_owncalculators(ownCalc) {}

~JetCaloCalculations()

virtual jet::JetCaloCalculations::~JetCaloCalculations ( )

inlinevirtual

Definition at line 150 of file JetCaloCalculations.h.

{clear();}

Member Function Documentation

addCalculator()

void jet::JetCaloCalculations::addCalculator

(

JetCaloCalculator *

c

)

Definition at line 258 of file JetCaloCalculations.cxx.

                                                             { 
    m_calculators.push_back(c); 
  }

at()

const JetCaloCalculator * jet::JetCaloCalculations::at ( size_t i ) const

inline

Definition at line 162 of file JetCaloCalculations.h.

{return m_calculators[i];}

clear()

void jet::JetCaloCalculations::clear

(

)

Definition at line 332 of file JetCaloCalculations.cxx.

                                 {
    if(m_owncalculators) for(size_t i=0;i < m_calculators.size();i++) delete m_calculators[i];
    m_calculators.clear();
  }

numCalculators()

size_t jet::JetCaloCalculations::numCalculators ( ) const

inline

Definition at line 161 of file JetCaloCalculations.h.

{return m_calculators.size();}

process()

std::vector< double > jet::JetCaloCalculations::process ( const xAOD::Jet * jet ) const

virtual

Perform all tasks correspondings to the associated JetCaloCalculators on Jet jet.

Reimplemented in jet::JetCaloCellCalculations.

Definition at line 270 of file JetCaloCalculations.cxx.

                                                                         {
    size_t nConstit = jet->numConstituents();
    std::vector<double> results;
    results.reserve(m_calculators.size());
 
    if( nConstit == 0) {
      results.resize(m_calculators.size(),0);
      return results;
    }
 
    // Clone calculators : we are in a const method, we can't call the 
    // non const setupJet() and  processConstituent() methods of our calculators.
    std::vector<JetCaloCalculator*> clonedCalc;
    clonedCalc.reserve(m_calculators.size());
    for( const JetCaloCalculator *calc : m_calculators) clonedCalc.push_back( calc->clone() );  
 
    // prepare each calculator
    for(JetCaloCalculator* calc: clonedCalc) {
      calc->setupJet(jet);
    }
   
    // retrieve the cluster moment extractor for this jet.
    const CaloConstitHelpers::CaloConstitExtractor * extractor = CaloConstitHelpers::extractorForJet(jet);
    // assign the extractor to the calculators :
    for( JetCaloCalculator* calc : clonedCalc) calc->setExtractor(extractor);
 
    xAOD::JetConstituentVector constits = jet->getConstituents();
    // Use the constituent iterator at UNCALIBRATED scale 
    xAOD::JetConstituentVector::iterator it  = constits.begin(xAOD::UncalibratedJetConstituent );
    xAOD::JetConstituentVector::iterator itE = constits.end(xAOD::UncalibratedJetConstituent);
                  
    // loop over constituents
    for(; it != itE; ++it)
      {
        //std::cout << " processing constit  ---- "<< (*it)->pt() << " v= "<< extractor->valid(it) << std::endl;
        
        if( ! extractor->valid(it) ) continue; // this can happen for charged pflow objects
        // loop over calculators for this constituent.
        for(JetCaloCalculator* calc : clonedCalc) {
          calc->processConstituent(it);
        }
      } // constituents loop
  
    // copy results & clear the cloned calc
    for(JetCaloCalculator* calc: clonedCalc) {
      results.push_back( calc->jetCalculation() );
      delete calc;
    }
    
    return results;
  }

setupEvent()

bool jet::JetCaloCalculations::setupEvent

(

)

Definition at line 263 of file JetCaloCalculations.cxx.

                                      {
    for(size_t i=0;i < m_calculators.size();i++) m_calculators[i]->setupEvent();
    return true;
  }

Member Data Documentation

m_calculators

std::vector<JetCaloCalculator*> jet::JetCaloCalculations::m_calculators

protected

Definition at line 167 of file JetCaloCalculations.h.

m_owncalculators

bool jet::JetCaloCalculations::m_owncalculators

protected

Definition at line 168 of file JetCaloCalculations.h.

---

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

• JetCaloCalculations.h
• JetCaloCalculations.cxx