jet::JetIsolation::IsolationCalculatorT< ISOCRITERIA > Class Template Reference

Inheritance diagram for jet::JetIsolation::IsolationCalculatorT< ISOCRITERIA >:

Collaboration diagram for jet::JetIsolation::IsolationCalculatorT< ISOCRITERIA >:

Public Types
enum	Kinematics {   Pt , PtPUsub , SumPt , Par ,   Perp , P }
	Define the available isolation variables. More...

Public Member Functions
	IsolationCalculatorT (double param=0.)
virtual IsolationResult	jetIsolation (const xAOD::Jet *jet, std::vector< const xAOD::IParticle * > &nearbyConstit) const
	Compute the isolation 4-momentum from jet and jet inputs.
virtual string	baseName () const
virtual IsolationCalculator *	clone (const xAOD::Jet *j) const
virtual void	copyFrom (const IsolationCalculator *o, const xAOD::Jet *)
bool	scheduleKinematicCalculation (const std::string &kname)
virtual std::vector< float >	calcIsolationVariables (const xAOD::Jet *jet, std::vector< const xAOD::IParticle * > &nearbyConstit) const
	Implement the calculation of isolation variables for this jet.
virtual std::vector< std::string >	calculationNames () const
void	dump () const
void	setEventDensity (float rho)

Public Attributes
ISOCRITERIA	m_iso

Static Public Attributes
static constexpr std::array< std::string_view, 6 >	s_kname = {"Pt","PtPUsub" , "SumPt", "Par", "Perp", "P"}
	names for isolation variables. Must match EXACTLY the enum.

Protected Attributes
std::vector< Kinematics >	m_kinematics
	kinematics isolation variables to be computed
float	m_rho =-9999.
	Value of the event density in case it is needed.

Detailed Description

template<typename ISOCRITERIA>
class jet::JetIsolation::IsolationCalculatorT< ISOCRITERIA >

Definition at line 140 of file JetIsolationTool.cxx.

Member Enumeration Documentation

Kinematics

enum jet::JetIsolation::IsolationCalculator::Kinematics

inherited

Define the available isolation variables.

Enumerator
Pt
PtPUsub
SumPt
Par
Perp
P

Definition at line 37 of file JetIsolationTool.cxx.

                      {
        Pt, PtPUsub, SumPt, Par, Perp, P
      };

Constructor & Destructor Documentation

IsolationCalculatorT()

template<typename ISOCRITERIA>

jet::JetIsolation::IsolationCalculatorT< ISOCRITERIA >::IsolationCalculatorT ( double param = 0. )

inline

Definition at line 143 of file JetIsolationTool.cxx.

: m_iso(param) { }

Member Function Documentation

baseName()

template<typename ISOCRITERIA>

virtual string jet::JetIsolation::IsolationCalculatorT< ISOCRITERIA >::baseName ( ) const

inlinevirtual

Reimplemented from jet::JetIsolation::IsolationCalculator.

Definition at line 160 of file JetIsolationTool.cxx.

{return m_iso.name();}

calcIsolationVariables()

virtual std::vector< float > jet::JetIsolation::IsolationCalculator::calcIsolationVariables ( const xAOD::Jet * jet, std::vector< const xAOD::IParticle * > & nearbyConstit ) const

inlinevirtualinherited

Implement the calculation of isolation variables for this jet.

The vector<IParticle*> nearbyConstit is expected to contain all the constituents which can fall in the isolation area AND which are not constituent of the jet.

Definition at line 80 of file JetIsolationTool.cxx.

                                                                                                       {
        IsolationResult result = jetIsolation(jet, nearbyConstit);
    std::vector<float> calcVector;
    float pt = jet->jetP4(xAOD::JetConstitScaleMomentum).pt();
    static const SG::AuxElement::Accessor<float> areaAcc("ActiveArea");
    float jetArea=0;
    for(auto k : m_kinematics){
      float v=-1;
          switch( k ) {
          case Pt:
        v = result.isoP.Pt() / pt; break ;
      case PtPUsub:
        jetArea= areaAcc(*jet);     
        v = (result.isoP.Pt() - (result.isoArea-jetArea)*m_rho)/ (pt-jetArea*m_rho);
        break;
          case Perp:
            v = result.isoP.Vect().Dot(unitVector(jet->p4())) /pt; break;
          case SumPt:
            v = result.isoSumPt; break;
          case Par:
            v = result.isoP.Vect().Perp(unitVector(jet->p4())) /pt ; break;
          case P:
        v = result.isoP.Vect().Mag()/pt; break ;
      }
      calcVector.push_back(v);
        }
        return calcVector;
      }

calculationNames()

virtual std::vector< std::string > jet::JetIsolation::IsolationCalculator::calculationNames ( ) const

inlinevirtualinherited

Definition at line 110 of file JetIsolationTool.cxx.

                                                    {
    std::vector<std::string> v;
    v.reserve(m_kinematics.size());
    for(auto k : m_kinematics) {
      v.emplace_back(baseName() + string(s_kname[k]));
    }
    return v;  
      }

clone()

template<typename ISOCRITERIA>

virtual IsolationCalculator * jet::JetIsolation::IsolationCalculatorT< ISOCRITERIA >::clone ( const xAOD::Jet * j ) const

inlinevirtual

Reimplemented from jet::JetIsolation::IsolationCalculator.

Definition at line 162 of file JetIsolationTool.cxx.

                                                                  {
        IsolationCalculatorT* isoT= new IsolationCalculatorT();
        isoT->m_iso = m_iso;
        isoT->m_iso.setup(j);
        isoT->copyFrom(this,j);
        return isoT;
      }

copyFrom()

virtual void jet::JetIsolation::IsolationCalculator::copyFrom ( const IsolationCalculator * o, const xAOD::Jet *  )

inlinevirtualinherited

Definition at line 56 of file JetIsolationTool.cxx.

                                                                          {
        m_kinematics = o->m_kinematics;
      }

dump()

void jet::JetIsolation::IsolationCalculator::dump ( ) const

inlineinherited

Definition at line 120 of file JetIsolationTool.cxx.

                        {
        std::cout << "Isolation calculator "<< baseName() <<std::endl;
    for(const auto& n : calculationNames()){
      std::cout << "   - "<< n << std::endl; 
    }
      }

jetIsolation()

template<typename ISOCRITERIA>

virtual IsolationResult jet::JetIsolation::IsolationCalculatorT< ISOCRITERIA >::jetIsolation ( const xAOD::Jet * , std::vector< const xAOD::IParticle * > &  ) const

inlinevirtual

Compute the isolation 4-momentum from jet and jet inputs.

It is assumed the caller has already removed jet constituents from the input list.

Reimplemented from jet::JetIsolation::IsolationCalculator.

Definition at line 146 of file JetIsolationTool.cxx.

                                                                                             {
        IsolationResult result;
    double rap = jet->rapidity();
    double phi = jet->phi();
    for(const xAOD::IParticle* constit:nearbyConstit){
      if ( m_iso.inIsolationArea(rap, phi, constit) ) {
        result.isoP     += constit->p4();
            result.isoSumPt += constit->pt();
          }    
        }
    result.isoArea = m_iso.isoArea();
        return result;
      }

scheduleKinematicCalculation()

bool jet::JetIsolation::IsolationCalculator::scheduleKinematicCalculation ( const std::string & kname )

inlineinherited

Definition at line 67 of file JetIsolationTool.cxx.

                                                               {
    auto it = std::ranges::find(s_kname, kname);
    if( it != s_kname.end( )){
      m_kinematics.push_back(static_cast<Kinematics>(it-s_kname.begin()) );
      return true;
    }
        return false;
      }

setEventDensity()

void jet::JetIsolation::IsolationCalculator::setEventDensity ( float rho )

inlineinherited

Definition at line 127 of file JetIsolationTool.cxx.

                                     {
    m_rho=rho;
      }

Member Data Documentation

m_iso

template<typename ISOCRITERIA>

ISOCRITERIA jet::JetIsolation::IsolationCalculatorT< ISOCRITERIA >::m_iso

Definition at line 170 of file JetIsolationTool.cxx.

m_kinematics

std::vector<Kinematics> jet::JetIsolation::IsolationCalculator::m_kinematics

protectedinherited

kinematics isolation variables to be computed

Definition at line 133 of file JetIsolationTool.cxx.

m_rho

float jet::JetIsolation::IsolationCalculator::m_rho =-9999.

protectedinherited

Value of the event density in case it is needed.

Definition at line 135 of file JetIsolationTool.cxx.

s_kname

std::array<std::string_view, 6> jet::JetIsolation::IsolationCalculator::s_kname = {"Pt","PtPUsub" , "SumPt", "Par", "Perp", "P"}

staticconstexprinherited

names for isolation variables. Must match EXACTLY the enum.

Definition at line 42 of file JetIsolationTool.cxx.

{"Pt","PtPUsub" , "SumPt", "Par", "Perp", "P"};      

---

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

• JetIsolationTool.cxx