jet::JetIsolation::IsolationCalculator Class Reference

IsolationCalculator : base class for isolation calculations Implementations of this class encapsulate all the needed calculations inside the calcIsolationVariables(jet, constituents) function, where 'constituents' is expected to be a vector a consituent NOT containing the jet's constitents. More...

Inheritance diagram for jet::JetIsolation::IsolationCalculator:

Collaboration diagram for jet::JetIsolation::IsolationCalculator:

Classes
struct	IsolationResult
	Holds the 4-vector of all constituents contributing to isolation. More...

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

Public Member Functions
virtual	~IsolationCalculator ()=default
virtual string	baseName () const
virtual IsolationCalculator *	clone (const xAOD::Jet *) const
virtual void	copyFrom (const IsolationCalculator *o, const xAOD::Jet *)
virtual IsolationResult	jetIsolation (const xAOD::Jet *, std::vector< const xAOD::IParticle * > &) const
	Compute the isolation 4-momentum from jet and jet inputs.
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)

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

IsolationCalculator : base class for isolation calculations Implementations of this class encapsulate all the needed calculations inside the calcIsolationVariables(jet, constituents) function, where 'constituents' is expected to be a vector a consituent NOT containing the jet's constitents.

Definition at line 33 of file JetIsolationTool.cxx.

Member Enumeration Documentation

Kinematics

enum jet::JetIsolation::IsolationCalculator::Kinematics

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

~IsolationCalculator()

virtual jet::JetIsolation::IsolationCalculator::~IsolationCalculator ( )

virtualdefault

Member Function Documentation

baseName()

virtual string jet::JetIsolation::IsolationCalculator::baseName ( ) const

inlinevirtual

Reimplemented in jet::JetIsolation::IsolationCalculatorT< ISOCRITERIA >.

Definition at line 54 of file JetIsolationTool.cxx.

{return "";}

calcIsolationVariables()

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

inlinevirtual

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

inlinevirtual

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

virtual IsolationCalculator * jet::JetIsolation::IsolationCalculator::clone ( const xAOD::Jet * ) const

inlinevirtual

Reimplemented in jet::JetIsolation::IsolationCalculatorT< ISOCRITERIA >.

Definition at line 55 of file JetIsolationTool.cxx.

{return nullptr;}

copyFrom()

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

inlinevirtual

Definition at line 56 of file JetIsolationTool.cxx.

                                                                          {
        m_kinematics = o->m_kinematics;
      }

dump()

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

inline

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

virtual IsolationResult jet::JetIsolation::IsolationCalculator::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 in jet::JetIsolation::IsolationCalculatorT< ISOCRITERIA >.

Definition at line 63 of file JetIsolationTool.cxx.

                                                                                                     {
        return {};
      }

scheduleKinematicCalculation()

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

inline

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 )

inline

Definition at line 127 of file JetIsolationTool.cxx.

                                     {
    m_rho=rho;
      }

Member Data Documentation

m_kinematics

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

protected

kinematics isolation variables to be computed

Definition at line 133 of file JetIsolationTool.cxx.

m_rho

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

protected

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"}

staticconstexpr

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