JetBalancePFlowJvtTool Class Reference

#include <JetBalancePFlowJvtTool.h>

Inheritance diagram for JetBalancePFlowJvtTool:

Collaboration diagram for JetBalancePFlowJvtTool:

Public Member Functions
	JetBalancePFlowJvtTool (const std::string &name)
	Constructor with parameters:
virtual	~JetBalancePFlowJvtTool ()
	Destructor:
virtual StatusCode	initialize () override
	Dummy implementation of the initialisation function.
virtual StatusCode	decorate (const xAOD::JetContainer &jetCont) const override
	Decorate a jet collection without otherwise modifying it.
bool	isQCDPUJet (const xAOD::Jet *jet) const
virtual std::vector< TVector2 >	calculateVertexMomenta (const xAOD::JetContainer *jets, int pvind, int vertices) const override
StatusCode	tagTruth (const xAOD::JetContainer *jets, const xAOD::JetContainer *truthJets, const xAOD::JetContainer *itpujets, const xAOD::JetContainer *ootpujets)
float	getFJVT (const xAOD::Jet *jet, const std::vector< TVector2 > &pileupMomenta) const
bool	isForwardJet (const xAOD::Jet *jet) const
bool	isCentralJet (const xAOD::Jet *jet) const
StatusCode	tagTruth (const xAOD::JetContainer *jets, const xAOD::JetContainer *truthJets)
pflow::puJets	buildPFlowPUjets (const xAOD::Vertex &vx) const
bool	hasCloseByHSjet (const xAOD::Jet *jet, const xAOD::JetContainer *pjets) const
double	getRpt (const xAOD::Jet *jet) const
fastjet::PseudoJet	pfoToPseudoJet (const xAOD::PFO *pfo, const CP::PFO_JetMETConfig_charge &theCharge, const xAOD::Vertex *vx) const
fastjet::PseudoJet	feToPseudoJet (const xAOD::FlowElement *fe, const CP::PFO_JetMETConfig_charge &theCharge, const xAOD::Vertex *vx) const
std::size_t	getPV () const
virtual void	print () const
	Print the state of the tool.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
virtual StatusCode	modify (xAOD::JetContainer &jets) const override final
	Concrete implementation of the function inherited from IJetModifier.
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Protected Attributes
Gaudi::Property< float >	m_QCDPUMinPt {this, "QCDPUMinPt", 20e3, "Minimum pt cut value for central PU jets contributing in the missing momentum calculation"}
Gaudi::Property< float >	m_QCDPUMaxPt {this, "QCDPUMaxPt", -1, "Maximum pt cut value for central PU jets contributing in the missing momentum calculation. If -1 no threshold is applied"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_bjvtKey {this, "BjvtName", "passOnlyBJVT", "Decorator for passing bJVT threshold (tight or loose)"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_bjvtRawKey {this, "BjvtRawName", "bJvt", "Decorator for raw bJVT variable"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_isQCDPUKey {this, "isQCDPUName", "isJvtQCDPU", "SG key for output isJVTQCDPU decoration"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_isStochPUKey {this, "isStochPUName", "isJvtStochPU", "SG key for output isJVTStochPU decoration"}
float	m_bjvtThresh
SG::ReadHandleKey< jet::TrackVertexAssociation >	m_tvaKey {this, "TrackVertexAssociation", "", "Input track-vertex association"}
Gaudi::Property< std::string >	m_jetContainerName {this, "JetContainer", "", "SG key for the input jet container"}
Gaudi::Property< std::string >	m_jetsName {this, "jetsName", "AntiKt4PUPFlowJets", "Container name for the output reconstructed PU jets"}
Gaudi::Property< std::string >	m_jetchargedp4 {this, "jetchargedp4", "JetChargedScaleMomentum", "Name of the jet charged momentum 4-vector"}
Gaudi::Property< bool >	m_isdata {this, "isdata", false, "True if data"}
Gaudi::Property< int >	m_pvind {this, "pvind", -1, "Hard-Scatter primary vertex index of the event. If -1 it will be automatically retrieved from the event"}
Gaudi::Property< int >	m_vertices {this, "vertices", 10, "Number of vertices for which the missing momentum is calculated"}
Gaudi::Property< bool >	m_includePV {this, "includePV", false, "Flag to include jets and tracks associated to PV in the calculation"}
Gaudi::Property< double >	m_etaThresh {this, "etaThresh", 2.5, "Maximum eta value for considering a jet as central"}
Gaudi::Property< double >	m_forwardMinPt {this, "forwardMinPt", 18e3, "Minimum forward jet pt"}
Gaudi::Property< double >	m_forwardMaxPt {this, "forwardMaxPt", -1, "Maximum forward jet pt. If -1 no threshold is applied"}
Gaudi::Property< double >	m_centerMinPt {this, "centralMinPt", 20e3, "Minimum central jet pt"}
Gaudi::Property< double >	m_centerMaxPt {this, "centralMaxPt", -1, "Maximum central jet pt. If -1 no threshold is applied"}
Gaudi::Property< double >	m_fjvtThresh {this, "fjvtThresh", 15e3, "fjvt threshold value"}
Gaudi::Property< double >	m_rptCut {this, "rptCut", 0.1, "Rpt cut value for central PU jets contributing in the missing momentum calculation"}
Gaudi::Property< double >	m_jvtCut {this, "jvtCut", 0.2, "JVT threshold value for considering a central PU jet as HS"}
Gaudi::Property< double >	m_dzCut {this, "dzCut", 2.0, "Dz=z=-z0 cut for pfo objects participating in the HS vertex jet reco"}
Gaudi::Property< double >	m_maxRap {this, "maxRap", 2.5, "Maximum rapidity value in fastjet::AreaDefinition"}
Gaudi::Property< double >	m_neutMaxRap {this, "neutMaxRap", 2.5, "Maximum rapidity value for neutral pfos participating in jet reco"}
Gaudi::Property< float >	m_weight {this, "weight", 0, "PFO weight value"}
Gaudi::Property< bool >	m_tightOP {this, "tightOP", false, "If true a tight fjvt threshold value is applied"}
SG::ReadHandleKey< xAOD::VertexContainer >	m_vxContKey {this, "verticesName", "PrimaryVertices", "Container name of vertices to be retrieved"}
SG::ReadHandleKey< xAOD::PFOContainer >	m_PFOKey {this, "PFOName", "CHSParticleFlowObjects", "SG Key for CHS PFO Container"}
SG::ReadHandleKey< xAOD::FlowElementContainer >	m_FEKey {this, "FEName", "", "SG Key for CHS FlowElement Container (overrides PFO if not empty)"}
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey {"EventInfo"}
SG::ReadDecorHandleKey< xAOD::JetContainer >	m_passJvtKey {this, "passJvtName", "NNJvtPass", "SG key for output pass-JVT decoration"}
SG::ReadDecorHandleKey< xAOD::PFO >	m_orKey {this, "ORName", "", "OR label"}
SG::ReadDecorHandleKey< xAOD::FlowElement >	m_orFEKey {this, "ORNameFE", "", "OR label"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_fjvtKey {this, "FjvtName", "passOnlyFJVT", "Decorator for passing fJVT threshold (tight or loose)"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_fjvtRawKey {this, "FjvtRawName", "fJvt", "Decorator for raw fJVT variable"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_isHSKey {this, "isHSName", "isJVTHS", "SG key for output isJVTHS decoration"}
SG::WriteDecorHandleKey< xAOD::JetContainer >	m_isPUKey {this, "isPUName", "isJvtPU", "SG key for output isJVTPU decoration"}
ToolHandle< CP::WeightPFOTool >	m_wpfotool {this,"WeightPFOTool", "", "Weight PFO tool name"}
ToolHandle< IJetCalibrationTool >	m_pfoJES {this,"JetCalibrationTool", "", "Jet calibration tool name"}
Gaudi::Property< bool >	m_suppressInputDependence {this, "SuppressInputDependence", false}

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 94 of file JetBalancePFlowJvtTool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

JetBalancePFlowJvtTool()

JetBalancePFlowJvtTool::JetBalancePFlowJvtTool

(

const std::string &

name

)

Constructor with parameters:

Definition at line 33 of file JetBalancePFlowJvtTool.cxx.

                                                                      : 
  JetForwardPFlowJvtTool(name){
    m_bjvtThresh = 0;
  }

~JetBalancePFlowJvtTool()

JetBalancePFlowJvtTool::~JetBalancePFlowJvtTool ( )

virtualdefault

Destructor:

Member Function Documentation

buildPFlowPUjets()

pflow::puJets JetForwardPFlowJvtTool::buildPFlowPUjets ( const xAOD::Vertex & vx ) const

inherited

Definition at line 192 of file JetForwardPFlowJvtTool.cxx.

                                                                                 {
    pflow::puJets pu_jets;
    const std::size_t pv_index = (m_pvind==-1) ? getPV() : std::size_t (m_pvind);
 
    std::vector<fastjet::PseudoJet> input_pfo;
    std::set<int> charged_pfo;
 
    SG::ReadHandle<jet::TrackVertexAssociation> tvaHandle(m_tvaKey);
        
    if (!tvaHandle.isValid()){
      ATH_MSG_ERROR("Could not retrieve the TrackVertexAssociation: "
                    << m_tvaKey.key());
      return pu_jets;
    }
 
    if(!m_FEKey.empty()){
      SG::ReadHandle<xAOD::FlowElementContainer> FlowElementHandle(m_FEKey);
 
      for(const xAOD::FlowElement* fe : *FlowElementHandle){
        if (!m_orFEKey.key().empty()){
          SG::ReadDecorHandle<xAOD::FlowElement, char> orHandle(m_orFEKey);
          if (!orHandle(*fe)) continue;
        }
        if (fe->isCharged()) {
          const xAOD::TrackParticle* track = dynamic_cast<const xAOD::TrackParticle*>(fe->chargedObject(0));
 
          if (vx.index()==pv_index && std::abs((vx.z()-track->z0())*sin(track->theta()))>m_dzCut)
            continue;
          if (vx.index()!=pv_index
              && (!tvaHandle->associatedVertex(track)
                  || vx.index()!=tvaHandle->associatedVertex(track)->index())
              ) continue;
          input_pfo.push_back(feToPseudoJet(fe, CP::charged, &vx) );
          charged_pfo.insert(fe->index());
        }
        else if (std::abs(fe->eta())<m_neutMaxRap && !fe->isCharged() && fe->e()>0)
          {
            input_pfo.push_back(feToPseudoJet(fe, CP::neutral, &vx) );
          }
      }
    }
    else{
      SG::ReadHandle<xAOD::PFOContainer> PFOHandle(m_PFOKey);
 
      for(const xAOD::PFO* pfo : *PFOHandle){
        if (!m_orKey.key().empty()){
          SG::ReadDecorHandle<xAOD::PFO, char> orHandle(m_orKey);
          if (!orHandle(*pfo)) continue;
        }
        if (pfo->isCharged()) {
          if (vx.index()==pv_index && std::abs((vx.z()-pfo->track(0)->z0())*sin(pfo->track(0)->theta()))>m_dzCut)
            continue;
          if (vx.index()!=pv_index
              && (!tvaHandle->associatedVertex(pfo->track(0))
                  || vx.index()!=tvaHandle->associatedVertex(pfo->track(0))->index())
              ) continue;
          input_pfo.push_back(pfoToPseudoJet(pfo, CP::charged, &vx) );
          charged_pfo.insert(pfo->index());
        }
        else if (std::abs(pfo->eta())<m_neutMaxRap && !pfo->isCharged() && pfo->eEM()>0)
        {
          input_pfo.push_back(pfoToPseudoJet(pfo, CP::neutral, &vx) );
        }
      }
    }
 
    std::shared_ptr<xAOD::JetContainer> vertjets = std::make_shared<xAOD::JetContainer>();
    std::shared_ptr<xAOD::JetAuxContainer> vertjetsAux = std::make_shared<xAOD::JetAuxContainer>();
 
    vertjets->setStore(vertjetsAux.get());
    TString newname = m_jetsName.value();
    newname += vx.index();
 
    // Use run/event number as random number seeds.
    std::vector<int> seeds;
    auto evtInfoHandle = SG::makeHandle(m_eventInfoKey);
    if (!evtInfoHandle.isValid())
    {
      ATH_MSG_ERROR("Unable to retrieve event info");
      return pu_jets;
    }
    JetClustererHelper::seedsFromEventInfo(evtInfoHandle.cptr(), seeds);
 
    fastjet::JetDefinition jet_def(fastjet::antikt_algorithm,0.4);
    fastjet::AreaDefinition area_def(fastjet::active_area_explicit_ghosts,
                                     fastjet::GhostedAreaSpec(fastjet::SelectorAbsRapMax(m_maxRap)));
    area_def = area_def.with_fixed_seed(seeds);
    fastjet::ClusterSequenceArea clust_pfo(input_pfo,jet_def,area_def);
    std::vector<fastjet::PseudoJet> inclusive_jets = sorted_by_pt(clust_pfo.inclusive_jets(5000.));
 
    for (size_t i = 0; i < inclusive_jets.size(); i++) {
      xAOD::Jet* jet=  new xAOD::Jet();
      xAOD::JetFourMom_t tempjetp4(inclusive_jets[i].pt(),
                                   inclusive_jets[i].eta(),
                                   inclusive_jets[i].phi(),
                                   inclusive_jets[i].m());
      xAOD::JetFourMom_t newArea(inclusive_jets[i].area_4vector().perp(),
                                 inclusive_jets[i].area_4vector().eta(),
                                 inclusive_jets[i].area_4vector().phi(),
                                 inclusive_jets[i].area_4vector().m());
      vertjets->push_back(jet);
      jet->setJetP4(tempjetp4);
      jet->setJetP4("JetConstitScaleMomentum",tempjetp4);
      jet->setJetP4("JetPileupScaleMomentum",tempjetp4);
      jet->setAttribute("ActiveArea4vec",newArea);
      jet->setAttribute("DetectorEta",jet->eta());
      std::vector<fastjet::PseudoJet> constituents = inclusive_jets[i].constituents();
      float chargedpart = 0;
      for (size_t j = 0; j < constituents.size(); j++) {
        if (charged_pfo.count(constituents[j].user_index())>=1) {
          chargedpart += constituents[j].perp(); 
        }
      }
      xAOD::JetFourMom_t chargejetp4(chargedpart,inclusive_jets[i].eta(),inclusive_jets[i].phi(),inclusive_jets[i].m());
      jet->setJetP4(m_jetchargedp4,chargejetp4);
    }
 
    if((m_pfoJES->modify(*vertjets)).isFailure()){
      ATH_MSG_ERROR(" Failed to calibrate PU jet container ");
      return pu_jets;
    }
 
    pu_jets.jetCont = vertjets;
    pu_jets.jetAuxCont = vertjetsAux;
    return pu_jets;
  }

calculateVertexMomenta()

std::vector< TVector2 > JetBalancePFlowJvtTool::calculateVertexMomenta ( const xAOD::JetContainer * jets, int pvind, int vertices ) const

overridevirtual

Reimplemented from JetForwardPFlowJvtTool.

Definition at line 98 of file JetBalancePFlowJvtTool.cxx.

                                                                                                      {
    std::vector<TVector2> pileupMomenta;
    // -- Retrieve PV index if not provided by user
    const std::size_t pv_index = (pvind==-1) ? getPV() : std::size_t(pvind);
 
    SG::ReadHandle<xAOD::VertexContainer> vxContHandle(m_vxContKey);
 
    for(const xAOD::Vertex* vx: *vxContHandle) {
      if(vx->vertexType()!=xAOD::VxType::PriVtx && vx->vertexType()!=xAOD::VxType::PileUp) continue;
      if(vx->index()==(size_t)pv_index) continue;
 
      TString jname = m_jetsName.value();
      jname += vx->index();
 
      pflow::puJets vertjets = buildPFlowPUjets(*vx);
      if( !vertjets.jetCont || !vertjets.jetAuxCont ){
        ATH_MSG_WARNING(" Some issue appeared while building the pflow pileup jets for vertex "
                        << vx->index() << " (vxType = " << vx->vertexType()<<" )!" );
        return pileupMomenta;
      }
      
      TVector2 vertex_met;
      for( const xAOD::Jet *jet : *(vertjets.jetCont) ) {
 
        // Remove jets which are close to hs
        if (!m_includePV && hasCloseByHSjet(jet,pjets)) continue;
 
        // Calculate vertex missing momentum
        if (isQCDPUJet(jet) && getRpt(jet)> m_rptCut)
        { 
          vertex_met += TVector2(jet->pt()*cos(jet->phi()),jet->pt()*sin(jet->phi()) ) ;
        } 
        else{
          vertex_met += TVector2(jet->jetP4(m_jetchargedp4).Pt()*cos(jet->jetP4(m_jetchargedp4).Phi()),
                                 jet->jetP4(m_jetchargedp4).Pt()*sin(jet->jetP4(m_jetchargedp4).Phi()) );
        }
      }
 
      pileupMomenta.push_back(vertex_met);
      if(vertices!=-1 && int(vx->index())==vertices) break;
    }
    return pileupMomenta;
  }

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

decorate()

StatusCode JetBalancePFlowJvtTool::decorate ( const xAOD::JetContainer & jets ) const

overridevirtual

Decorate a jet collection without otherwise modifying it.

Reimplemented from JetForwardPFlowJvtTool.

Definition at line 69 of file JetBalancePFlowJvtTool.cxx.

                                                                                   {
    std::vector<TVector2> pileupMomenta;
    pileupMomenta=calculateVertexMomenta(&jetCont,m_pvind, m_vertices);
    SG::WriteDecorHandle<xAOD::JetContainer, char> bjvtHandle(m_bjvtKey);
    SG::WriteDecorHandle<xAOD::JetContainer, float> bjvtRawHandle(m_bjvtRawKey);
    if(pileupMomenta.empty()) {
      ATH_MSG_DEBUG( "pileupMomenta is empty, this can happen for events with no PU vertices."
                     <<" bJVT won't be computed for this event and will be set to 0 instead." );
      for(const xAOD::Jet* jetC : jetCont) {
        bjvtHandle(*jetC) = 1;
        bjvtRawHandle(*jetC) = 0;
      }
      return StatusCode::SUCCESS;
    }
 
    for(const xAOD::Jet* jetC : jetCont) {
      bjvtHandle(*jetC) = 1;
      bjvtRawHandle(*jetC) = 0;
 
      if (isCentralJet(jetC)){
        double bjvt = getFJVT(jetC,pileupMomenta); //Same projection function as fJVT
        if (bjvt>m_bjvtThresh) bjvtHandle(*jetC) = 0;
        bjvtRawHandle(*jetC) = bjvt;
      }
    }
    return StatusCode::SUCCESS;
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

feToPseudoJet()

fastjet::PseudoJet JetForwardPFlowJvtTool::feToPseudoJet ( const xAOD::FlowElement * fe, const CP::PFO_JetMETConfig_charge & theCharge, const xAOD::Vertex * vx ) const

inherited

Definition at line 341 of file JetForwardPFlowJvtTool.cxx.

                                                                                                                                                          {
    TLorentzVector fe_p4;
    if (CP::charged == theCharge){
      float pweight = m_weight;
      if( (m_wpfotool->fillWeight(*fe,pweight)).isSuccess() ){
    // Create a Peeudojet with the momentum of the selected IParticle
    fe_p4= TLorentzVector(fe->p4().Px()*pweight,fe->p4().Py()*pweight,fe->p4().Pz()*pweight,fe->e()*pweight);
      }
    } else if (CP::neutral == theCharge){
      fe_p4=FEHelpers::getVertexCorrectedFourVec(*fe, *vx);
    }
    fastjet::PseudoJet psj(fe_p4);
    // User index is used to identify the xAOD object used for the PseudoJet
    if (CP::charged == theCharge){
      psj.set_user_index(fe->index());
    }else{
      psj.set_user_index(-1);
    }
 
    return psj;
  }

getFJVT()

float JetForwardPFlowJvtTool::getFJVT ( const xAOD::Jet * jet, const std::vector< TVector2 > & pileupMomenta ) const

inherited

Definition at line 127 of file JetForwardPFlowJvtTool.cxx.

                                                                                                          {
    TVector2 fjet(jet->pt()*cos(jet->phi()),jet->pt()*sin(jet->phi()));
    double fjvt = 0;
    for (const TVector2& pu : pileupMomenta) {
      double projection = pu*fjet/fjet.Mod();
      if (projection<fjvt) fjvt = projection;
    }
    return -1*fjvt/fjet.Mod();
  }

getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void * ptr ) const

inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getName

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

                                                    {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getKey( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      return ( proxy == nullptr ? 0 : proxy->sgkey() );
#endif // XAOD_STANDALONE
   }

getName()

const std::string & asg::AsgTool::getName ( const void * ptr ) const

inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also

asg::AsgTool::getKey

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns

The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

                                                            {
 
#ifdef XAOD_STANDALONE
      // In case we use @c xAOD::TEvent, we have a direct function call
      // for this.
      return evtStore()->event()->getName( ptr );
#else
      const SG::DataProxy* proxy = evtStore()->proxy( ptr );
      static const std::string dummy = "";
      return ( proxy == nullptr ? dummy : proxy->name() );
#endif // XAOD_STANDALONE
   }

getProperty()

template<class T>

const T * asg::AsgTool::getProperty ( const std::string & name ) const

inherited

Get one of the tool's properties.

getPV()

std::size_t JetForwardPFlowJvtTool::getPV ( ) const

inherited

Definition at line 381 of file JetForwardPFlowJvtTool.cxx.

                                               {
    if (m_includePV) return -1;
 
    //const xAOD::VertexContainer *vxCont = 0;
    SG::ReadHandle<xAOD::VertexContainer> vxContHandle(m_vxContKey);
    ATH_MSG_DEBUG("Successfully retrieved primary vertex container");
    for(const xAOD::Vertex *vx : *vxContHandle) {
      if(vx->vertexType()==xAOD::VxType::PriVtx) return vx->index();
    } 
    // If no verticies are found in the event the Primary Vertex container will just contain a dummy vertex and no primary vertex   
    if(vxContHandle->empty() ){     
      ATH_MSG_ERROR("Primary vertex container is empty ");
    } else if(vxContHandle->size() != 1 ){     
      ATH_MSG_WARNING("Couldn't identify the hard-scatter primary vertex (no vertex with \"vx->vertexType()==xAOD::VxType::PriVtx\" in the container)! ");
    }
    // this almost certainly isn't what we should do here, the
    // caller doesn't check this for errors
    return 0;
  }

getRpt()

double JetForwardPFlowJvtTool::getRpt ( const xAOD::Jet * jet ) const

inherited

Definition at line 375 of file JetForwardPFlowJvtTool.cxx.

                                                                {
    double Rpt;
    Rpt= jet->jetP4(m_jetchargedp4).Pt()/ jet->pt();
    return Rpt;
  }

hasCloseByHSjet()

bool JetForwardPFlowJvtTool::hasCloseByHSjet ( const xAOD::Jet * jet, const xAOD::JetContainer * pjets ) const

inherited

Definition at line 182 of file JetForwardPFlowJvtTool.cxx.

                                                                                                       {
    for (const xAOD::Jet* pjet : *pjets) {
      char jet_nnjvtpass=false;
      SG::ReadDecorHandle<xAOD::JetContainer, char>  passJvtHandle(m_passJvtKey);
      jet_nnjvtpass = passJvtHandle(*pjet);
      if (pjet->p4().DeltaR(jet->p4())<0.3 && jet_nnjvtpass && isCentralJet(pjet) ) return true;
    }
    return false;
  }

initialize()

StatusCode JetBalancePFlowJvtTool::initialize ( void )

overridevirtual

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented from JetForwardPFlowJvtTool.

Definition at line 45 of file JetBalancePFlowJvtTool.cxx.

  {
    ATH_MSG_INFO ("Initializing " << name() << "...");
 
    if(m_FEKey.empty()){
      ATH_MSG_ERROR("Flow Element container is empty");
      return StatusCode::FAILURE;
    }
 
    ATH_CHECK( JetForwardPFlowJvtTool::initialize() );
 
    m_bjvtKey = m_jetContainerName + "." + m_bjvtKey.key();
    m_bjvtRawKey = m_jetContainerName + "." + m_bjvtRawKey.key();
    m_isQCDPUKey = m_jetContainerName + "." + m_isQCDPUKey.key();
    m_isStochPUKey = m_jetContainerName + "." + m_isStochPUKey.key();
 
    ATH_CHECK(m_bjvtKey.initialize());
    ATH_CHECK(m_bjvtRawKey.initialize());
    ATH_CHECK(m_isQCDPUKey.initialize());
    ATH_CHECK(m_isStochPUKey.initialize());
 
    return StatusCode::SUCCESS;
  }

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isCentralJet()

bool JetForwardPFlowJvtTool::isCentralJet ( const xAOD::Jet * jet ) const

inherited

Definition at line 369 of file JetForwardPFlowJvtTool.cxx.

                                                                    {
    if (std::abs(jet->eta())>m_etaThresh) return false;
    if (jet->pt()<m_centerMinPt || (m_centerMaxPt>0 && jet->pt()>m_centerMaxPt)) return false;
    return true;
  }

isForwardJet()

bool JetForwardPFlowJvtTool::isForwardJet ( const xAOD::Jet * jet ) const

inherited

Definition at line 363 of file JetForwardPFlowJvtTool.cxx.

                                                                    {
    if (std::abs(jet->eta())<m_etaThresh) return false;
    if (jet->pt()<m_forwardMinPt || (m_forwardMaxPt>0 && jet->pt()>m_forwardMaxPt) ) return false;
    return true;
  }

isQCDPUJet()

bool JetBalancePFlowJvtTool::isQCDPUJet

(

const xAOD::Jet *

jet

)

const

Definition at line 143 of file JetBalancePFlowJvtTool.cxx.

                                                                  {
    if (std::abs(jet->eta())>m_etaThresh) return false; //Must be central
    if (jet->pt()<m_QCDPUMinPt || (m_QCDPUMaxPt>0 && jet->pt()>m_QCDPUMaxPt) ) return false;
    //Other selections? EMPTopo studies included cuts on JVT and JVF
    return true;
  }

modify()

virtual StatusCode IJetDecorator::modify ( xAOD::JetContainer & jets ) const

inlinefinaloverridevirtualinherited

Concrete implementation of the function inherited from IJetModifier.

Implements IJetModifier.

Definition at line 32 of file IJetDecorator.h.

{return decorate(jets);};

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const

inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns

The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

                                                  {
 
      return MSG::name( msg().level() );
   }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

pfoToPseudoJet()

fastjet::PseudoJet JetForwardPFlowJvtTool::pfoToPseudoJet ( const xAOD::PFO * pfo, const CP::PFO_JetMETConfig_charge & theCharge, const xAOD::Vertex * vx ) const

inherited

Definition at line 319 of file JetForwardPFlowJvtTool.cxx.

                                                                                                                                                    {
    TLorentzVector pfo_p4;
    if (CP::charged == theCharge){
      float pweight = m_weight;
      if( (m_wpfotool->fillWeight(*pfo,pweight)).isSuccess() ){
    // Create a PSeudojet with the momentum of the selected IParticle
    pfo_p4= TLorentzVector(pfo->p4().Px()*pweight,pfo->p4().Py()*pweight,pfo->p4().Pz()*pweight,pfo->e()*pweight);
      }
    } else if (CP::neutral == theCharge){ 
      pfo_p4= pfo->GetVertexCorrectedEMFourVec(*vx);
    }
    fastjet::PseudoJet psj(pfo_p4);
    // User index is used to identify the xAOD object used for the PSeudoJet
    if (CP::charged == theCharge){
      psj.set_user_index(pfo->index());
    }else{
      psj.set_user_index(-1);
    }
 
    return psj;
  }

print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in AsgHelloTool, HI::HIPileupTool, JetBottomUpSoftDrop, JetConstituentsRetriever, JetDumper, JetFinder, JetFromPseudojet, JetModifiedMassDrop, JetPileupLabelingTool, JetPruner, JetPseudojetRetriever, JetReclusterer, JetReclusteringTool, JetRecTool, JetRecursiveSoftDrop, JetSoftDrop, JetSplitter, JetSubStructureMomentToolsBase, JetToolRunner, JetTrimmer, JetTruthLabelingTool, KtDeltaRTool, and LundVariablesTool.

Definition at line 131 of file AsgTool.cxx.

                             {
 
      ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
      return;
   }

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

tagTruth() [1/2]

StatusCode JetBalancePFlowJvtTool::tagTruth	(	const xAOD::JetContainer *	jets,
		const xAOD::JetContainer *	truthJets,
		const xAOD::JetContainer *	itpujets,
		const xAOD::JetContainer *	ootpujets )

Definition at line 151 of file JetBalancePFlowJvtTool.cxx.

                                                                                                                  {
    //truthJets container taken to be truth HS - @to-Do double check this
    //In-time and out-of-time PU truth jets given in AODs as separate containers
    SG::WriteDecorHandle<xAOD::JetContainer, bool> isHSHandle(m_isHSKey);
    SG::WriteDecorHandle<xAOD::JetContainer, bool> isQCDPUHandle(m_isQCDPUKey);
    SG::WriteDecorHandle<xAOD::JetContainer, bool> isStochPUHandle(m_isStochPUKey);
    
    for(const xAOD::Jet *jet : *jets) {
      bool ishs = false;
      bool ispu = true;
 
      bool isqcdpu = false;
      bool isstochpu = true; //Default value to make logic work - changed below
      
      for(const xAOD::Jet *tjet : *truthJets) {
        if (tjet->p4().DeltaR(jet->p4())<0.3 && tjet->pt()>10e3) ishs = true;
        if (tjet->p4().DeltaR(jet->p4())<0.6 && tjet->pt()>4e3)  ispu = false;
      }
      
      if (ispu){
        //Need to check both containers
        for(const xAOD::Jet *itpujet : *itpujets){
          if (itpujet->p4().DeltaR(jet->p4())<0.3 && itpujet->pt()>10e3) isqcdpu = true;
          if (itpujet->p4().DeltaR(jet->p4())<0.6 && itpujet->pt()>10e3) isstochpu = false;
        }
        for(const xAOD::Jet *ootpujet : *ootpujets){
          if (ootpujet->p4().DeltaR(jet->p4())<0.3 && ootpujet->pt()>10e3) isqcdpu = true;
          if (ootpujet->p4().DeltaR(jet->p4())<0.6 && ootpujet->pt()>10e3) isstochpu = false;
        }
      }
 
      else {
        isstochpu = false; //Can't be labelled stochastic PU if jet is not determined to be PU
      }
 
      isHSHandle(*jet)=ishs;
      isQCDPUHandle(*jet)=isqcdpu;
      isStochPUHandle(*jet)=isstochpu;
    }
  
  return StatusCode::SUCCESS;
  }

tagTruth() [2/2]

StatusCode JetForwardPFlowJvtTool::tagTruth ( const xAOD::JetContainer * jets, const xAOD::JetContainer * truthJets )

inherited

Definition at line 401 of file JetForwardPFlowJvtTool.cxx.

                                                                                                            {
    SG::WriteDecorHandle<xAOD::JetContainer, bool> isHSHandle(m_isHSKey);
    SG::WriteDecorHandle<xAOD::JetContainer, bool> isPUHandle(m_isPUKey);
    
    for(const xAOD::Jet *jet : *jets) {
      bool ishs = false;
      bool ispu = true;
      for(const xAOD::Jet *tjet : *truthJets) {
        if (tjet->p4().DeltaR(jet->p4())<0.3 && tjet->pt()>10e3) ishs = true;
        if (tjet->p4().DeltaR(jet->p4())<0.6) ispu = false;
      }
      isHSHandle(*jet)=ishs;
      isPUHandle(*jet)=ispu;
    }
    return StatusCode::SUCCESS;
  }

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_bjvtKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JetBalancePFlowJvtTool::m_bjvtKey {this, "BjvtName", "passOnlyBJVT", "Decorator for passing bJVT threshold (tight or loose)"}

protected

Definition at line 126 of file JetBalancePFlowJvtTool.h.

{this, "BjvtName", "passOnlyBJVT", "Decorator for passing bJVT threshold (tight or loose)"};

m_bjvtRawKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JetBalancePFlowJvtTool::m_bjvtRawKey {this, "BjvtRawName", "bJvt", "Decorator for raw bJVT variable"}

protected

Definition at line 127 of file JetBalancePFlowJvtTool.h.

{this, "BjvtRawName", "bJvt", "Decorator for raw bJVT variable"};

m_bjvtThresh

float JetBalancePFlowJvtTool::m_bjvtThresh

protected

Definition at line 131 of file JetBalancePFlowJvtTool.h.

m_centerMaxPt

Gaudi::Property<double> JetForwardPFlowJvtTool::m_centerMaxPt {this, "centralMaxPt", -1, "Maximum central jet pt. If -1 no threshold is applied"}

protectedinherited

Definition at line 138 of file JetForwardPFlowJvtTool.h.

{this, "centralMaxPt", -1, "Maximum central jet pt. If -1 no threshold is applied"};

m_centerMinPt

Gaudi::Property<double> JetForwardPFlowJvtTool::m_centerMinPt {this, "centralMinPt", 20e3, "Minimum central jet pt"}

protectedinherited

Definition at line 137 of file JetForwardPFlowJvtTool.h.

{this, "centralMinPt", 20e3, "Minimum central jet pt"};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_dzCut

Gaudi::Property<double> JetForwardPFlowJvtTool::m_dzCut {this, "dzCut", 2.0, "Dz=z=-z0 cut for pfo objects participating in the HS vertex jet reco"}

protectedinherited

Definition at line 142 of file JetForwardPFlowJvtTool.h.

{this, "dzCut", 2.0, "Dz=z=-z0 cut for pfo objects participating in the HS vertex jet reco"};

m_etaThresh

Gaudi::Property<double> JetForwardPFlowJvtTool::m_etaThresh {this, "etaThresh", 2.5, "Maximum eta value for considering a jet as central"}

protectedinherited

Definition at line 134 of file JetForwardPFlowJvtTool.h.

{this, "etaThresh", 2.5, "Maximum eta value for considering a jet as central"};

m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> JetForwardPFlowJvtTool::m_eventInfoKey {"EventInfo"}

protectedinherited

Definition at line 155 of file JetForwardPFlowJvtTool.h.

{"EventInfo"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_FEKey

SG::ReadHandleKey<xAOD::FlowElementContainer> JetForwardPFlowJvtTool::m_FEKey {this, "FEName", "", "SG Key for CHS FlowElement Container (overrides PFO if not empty)"}

protectedinherited

Definition at line 154 of file JetForwardPFlowJvtTool.h.

{this, "FEName", "", "SG Key for CHS FlowElement Container (overrides PFO if not empty)"};

m_fjvtKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JetForwardPFlowJvtTool::m_fjvtKey {this, "FjvtName", "passOnlyFJVT", "Decorator for passing fJVT threshold (tight or loose)"}

protectedinherited

Definition at line 161 of file JetForwardPFlowJvtTool.h.

{this, "FjvtName", "passOnlyFJVT", "Decorator for passing fJVT threshold (tight or loose)"};

m_fjvtRawKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JetForwardPFlowJvtTool::m_fjvtRawKey {this, "FjvtRawName", "fJvt", "Decorator for raw fJVT variable"}

protectedinherited

Definition at line 162 of file JetForwardPFlowJvtTool.h.

{this, "FjvtRawName", "fJvt", "Decorator for raw fJVT variable"};

m_fjvtThresh

Gaudi::Property<double> JetForwardPFlowJvtTool::m_fjvtThresh {this, "fjvtThresh", 15e3, "fjvt threshold value"}

protectedinherited

Definition at line 139 of file JetForwardPFlowJvtTool.h.

{this, "fjvtThresh", 15e3, "fjvt threshold value"};

m_forwardMaxPt

Gaudi::Property<double> JetForwardPFlowJvtTool::m_forwardMaxPt {this, "forwardMaxPt", -1, "Maximum forward jet pt. If -1 no threshold is applied"}

protectedinherited

Definition at line 136 of file JetForwardPFlowJvtTool.h.

{this, "forwardMaxPt", -1, "Maximum forward jet pt. If -1 no threshold is applied"};

m_forwardMinPt

Gaudi::Property<double> JetForwardPFlowJvtTool::m_forwardMinPt {this, "forwardMinPt", 18e3, "Minimum forward jet pt"}

protectedinherited

Definition at line 135 of file JetForwardPFlowJvtTool.h.

{this, "forwardMinPt", 18e3, "Minimum forward jet pt"};

m_includePV

Gaudi::Property<bool> JetForwardPFlowJvtTool::m_includePV {this, "includePV", false, "Flag to include jets and tracks associated to PV in the calculation"}

protectedinherited

Definition at line 133 of file JetForwardPFlowJvtTool.h.

{this, "includePV", false, "Flag to include jets and tracks associated to PV in the calculation"};

m_isdata

Gaudi::Property<bool> JetForwardPFlowJvtTool::m_isdata {this, "isdata", false, "True if data"}

protectedinherited

Definition at line 130 of file JetForwardPFlowJvtTool.h.

{this, "isdata", false, "True if data"};

m_isHSKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JetForwardPFlowJvtTool::m_isHSKey {this, "isHSName", "isJVTHS", "SG key for output isJVTHS decoration"}

protectedinherited

Definition at line 163 of file JetForwardPFlowJvtTool.h.

{this, "isHSName", "isJVTHS", "SG key for output isJVTHS decoration"};

m_isPUKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JetForwardPFlowJvtTool::m_isPUKey {this, "isPUName", "isJvtPU", "SG key for output isJVTPU decoration"}

protectedinherited

Definition at line 164 of file JetForwardPFlowJvtTool.h.

{this, "isPUName", "isJvtPU", "SG key for output isJVTPU decoration"};

m_isQCDPUKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JetBalancePFlowJvtTool::m_isQCDPUKey {this, "isQCDPUName", "isJvtQCDPU", "SG key for output isJVTQCDPU decoration"}

protected

Definition at line 128 of file JetBalancePFlowJvtTool.h.

{this, "isQCDPUName", "isJvtQCDPU", "SG key for output isJVTQCDPU decoration"};

m_isStochPUKey

SG::WriteDecorHandleKey<xAOD::JetContainer> JetBalancePFlowJvtTool::m_isStochPUKey {this, "isStochPUName", "isJvtStochPU", "SG key for output isJVTStochPU decoration"}

protected

Definition at line 129 of file JetBalancePFlowJvtTool.h.

{this, "isStochPUName", "isJvtStochPU", "SG key for output isJVTStochPU decoration"};

m_jetchargedp4

Gaudi::Property<std::string> JetForwardPFlowJvtTool::m_jetchargedp4 {this, "jetchargedp4", "JetChargedScaleMomentum", "Name of the jet charged momentum 4-vector"}

protectedinherited

Definition at line 128 of file JetForwardPFlowJvtTool.h.

{this, "jetchargedp4", "JetChargedScaleMomentum", "Name of the jet charged momentum 4-vector"};

m_jetContainerName

Gaudi::Property<std::string> JetForwardPFlowJvtTool::m_jetContainerName {this, "JetContainer", "", "SG key for the input jet container"}

protectedinherited

Definition at line 126 of file JetForwardPFlowJvtTool.h.

{this, "JetContainer", "", "SG key for the input jet container"};

m_jetsName

Gaudi::Property<std::string> JetForwardPFlowJvtTool::m_jetsName {this, "jetsName", "AntiKt4PUPFlowJets", "Container name for the output reconstructed PU jets"}

protectedinherited

Definition at line 127 of file JetForwardPFlowJvtTool.h.

{this, "jetsName", "AntiKt4PUPFlowJets", "Container name for the output reconstructed PU jets"};

m_jvtCut

Gaudi::Property<double> JetForwardPFlowJvtTool::m_jvtCut {this, "jvtCut", 0.2, "JVT threshold value for considering a central PU jet as HS"}

protectedinherited

Definition at line 141 of file JetForwardPFlowJvtTool.h.

{this, "jvtCut", 0.2, "JVT threshold value for considering a central PU jet as HS"};

m_maxRap

Gaudi::Property<double> JetForwardPFlowJvtTool::m_maxRap {this, "maxRap", 2.5, "Maximum rapidity value in fastjet::AreaDefinition"}

protectedinherited

Definition at line 143 of file JetForwardPFlowJvtTool.h.

{this, "maxRap", 2.5, "Maximum rapidity value in fastjet::AreaDefinition"};

m_neutMaxRap

Gaudi::Property<double> JetForwardPFlowJvtTool::m_neutMaxRap {this, "neutMaxRap", 2.5, "Maximum rapidity value for neutral pfos participating in jet reco"}

protectedinherited

Definition at line 144 of file JetForwardPFlowJvtTool.h.

{this, "neutMaxRap", 2.5, "Maximum rapidity value for neutral pfos participating in jet reco"};

m_orFEKey

SG::ReadDecorHandleKey<xAOD::FlowElement> JetForwardPFlowJvtTool::m_orFEKey {this, "ORNameFE", "", "OR label"}

protectedinherited

Definition at line 159 of file JetForwardPFlowJvtTool.h.

{this, "ORNameFE", "", "OR label"};

m_orKey

SG::ReadDecorHandleKey<xAOD::PFO> JetForwardPFlowJvtTool::m_orKey {this, "ORName", "", "OR label"}

protectedinherited

Definition at line 158 of file JetForwardPFlowJvtTool.h.

{this, "ORName", "", "OR label"};

m_passJvtKey

SG::ReadDecorHandleKey<xAOD::JetContainer> JetForwardPFlowJvtTool::m_passJvtKey {this, "passJvtName", "NNJvtPass", "SG key for output pass-JVT decoration"}

protectedinherited

Definition at line 157 of file JetForwardPFlowJvtTool.h.

{this, "passJvtName", "NNJvtPass", "SG key for output pass-JVT decoration"};

m_pfoJES

ToolHandle<IJetCalibrationTool> JetForwardPFlowJvtTool::m_pfoJES {this,"JetCalibrationTool", "", "Jet calibration tool name"}

protectedinherited

Definition at line 167 of file JetForwardPFlowJvtTool.h.

{this,"JetCalibrationTool", "", "Jet calibration tool name"};

m_PFOKey

SG::ReadHandleKey<xAOD::PFOContainer> JetForwardPFlowJvtTool::m_PFOKey {this, "PFOName", "CHSParticleFlowObjects", "SG Key for CHS PFO Container"}

protectedinherited

Definition at line 153 of file JetForwardPFlowJvtTool.h.

{this, "PFOName", "CHSParticleFlowObjects", "SG Key for CHS PFO Container"};

m_pvind

Gaudi::Property<int> JetForwardPFlowJvtTool::m_pvind {this, "pvind", -1, "Hard-Scatter primary vertex index of the event. If -1 it will be automatically retrieved from the event"}

protectedinherited

Definition at line 131 of file JetForwardPFlowJvtTool.h.

{this, "pvind", -1, "Hard-Scatter primary vertex index of the event. If -1 it will be automatically retrieved from the event"};

m_QCDPUMaxPt

Gaudi::Property<float> JetBalancePFlowJvtTool::m_QCDPUMaxPt {this, "QCDPUMaxPt", -1, "Maximum pt cut value for central PU jets contributing in the missing momentum calculation. If -1 no threshold is applied"}

protected

Definition at line 123 of file JetBalancePFlowJvtTool.h.

{this, "QCDPUMaxPt", -1, "Maximum pt cut value for central PU jets contributing in the missing momentum calculation. If -1 no threshold is applied"};

m_QCDPUMinPt

Gaudi::Property<float> JetBalancePFlowJvtTool::m_QCDPUMinPt {this, "QCDPUMinPt", 20e3, "Minimum pt cut value for central PU jets contributing in the missing momentum calculation"}

protected

Definition at line 122 of file JetBalancePFlowJvtTool.h.

{this, "QCDPUMinPt", 20e3, "Minimum pt cut value for central PU jets contributing in the missing momentum calculation"};

m_rptCut

Gaudi::Property<double> JetForwardPFlowJvtTool::m_rptCut {this, "rptCut", 0.1, "Rpt cut value for central PU jets contributing in the missing momentum calculation"}

protectedinherited

Definition at line 140 of file JetForwardPFlowJvtTool.h.

{this, "rptCut", 0.1, "Rpt cut value for central PU jets contributing in the missing momentum calculation"};

m_suppressInputDependence

Gaudi::Property<bool> JetForwardPFlowJvtTool::m_suppressInputDependence {this, "SuppressInputDependence", false}

protectedinherited

Definition at line 169 of file JetForwardPFlowJvtTool.h.

{this, "SuppressInputDependence", false};

m_tightOP

Gaudi::Property<bool> JetForwardPFlowJvtTool::m_tightOP {this, "tightOP", false, "If true a tight fjvt threshold value is applied"}

protectedinherited

Definition at line 146 of file JetForwardPFlowJvtTool.h.

{this, "tightOP", false, "If true a tight fjvt threshold value is applied"};

m_tvaKey

SG::ReadHandleKey<jet::TrackVertexAssociation> JetForwardPFlowJvtTool::m_tvaKey {this, "TrackVertexAssociation", "", "Input track-vertex association"}

protectedinherited

Definition at line 125 of file JetForwardPFlowJvtTool.h.

{this, "TrackVertexAssociation", "", "Input track-vertex association"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vertices

Gaudi::Property<int> JetForwardPFlowJvtTool::m_vertices {this, "vertices", 10, "Number of vertices for which the missing momentum is calculated"}

protectedinherited

Definition at line 132 of file JetForwardPFlowJvtTool.h.

{this, "vertices", 10, "Number of vertices for which the missing momentum is calculated"};

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_vxContKey

SG::ReadHandleKey<xAOD::VertexContainer> JetForwardPFlowJvtTool::m_vxContKey {this, "verticesName", "PrimaryVertices", "Container name of vertices to be retrieved"}

protectedinherited

Definition at line 152 of file JetForwardPFlowJvtTool.h.

{this, "verticesName", "PrimaryVertices", "Container name of vertices to be retrieved"};

m_weight

Gaudi::Property<float> JetForwardPFlowJvtTool::m_weight {this, "weight", 0, "PFO weight value"}

protectedinherited

Definition at line 145 of file JetForwardPFlowJvtTool.h.

{this, "weight", 0, "PFO weight value"};

m_wpfotool

ToolHandle<CP::WeightPFOTool> JetForwardPFlowJvtTool::m_wpfotool {this,"WeightPFOTool", "", "Weight PFO tool name"}

protectedinherited

Definition at line 166 of file JetForwardPFlowJvtTool.h.

{this,"WeightPFOTool", "", "Weight PFO tool name"};

---

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

• JetBalancePFlowJvtTool.h
• JetBalancePFlowJvtTool.cxx