JetIsolationTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
// JetIsolationTool.h 
//
// Author: P-A. Delsart
//
// Modified Feb 2015 by D. Adams.
//    It now obtains its inputs from a pseudojet getter instead of a specified
// container of ATLAS objects.
 
#ifndef JetIsolationTool_H
#define JetIsolationTool_H
 
 
#include "AsgTools/AsgTool.h"
#include "JetUtils/TiledEtaPhiMap.h"
#include "JetInterface/IJetDecorator.h"
#include "fastjet/PseudoJet.hh"
#include "JetRec/PseudoJetContainer.h"
#include "JetEDM/IConstituentUserInfo.h"
#include "StoreGate/ReadDecorHandleKey.h"
#include "StoreGate/ReadDecorHandle.h"
#include "StoreGate/WriteDecorHandleKey.h"
#include "StoreGate/WriteDecorHandleKeyArray.h"
#include "StoreGate/WriteDecorHandle.h"
#include "xAODJet/JetContainer.h"
 
namespace jet {
 
namespace JetIsolation {
  class IsolationCalculator;
}
 
struct ParticlePosition {
  ParticlePosition(const fastjet::PseudoJet* p)
  : m_eta(p->eta()), m_phi(p->phi()), m_part(p) { };
  ParticlePosition(const xAOD::IParticle* p)
  : m_eta(p->eta()), m_phi(p->phi()), m_part(nullptr) { };
  ParticlePosition(double x=0, double y=0)
  : m_eta(x), m_phi(y), m_part(nullptr) { }
  double x() const {return m_eta;}
  double y() const {return m_phi;}
  double px() const { return m_part->px(); }
  double py() const { return m_part->py(); }
  double pz() const { return m_part->pz(); }
  double e() const { return m_part->e(); }
  double pt() const { return m_part->perp(); }
  void setX(double x){m_eta=x;}
  void setY(double x){m_phi=x;}
 
  const fastjet::PseudoJet* particle() const {return m_part;}
 
  struct DR2 {
    double operator()(const ParticlePosition &p1,const ParticlePosition &p2) const {
      return JetTiledMap::utils::DR2(p1.x(),p1.y(), p2.x(), p2.y() );
    }
  };
 
protected:
  double m_eta,m_phi;
  const fastjet::PseudoJet* m_part ;
};
 
}  // end namespace jet
 
//**********************************************************************
 
class JetIsolationTool : public asg::AsgTool,
                         virtual public IJetDecorator { 
  ASG_TOOL_CLASS0(JetIsolationTool)
 
public: 
 
  friend class jet::JetIsolation::IsolationCalculator;
 
  JetIsolationTool(const std::string &myname);
 
  virtual ~JetIsolationTool(); 
 
  // Athena algtool Hooks
  virtual StatusCode  initialize() override;
  virtual StatusCode  finalize() override;
 
  // Jet Modifier methods.
  virtual StatusCode decorate(const xAOD::JetContainer& jets) const override;
 
private: 
  Gaudi::Property<std::vector<std::string>> m_isolationCodes{this, "IsolationCalculations", {}, "Isolation calculation data vector"};
  Gaudi::Property<std::string> m_jetContainerName{this, "JetContainer", "", "SG key for the input jet container"};
 
  SG::ReadHandleKey<PseudoJetContainer> m_pjsin{this, "PseudoJetsIn", "", "PseudoJetContainer to read"};
  SG::ReadDecorHandleKey<xAOD::JetContainer> m_inputTypeKey{this, "InputTypeName", "InputType", "Key for the InputType field of a jet"};
  SG::WriteDecorHandleKeyArray<xAOD::JetContainer> m_perpKeys{this, "PerpName", {}, "SG key for output perpendicular momentum component decoration (not to be configured manually!)"};
  SG::WriteDecorHandleKeyArray<xAOD::JetContainer> m_sumPtKeys{this, "SumPtName", {}, "SG key for output SumPt decoration (not to be configured manually!)"};
  SG::WriteDecorHandleKeyArray<xAOD::JetContainer> m_parKeys{this, "ParName", {}, "SG key for output parallel momentum component decoration (not to be configured manually!)"};
  SG::WriteDecorHandleKeyArray<xAOD::JetContainer> m_pKeys{this, "PName", {}, "SG key for output momentum decoration (not to be configured manually!)"};
 
  // and adapted to the jet object, see implementation)
  std::vector<jet::JetIsolation::IsolationCalculator*> m_isoCalculators;
 
}; 
 
#endif