#include <RCJet.h>

Inheritance diagram for RCJet:

Collaboration diagram for RCJet:

Public Member Functions
	RCJet (const std::string &name)

	~RCJet ()

	RCJet (const RCJet &rhs)=delete

	RCJet (RCJet &&rhs)=delete

RCJet &	operator= (const RCJet &rhs)=delete

StatusCode	initialize ()
	Dummy implementation of the initialisation function. More...

StatusCode	execute (const top::Event &event)

StatusCode	finalize ()

bool	isUniqueSyst (std::string syst_name)

std::string	inputContainerName (std::size_t hash_value, bool isLooseEvent)

std::string	rcjetContainerName (std::size_t hash_value, bool isLooseEvent)

bool	passSelection (const xAOD::Jet &jet) const

void	getEMTopoClusters (std::vector< fastjet::PseudoJet > &clusters, const xAOD::Jet *rcjet)

void	getLCTopoClusters (std::vector< fastjet::PseudoJet > &clusters, const xAOD::Jet *rcjet)

void	getPflowConstituent (std::vector< fastjet::PseudoJet > &clusters, const xAOD::Jet *rcjet, const top::Event &event)

virtual void	print () const
	Print the state of the tool. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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. More...

Private Types
typedef std::map< std::size_t, std::string >::iterator	m_iterator

typedef std::unordered_map< std::size_t, std::shared_ptr< JetReclusteringTool > >::iterator	m_tool_iterator

typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

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

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
std::string	m_name

std::shared_ptr< top::TopConfig >	m_config

bool	m_VarRCjets

std::string	m_VarRCjets_rho

std::string	m_VarRCjets_mass_scale

float	m_ptcut

float	m_etamax

float	m_inputJetPtMin

float	m_inputJetEtaMax

float	m_trim

float	m_radius

float	m_minradius

float	m_massscale

bool	m_useJSS

bool	m_useAdditionalJSS

std::string	m_egamma

std::string	m_jetsyst

std::string	m_muonsyst

std::string	m_tracksyst

std::string	m_InJetContainerBase

std::string	m_OutJetContainerBase

std::string	m_InputJetContainer

std::string	m_OutputJetContainer

int	m_loose_hashValue

std::shared_ptr< fastjet::JetDefinition >	m_jet_def_rebuild

std::shared_ptr< fastjet::contrib::Nsubjettiness >	m_nSub1_beta1

std::shared_ptr< fastjet::contrib::Nsubjettiness >	m_nSub2_beta1

std::shared_ptr< fastjet::contrib::Nsubjettiness >	m_nSub3_beta1

std::shared_ptr< fastjet::contrib::EnergyCorrelator >	m_ECF1

std::shared_ptr< fastjet::contrib::EnergyCorrelator >	m_ECF2

std::shared_ptr< fastjet::contrib::EnergyCorrelator >	m_ECF3

std::shared_ptr< JetSubStructureUtils::KtSplittingScale >	m_split12

std::shared_ptr< JetSubStructureUtils::KtSplittingScale >	m_split23

std::shared_ptr< JetSubStructureUtils::Qw >	m_qw

std::shared_ptr< JetSubStructureUtils::EnergyCorrelatorGeneralized >	m_gECF332

std::shared_ptr< JetSubStructureUtils::EnergyCorrelatorGeneralized >	m_gECF461

std::shared_ptr< JetSubStructureUtils::EnergyCorrelatorGeneralized >	m_gECF322

std::shared_ptr< JetSubStructureUtils::EnergyCorrelatorGeneralized >	m_gECF331

std::shared_ptr< JetSubStructureUtils::EnergyCorrelatorGeneralized >	m_gECF422

std::shared_ptr< JetSubStructureUtils::EnergyCorrelatorGeneralized >	m_gECF441

std::shared_ptr< JetSubStructureUtils::EnergyCorrelatorGeneralized >	m_gECF212

std::shared_ptr< JetSubStructureUtils::EnergyCorrelatorGeneralized >	m_gECF321

std::shared_ptr< JetSubStructureUtils::EnergyCorrelatorGeneralized >	m_gECF311

bool	m_unique_syst

std::map< std::size_t, std::string >	m_inputContainerNames

std::map< std::size_t, std::string >	m_outputContainerNames

std::map< std::string, float >	mass_scales

std::unordered_map< std::size_t, std::shared_ptr< JetReclusteringTool > >	m_jetReclusteringTool

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 55 of file RCJet.h.

Member Typedef Documentation

◆ m_iterator

typedef std::map<std::size_t, std::string>::iterator RCJet::m_iterator

private

Definition at line 142 of file RCJet.h.

◆ m_tool_iterator

typedef std::unordered_map<std::size_t, std::shared_ptr<JetReclusteringTool> >::iterator RCJet::m_tool_iterator

private

Definition at line 156 of file RCJet.h.

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ RCJet() [1/3]

RCJet::RCJet ( const std::string & name )

explicit

Definition at line 38 of file RCJetMC.cxx.

                                   :
   asg::AsgTool(name),
   m_name(name),
   m_config(nullptr),
   m_ptcut(0.),
   m_etamax(0.),
   m_inputJetPtMin(0.),
   m_inputJetEtaMax(999.),
   m_trim(0.),
   m_radius(0.),
   m_minradius(0.),
   m_massscale(0.),
   m_useJSS(false),
   m_useAdditionalJSS(false),
   m_egamma("EG_"),
   m_jetsyst("JET_"),
   m_muonsyst("MUON_"),
   m_tracksyst("TRK_"),
   m_InJetContainerBase("AntiKt4EMTopoJets_RC"),
   m_OutJetContainerBase("AntiKtRCJets"),
   m_InputJetContainer("AntiKt4EMTopoJets_RC"),
   m_OutputJetContainer("AntiKtRCJets"),
   m_loose_hashValue(2),
   m_jet_def_rebuild(nullptr),
   m_nSub1_beta1(nullptr),
   m_nSub2_beta1(nullptr),
   m_nSub3_beta1(nullptr),
   m_ECF1(nullptr),
   m_ECF2(nullptr),
   m_ECF3(nullptr),
   m_split12(nullptr),
   m_split23(nullptr),
   m_qw(nullptr),
   m_gECF332(nullptr),
   m_gECF461(nullptr),
   m_gECF322(nullptr),
   m_gECF331(nullptr),
   m_gECF422(nullptr),
   m_gECF441(nullptr),
   m_gECF212(nullptr),
   m_gECF321(nullptr),
   m_gECF311(nullptr),
   m_unique_syst(false) {
   declareProperty("config", m_config);
   declareProperty("VarRCjets", m_VarRCjets = false);
   declareProperty("VarRCjets_rho", m_VarRCjets_rho = "");
   declareProperty("VarRCjets_mass_scale", m_VarRCjets_mass_scale = "");
 }

◆ ~RCJet()

RCJet::~RCJet ( )

Definition at line 87 of file RCJetMC.cxx.

87 {}

◆ RCJet() [2/3]

RCJet::RCJet ( const RCJet & rhs )

delete

◆ RCJet() [3/3]

RCJet::RCJet ( RCJet && rhs )

delete

Member Function Documentation

◆ declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	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());
  
   }

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ 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.

95 { return m_detStore; }

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode RCJet::execute ( const top::Event & event )

Definition at line 267 of file RCJetMC.cxx.

                                                {
   /*
      Make the jet container (if necessary) and execute the re-clustering tool
       https://svnweb.cern.ch/trac/atlasoff/browser/PhysicsAnalysis/TopPhys/xAOD/TopEvent/trunk/Root/TopEventMaker.cxx#L31
    */
   m_InputJetContainer = inputContainerName(event.m_hashValue, event.m_isLoose);
   m_OutputJetContainer = rcjetContainerName(event.m_hashValue, event.m_isLoose);
  
  
   // -- Save the jet container to the TStore (only if it doesn't already exist!)
   // -- Then, we can access it with the re-clustering tool further down
   if (!evtStore()->contains<xAOD::JetContainer>(m_InputJetContainer)) {
     // Save the nominal container once, and each jet systematic container once
     // Make the new jet container (only do this if we have to!)
     // 22 Feb 2016:
     //   Code significantly shortened to make this container
     //   thanks to email exchange between Davide Gerbaudo & Attila Krasznahorkay
     auto rcJetInputs = std::make_unique< ConstDataVector< xAOD::JetContainer >>(SG::VIEW_ELEMENTS);
     for(const xAOD::Jet* jet : event.m_jets) {
       if(jet->pt() < m_inputJetPtMin || std::abs(jet->eta()) > m_inputJetEtaMax) continue;
       rcJetInputs->push_back(jet);
     }
     top::check(evtStore()->tds()->record(std::move(rcJetInputs), m_InputJetContainer),
                "Failed to put jets in TStore for re-clustering");
   } // end if jet container exists
  
   // --- EXECUTE --- //
   // only execute if the jet container doesn't exist
   // (do not re-make the 'nominal' jet container over & over again!)
   if (!evtStore()->contains<xAOD::JetContainer>(m_OutputJetContainer)) {
     int hash_factor = (event.m_isLoose) ? m_loose_hashValue : 1;
  
     // tools only exist for unique systematics & nominal (save time/space)!
     m_tool_iterator tool_iter = m_jetReclusteringTool.find(hash_factor * event.m_hashValue);
  
     // if this is a unique systematic or nominal, execute from the tool; else execute nominal
     if (tool_iter != m_jetReclusteringTool.end()) tool_iter->second->execute();
     else m_jetReclusteringTool.at(hash_factor * m_config->nominalHashValue())->execute();
  
     xAOD::JetContainer* myJets(nullptr);
     top::check(evtStore()->retrieve(myJets, m_OutputJetContainer), "Failed to retrieve RC JetContainer");
     for (auto rcjet : *myJets) {
       rcjet->auxdecor<bool>("PassedSelection") = passSelection(*rcjet);
     }
  
     if (m_useJSS || m_useAdditionalJSS) {
       static const SG::AuxElement::ConstAccessor<bool> passedSelection("PassedSelection");
  
       for (auto rcjet : *myJets) {
         if (!passedSelection(*rcjet)) continue; // Calculate JSS only if passed object selection
  
         // get the subjets and clusters of the rcjets
  
         std::vector<fastjet::PseudoJet> clusters;
  
  
         if (m_config->sgKeyJetsTDS(hash_factor * m_config->nominalHashValue(),
                                    false).find("AntiKt4EMTopoJets") != std::string::npos) {
       getEMTopoClusters(clusters,rcjet); // use subjet constituents
     }
         else if (m_config->sgKeyJetsTDS(hash_factor * m_config->nominalHashValue(),
                                         false).find("AntiKt4EMPFlowJets") != std::string::npos) {
       getPflowConstituent(clusters, rcjet, event); // use ghost-matched tracks
     }
         else getLCTopoClusters(clusters, rcjet); //  // use LCTOPO CLUSTERS matched to subjet
  
         if (m_config->sgKeyJetsTDS(hash_factor * m_config->nominalHashValue(),
                                    false).find("AntiKt4EMPFlowJets") == std::string::npos) {
           // In case of AntiKt4EMPFlowJets the tracks could be removed by the pile-up cuts
           top::check(
             !clusters.empty(),
             "RCJet::execute(const top::Event& event): Failed to get vector of clusters! Unable to calculate RC jets substructure variables!\n Aborting!");
         }
  
         if (clusters.size() != 0) {
           // Now rebuild the large jet from the small jet constituents aka the original clusters
           fastjet::ClusterSequence clust_seq_rebuild = fastjet::ClusterSequence(clusters, *m_jet_def_rebuild);
           std::vector<fastjet::PseudoJet> my_pjets = fastjet::sorted_by_pt(clust_seq_rebuild.inclusive_jets(0.0));
  
  
           fastjet::PseudoJet correctedJet;
           correctedJet = my_pjets[0];
           //Sometimes fastjet splits the jet into two, so need to correct for that!!
           if (my_pjets.size() > 1) correctedJet += my_pjets[1];
  
           if (m_useJSS) {
             // Now finally we can calculate some substructure!
             double tau32 = -1, tau21 = -1;
  
             double tau1 = m_nSub1_beta1->result(correctedJet);
             double tau2 = m_nSub2_beta1->result(correctedJet);
             double tau3 = m_nSub3_beta1->result(correctedJet);
  
             if (std::abs(tau1) > 1e-8) tau21 = tau2 / tau1;
             else tau21 = -999.0;
             if (std::abs(tau2) > 1e-8) tau32 = tau3 / tau2;
             else tau32 = -999.0;
  
  
  
             double split12 = m_split12->result(correctedJet);
             double split23 = m_split23->result(correctedJet);
             double qw = m_qw->result(correctedJet);
         
         double D2 = -1;
  
             double vECF1 = m_ECF1->result(correctedJet);
             double vECF2 = m_ECF2->result(correctedJet);
             double vECF3 = m_ECF3->result(correctedJet);
             if (std::abs(vECF2) > 1e-8) D2 = vECF3 * vECF1* vECF1* vECF1 / (vECF2 * vECF2 * vECF2);
             else D2 = -999.0;
         
  
             // now attach the results to the original jet
             rcjet->auxdecor<float>("Tau32_clstr") = tau32;
             rcjet->auxdecor<float>("Tau21_clstr") = tau21;
  
             // lets also write out the components so we can play with them later
             rcjet->auxdecor<float>("Tau3_clstr") = tau3;
             rcjet->auxdecor<float>("Tau2_clstr") = tau2;
             rcjet->auxdecor<float>("Tau1_clstr") = tau1;
  
             rcjet->auxdecor<float>("d12_clstr") = split12;
             rcjet->auxdecor<float>("d23_clstr") = split23;
             rcjet->auxdecor<float>("Qw_clstr") = qw;
  
             rcjet->auxdecor<float>("nconstituent_clstr") = clusters.size();
         
         rcjet->auxdecor<float>("ECF1_clstr") = vECF1;
             rcjet->auxdecor<float>("ECF2_clstr") = vECF2;
             rcjet->auxdecor<float>("ECF3_clstr") = vECF3;
             rcjet->auxdecor<float>("D2_clstr") = D2;
         
           } // end of if useJSS
  
           if (m_useAdditionalJSS) {
  
             // MlB's t/H discriminators
             // E = (a*n) / (b*m)
             // for an ECFG_X_Y_Z, a=Y, n=Z -> dimenionless variable
             double gECF332 = m_gECF332->result(correctedJet);
             double gECF461 = m_gECF461->result(correctedJet);
             double gECF322 = m_gECF322->result(correctedJet);
             double gECF331 = m_gECF331->result(correctedJet);
             double gECF422 = m_gECF422->result(correctedJet);
             double gECF441 = m_gECF441->result(correctedJet);
             double gECF212 = m_gECF212->result(correctedJet);
             double gECF321 = m_gECF321->result(correctedJet);
             double gECF311 = m_gECF311->result(correctedJet);
  
             double L1 = -999.0, L2 = -999.0, L3 = -999.0, L4 = -999.0, L5 = -999.0;
             if (std::abs(gECF212) > 1e-12) {
               L1 = gECF321 / gECF212;
               L2 = gECF331 / sqrt(gECF212*gECF212*gECF212);
             }
             if (std::abs(gECF331) > 1e-12) {
               L3 = gECF311 / pow(gECF331,1./3.);
               L4 = gECF322 / pow(gECF331,4./3.);
             }
             if (std::abs(gECF441) > 1e-12) {
               L5 = gECF422/gECF441;
             }
  
             rcjet->auxdecor<float>("gECF332_clstr") = gECF332;
             rcjet->auxdecor<float>("gECF461_clstr") = gECF461;
             rcjet->auxdecor<float>("gECF322_clstr") = gECF322;
             rcjet->auxdecor<float>("gECF331_clstr") = gECF331;
             rcjet->auxdecor<float>("gECF422_clstr") = gECF422;
             rcjet->auxdecor<float>("gECF441_clstr") = gECF441;
             rcjet->auxdecor<float>("gECF212_clstr") = gECF212;
             rcjet->auxdecor<float>("gECF321_clstr") = gECF321;
             rcjet->auxdecor<float>("gECF311_clstr") = gECF311;
             rcjet->auxdecor<float>("L1_clstr") = L1;
             rcjet->auxdecor<float>("L2_clstr") = L2;
             rcjet->auxdecor<float>("L3_clstr") = L3;
             rcjet->auxdecor<float>("L4_clstr") = L4;
             rcjet->auxdecor<float>("L5_clstr") = L5;
             // lets also store the rebuilt jet incase we need it later
             rcjet->auxdecor<float>("RRCJet_pt") = correctedJet.pt();
             rcjet->auxdecor<float>("RRCJet_eta") = correctedJet.eta();
             rcjet->auxdecor<float>("RRCJet_phi") = correctedJet.phi();
             rcjet->auxdecor<float>("RRCJet_e") = correctedJet.e();
           }// end of if useAdditional JSS
         }
       }// end of rcjet loop
     }//m_useJSS || m_useAdditionalJSS
   } //if (!evtStore()->contains<xAOD::JetContainer>(m_OutputJetContainer))
  
  
  
  
  
  
  
  
  
   return StatusCode::SUCCESS;
 } // end execute()

◆ 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

◆ finalize()

StatusCode RCJet::finalize ( )

Definition at line 466 of file RCJetMC.cxx.

                            {
   m_jetReclusteringTool.clear();
  
   return StatusCode::SUCCESS;
 }

◆ getEMTopoClusters()

void RCJet::getEMTopoClusters	(	std::vector< fastjet::PseudoJet > &	clusters,
		const xAOD::Jet *	rcjet
	)

Definition at line 545 of file RCJetMC.cxx.

                                                                                          {
   clusters.clear();
  
   for (auto subjet : rcjet->getConstituents()) {
     const xAOD::Jet* subjet_raw = static_cast<const xAOD::Jet*>(subjet->rawConstituent());
  
     // Make sure we don't try to access jets that have had the clusters thinned
     bool hasConstituents = true;
     auto links = subjet_raw->constituentLinks();
     for (auto link : links) {
       if (!link.isValid()) {
         ATH_MSG_WARNING(
           "Some of the RC Jet Constituents have been thinned - will not be included in RCJet JSS calculation");
         hasConstituents = false;
         break;
       }
     }
     if (!hasConstituents) {
       continue;
     }
  
     for (auto clus_itr : subjet_raw->getConstituents()) {
       if (clus_itr->e() > 0) {
         TLorentzVector temp_p4;
  
         double sf = 1.0;
         temp_p4.SetPtEtaPhiM(clus_itr->pt() * sf, clus_itr->eta(), clus_itr->phi(), clus_itr->m());
  
         clusters.push_back(fastjet::PseudoJet(temp_p4.Px(), temp_p4.Py(), temp_p4.Pz(), temp_p4.E()));
       }
     }
   }
 }

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

◆ getLCTopoClusters()

void RCJet::getLCTopoClusters	(	std::vector< fastjet::PseudoJet > &	clusters,
		const xAOD::Jet *	rcjet
	)

Definition at line 579 of file RCJetMC.cxx.

                                                                                          {
   //LCTOPO CLUSTERS
   clusters.clear();
  
   // get the clusters (directly we so can try using the LCTopo clusters)
   const xAOD::CaloClusterContainer* myClusters(nullptr);
   top::check(evtStore()->retrieve(myClusters, "CaloCalTopoClusters"), "Failed to retrieve CaloCalTopoClusters");
  
  
  
   for (auto cluster : *myClusters) {
     for (auto subjet : rcjet->getConstituents()) {
       const xAOD::Jet* subjet_raw = static_cast<const xAOD::Jet*>(subjet->rawConstituent());
  
       float dR = subjet_raw->p4().DeltaR(cluster->p4());
       if (dR < 0.4) {
         TLorentzVector temp_p4;
         temp_p4.SetPtEtaPhiE(cluster->pt((xAOD::CaloCluster_v1::State(1))),
                              cluster->eta((xAOD::CaloCluster_v1::State(1))),
         cluster->phi((xAOD::CaloCluster_v1::State(1))),
                              cluster->e((xAOD::CaloCluster_v1::State(1))));
         clusters.push_back(fastjet::PseudoJet(temp_p4.Px(), temp_p4.Py(), temp_p4.Pz(), temp_p4.E()));
         break;
       }
     }
   }
 }

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

◆ getPflowConstituent()

void RCJet::getPflowConstituent	(	std::vector< fastjet::PseudoJet > &	clusters,
		const xAOD::Jet *	rcjet,
		const top::Event &	event
	)

Definition at line 607 of file RCJetMC.cxx.

                                                            {
   // At the moment the proper constituent of the PFlows aren't available in TOPQ1 and there is no strategy to provide
   // uncertainty on that consequently
   // at the moment just the tracks ghost matched to the PFLow objects are considered to define the substructure (under
   // suggestion of the JSS group).
   // As a consiquence all the neutral component of the jet is missing from the substructure, this choice is consistently
   // copied at particle level
  
   clusters.clear();
   std::vector<const xAOD::TrackParticle*> jetTracks;
  
  
   for (auto subjet : rcjet->getConstituents()) {
     const xAOD::Jet* subjet_raw = static_cast<const xAOD::Jet*>(subjet->rawConstituent());
     
     if(subjet->pt() < m_config->jetPtGhostTracks() || std::abs(subjet->eta()) > m_config->jetEtaGhostTracks()) continue;
     
  
     jetTracks.clear();
     
     jetTracks = subjet_raw->getAssociatedObjects<xAOD::TrackParticle>(m_config->decoKeyJetGhostTrack(event.m_hashValue));
     bool haveJetTracks = jetTracks.size() != 0;
  
     if (haveJetTracks) {
       
       for ( const xAOD::TrackParticle* jet: jetTracks ){
         TLorentzVector temp_p4;
       
         if (jet != nullptr) {
           
           // Select on track quality, pt, eta and match to vertex  
           if(jet->auxdataConst< char >("passPreORSelection") != 1){
             continue;
           }
           
           temp_p4.SetPtEtaPhiE(jet->pt(), jet->eta(), jet->phi(), jet->e());
           clusters.emplace_back(fastjet::PseudoJet(temp_p4.Px(), temp_p4.Py(), temp_p4.Pz(), temp_p4.E()));
     
         }
       }
     } else {
       ATH_MSG_WARNING(
         "RCJET::No remaining tracks associated to the PFlow jet");
           }
   }
 }

◆ getProperty()

template<class T >

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

inherited

Get one of the tool's properties.

◆ initialize()

StatusCode RCJet::initialize ( )

virtual

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 asg::AsgTool.

Definition at line 90 of file RCJetMC.cxx.

                              {
   /* Initialize the re-clustered jets */
   ATH_MSG_INFO(" Initializing Re-clustered jets ");
  
   // load the necessary parameters from the Dynamic Keys in the config file
   top::ConfigurationSettings* configSettings = top::ConfigurationSettings::get();
  
   m_name = m_VarRCjets_rho + m_VarRCjets_mass_scale;
   if (m_VarRCjets) {
     m_ptcut = std::stof(configSettings->value("VarRCJetPt"));        // 100 GeV
     m_etamax = std::stof(configSettings->value("VarRCJetEta"));       // 2.5
     m_trim = std::stof(configSettings->value("VarRCJetTrim"));      // 0.05 (5% jet pT)
     m_radius = std::stof(configSettings->value("VarRCJetMaxRadius")); // 1.2  (min=0.4)
     m_minradius = 0.4;                                // 0.4 default (until we have smaller jets!)
     std::string original_rho(m_VarRCjets_rho);
     std::replace(original_rho.begin(), original_rho.end(), '_', '.');
     float rho = std::stof(original_rho);
     float m_scale = mass_scales.at(m_VarRCjets_mass_scale);
     m_massscale = rho * m_scale * 1e-3;                   // e.g., 2*m_top; in [GeV]!
  
     m_useJSS = m_config->useVarRCJetSubstructure();
     m_useAdditionalJSS = m_config->useVarRCJetAdditionalSubstructure();
   } else {
     m_ptcut = std::stof(configSettings->value("RCJetPt"));     // for initialize [GeV] & passSelection
     m_etamax = std::stof(configSettings->value("RCJetEta"));    // for passSelection
     m_trim = std::stof(configSettings->value("RCJetTrim"));   // for initialize
     m_radius = std::stof(configSettings->value("RCJetRadius")); // for initialize
     m_minradius = -1.0;
     m_massscale = -1.0;
     m_useJSS = m_config->useRCJetSubstructure();
     m_useAdditionalJSS = m_config->useRCJetAdditionalSubstructure();
   }
  
   m_inputJetPtMin = std::stof(configSettings->value("RCInputJetPtMin"));
   m_inputJetEtaMax = std::stof(configSettings->value("RCInputJetEtaMax"));
  
  
   if (m_useJSS || m_useAdditionalJSS) {
     ATH_MSG_INFO("Calculating RCJet Substructure");
  
     // Setup a bunch of FastJet stuff
     //define the type of jets you will build (http://fastjet.fr/repo/doxygen-3.0.3/classfastjet_1_1JetDefinition.html)
     m_jet_def_rebuild = std::make_shared<fastjet::JetDefinition>(fastjet::antikt_algorithm, 1.0, fastjet::E_scheme,
                                                                  fastjet::Best);
   }
   if (m_useJSS) {
     //Substructure tool definitions
     m_nSub1_beta1 = std::make_shared<fastjet::contrib::Nsubjettiness>(1,
                                                                       fastjet::contrib::OnePass_WTA_KT_Axes(),
                                                                       fastjet::contrib::UnnormalizedMeasure(1.0));
     m_nSub2_beta1 = std::make_shared<fastjet::contrib::Nsubjettiness>(2,
                                                                       fastjet::contrib::OnePass_WTA_KT_Axes(),
                                                                       fastjet::contrib::UnnormalizedMeasure(1.0));
     m_nSub3_beta1 = std::make_shared<fastjet::contrib::Nsubjettiness>(3,
                                                                       fastjet::contrib::OnePass_WTA_KT_Axes(),
                                                                       fastjet::contrib::UnnormalizedMeasure(1.0));
  
  
     m_split12 = std::make_shared<JetSubStructureUtils::KtSplittingScale>(1);
     m_split23 = std::make_shared<JetSubStructureUtils::KtSplittingScale>(2);
  
     m_qw = std::make_shared<JetSubStructureUtils::Qw>();
     
     m_ECF1 = std::make_shared<fastjet::contrib::EnergyCorrelator>(1, 1.0, fastjet::contrib::EnergyCorrelator::pt_R);
     m_ECF2 = std::make_shared<fastjet::contrib::EnergyCorrelator>(2, 1.0, fastjet::contrib::EnergyCorrelator::pt_R);
     m_ECF3 = std::make_shared<fastjet::contrib::EnergyCorrelator>(3, 1.0, fastjet::contrib::EnergyCorrelator::pt_R);
  
   }
   if (m_useAdditionalJSS) {
     
     m_gECF332 = std::make_shared<JetSubStructureUtils::EnergyCorrelatorGeneralized>(3, 3, 2,
                                                                                     JetSubStructureUtils::EnergyCorrelator::pt_R);
     m_gECF461 = std::make_shared<JetSubStructureUtils::EnergyCorrelatorGeneralized>(6, 4, 1,
                                                                                     JetSubStructureUtils::EnergyCorrelator::pt_R);
     m_gECF322 = std::make_shared<JetSubStructureUtils::EnergyCorrelatorGeneralized>(2, 3, 2,
                                                                                     JetSubStructureUtils::EnergyCorrelator::pt_R);
     m_gECF331 = std::make_shared<JetSubStructureUtils::EnergyCorrelatorGeneralized>(3, 3, 1,
                                                                                     JetSubStructureUtils::EnergyCorrelator::pt_R);
     m_gECF422 = std::make_shared<JetSubStructureUtils::EnergyCorrelatorGeneralized>(2, 4, 2,
                                                                                     JetSubStructureUtils::EnergyCorrelator::pt_R);
     m_gECF441 = std::make_shared<JetSubStructureUtils::EnergyCorrelatorGeneralized>(4, 4, 1,
                                                                                     JetSubStructureUtils::EnergyCorrelator::pt_R);
     m_gECF212 = std::make_shared<JetSubStructureUtils::EnergyCorrelatorGeneralized>(1, 2, 2,
                                                                                     JetSubStructureUtils::EnergyCorrelator::pt_R);
     m_gECF321 = std::make_shared<JetSubStructureUtils::EnergyCorrelatorGeneralized>(2, 3, 1,
                                                                                     JetSubStructureUtils::EnergyCorrelator::pt_R);
     m_gECF311 = std::make_shared<JetSubStructureUtils::EnergyCorrelatorGeneralized>(1, 3, 1,
                                                                                     JetSubStructureUtils::EnergyCorrelator::pt_R);
   }
  
  
  
   for (auto treeName : *m_config->systAllTTreeNames()) {
     // only make a new tool if it is the nominal systematic or one that could affect small-r jets (el, mu, jet)
     std::string hash_name("");
  
     if (isUniqueSyst(treeName.second)) {
       if (treeName.second.compare("nominal") != 0) hash_name = treeName.second; // no extra strings for nominal (so all
                                                                                 // other non-unique systs have same name
                                                                                 // as nominal)
  
       m_InputJetContainer = m_InJetContainerBase + hash_name;
       m_OutputJetContainer = m_OutJetContainerBase + hash_name + m_name;
  
       // build a jet re-clustering tool for each case
       std::shared_ptr<JetReclusteringTool> tool(new JetReclusteringTool(treeName.second + m_name));
       top::check(tool->setProperty("InputJetContainer",
                                    m_InputJetContainer), "Failed inputjetcontainer initialize reclustering tool");
       top::check(tool->setProperty("OutputJetContainer",
                                    m_OutputJetContainer), "Failed outputjetcontainer initialize reclustering tool");
       top::check(tool->setProperty("ReclusterRadius",
                                    m_radius), "Failed re-clustering radius initialize reclustering tool");
       top::check(tool->setProperty("RCJetPtMin", m_ptcut * 1e-3), "Failed ptmin [GeV] initialize reclustering tool");
       top::check(tool->setProperty("InputJetPtMin", m_inputJetPtMin * 1e-3), "Failed InputJetPtMin [GeV] initialize reclustering tool");
       top::check(tool->setProperty("TrimPtFrac", m_trim), "Failed pT fraction initialize reclustering tool");
       top::check(tool->setProperty("VariableRMinRadius",
                                    m_minradius), "Failed VarRC min radius initialize reclustering tool");
       top::check(tool->setProperty("VariableRMassScale",
                                    m_massscale), "Failed VarRC mass scale initialize reclustering tool");
       top::check(tool->initialize(), "Failed to initialize reclustering tool");
  
       m_jetReclusteringTool.insert({treeName.first, tool}); // insert the re-clustering tool into map
                                                             // this stores a tool for each systematic based on hash
                                                             // value
  
       // map of container names to access in event saver
       m_inputContainerNames.insert({treeName.first, m_InputJetContainer});
       m_outputContainerNames.insert({treeName.first, m_OutputJetContainer});
  
       // make a re-clustering tool for 'loose' events, too.
       if (m_config->doLooseEvents()) {
         std::shared_ptr<JetReclusteringTool> tool_loose(new JetReclusteringTool(treeName.second + m_name + "_Loose"));
         top::check(tool_loose->setProperty("InputJetContainer",
                                            m_InputJetContainer + "_Loose"),
                    "Failed inputjetcontainer reclustering tool");
         top::check(tool_loose->setProperty("OutputJetContainer",
                                            m_OutputJetContainer + "_Loose"),
                    "Failed outputjetcontainer loose initialize reclustering tool");
         top::check(tool_loose->setProperty("ReclusterRadius",
                                            m_radius), "Failed re-clustering radius initialize reclustering tool");
         top::check(tool_loose->setProperty("RCJetPtMin", m_ptcut * 1e-3), "Failed ptmin [GeV] reclustering tool");
     top::check(tool->setProperty("InputJetPtMin", m_inputJetPtMin * 1e-3), "Failed InputJetPtMin [GeV] initialize reclustering tool");
         top::check(tool_loose->setProperty("TrimPtFrac", m_trim), "Failed pT fraction initialize reclustering tool");
         top::check(tool_loose->setProperty("VariableRMinRadius",
                                            m_minradius), "Failed VarRC min radius initialize reclustering tool");
         top::check(tool_loose->setProperty("VariableRMassScale",
                                            m_massscale), "Failed VarRC mass scale initialize reclustering tool");
         top::check(tool_loose->initialize(), "Failed to initialize reclustering tool");
  
         m_jetReclusteringTool.insert({m_loose_hashValue* treeName.first, tool_loose}); // making up a number as index
                                                                                        // for the loose event
         // map of container names to access in event saver
         m_inputContainerNames.insert({m_loose_hashValue* treeName.first, m_InputJetContainer + "_Loose"});
         m_outputContainerNames.insert({m_loose_hashValue* treeName.first, m_OutputJetContainer + "_Loose"});
       } // end if loose
     } // end if unique syst
     else {
       m_InputJetContainer = m_InJetContainerBase;
       m_OutputJetContainer = m_OutJetContainerBase + m_name;
  
       // map of container names to access in event saver
       if (m_config->doLooseEvents()) {
         m_inputContainerNames.insert({m_loose_hashValue* treeName.first, m_InputJetContainer + "_Loose"});
         m_outputContainerNames.insert({m_loose_hashValue* treeName.first, m_OutputJetContainer + "_Loose"});
       } else {
         m_inputContainerNames.insert({treeName.first, m_InputJetContainer});
         m_outputContainerNames.insert({treeName.first, m_OutputJetContainer});
       }
     }
     
   } // end for loop over systematics
  
   ATH_MSG_INFO(" Re-clustered jets initialized ");
  
   return StatusCode::SUCCESS;
 } // end initialize()

◆ inputContainerName()

std::string RCJet::inputContainerName	(	std::size_t	hash_value,
		bool	isLooseEvent
	)

Definition at line 499 of file RCJetMC.cxx.

                                                                            {
   /* Return the name of the input container */
   std::string this_container_name("");
   if (isLooseEvent) hash_value *= m_loose_hashValue; // loose events have a slightly different hash value to keep track
                                                      // of
  
   m_iterator iter = m_inputContainerNames.find(hash_value);
  
   if (iter != m_inputContainerNames.end()) this_container_name = iter->second;
   else this_container_name = m_InJetContainerBase;
  
   return this_container_name;
 }

◆ 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.

◆ isUniqueSyst()

bool RCJet::isUniqueSyst ( std::string syst_name )

Definition at line 472 of file RCJetMC.cxx.

                                                   {
   /*
      Check if the given systematic (besides nominal) needs a unique container
      Keep this in one function so it easier to update than having multiple checks everywhere.
      Only need jet containers for EGamma, Muon, Jet and Nominal systematics
    */
  
   bool isSmallRJetSys = (syst_name.find(m_jetsyst) != std::string::npos);
  
   // Systematic branches for small-R and large-R jets both contain "JET_" string. We want to recluster only if they
   // correspond to small-R jets.
   if ((syst_name.find("_R10_") != std::string::npos) ||
       (syst_name.find("_CombMass_") != std::string::npos) ||
       (syst_name.find("_LargeR_") != std::string::npos) ||
       (syst_name.find("_MassRes_") != std::string::npos) ||
       (syst_name.find("_SigSF_") != std::string::npos) ||
       (syst_name.find("_BGSF_") != std::string::npos) ) isSmallRJetSys = false;
  
   m_unique_syst = (syst_name.find(m_egamma) == 0 ||
                    syst_name.find(m_muonsyst) == 0 ||
                    isSmallRJetSys ||
                    syst_name.find(m_tracksyst) == 0 ||
                    syst_name.compare("nominal") == 0);
  
   return m_unique_syst;
 }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ 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);
   }

◆ operator=()

RCJet& RCJet::operator= ( const RCJet & rhs )

delete

◆ 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.

◆ passSelection()

bool RCJet::passSelection ( const xAOD::Jet & jet ) const

Definition at line 526 of file RCJetMC.cxx.

                                                   {
   /*
      Check if the re-clustered jet passes selection.
      Right now, this only does something for |eta| because
      pT is taken care of in the re-clustering tool.  When
      small-r jet mass is available (calibrated+uncertainties),
      we can cut on that.
    */
   // [pT] calibrated to >~ 22 GeV (23 Jan 2016)
   if (jet.pt() < m_ptcut) return false;
  
   // [|eta|] calibrated < 2.5
   if (std::abs(jet.eta()) > m_etamax) return false;
  
   // small-r jet mass not calibrated and no uncertainties
  
   return true;
 }

◆ print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

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

Definition at line 131 of file AsgTool.cxx.

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

◆ rcjetContainerName()

std::string RCJet::rcjetContainerName	(	std::size_t	hash_value,
		bool	isLooseEvent
	)

Definition at line 513 of file RCJetMC.cxx.

                                                                            {
   /* Return the name of the rcjet container for a given systematic */
   std::string this_container_name("");
   if (isLooseEvent) hash_value *= m_loose_hashValue; // loose events have a slightly different hash value
  
   m_iterator iter = m_outputContainerNames.find(hash_value);
  
   if (iter != m_outputContainerNames.end()) this_container_name = iter->second;
   else this_container_name = m_OutJetContainerBase;
  
   return this_container_name;
 }

◆ 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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ 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.

◆ 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_config

std::shared_ptr<top::TopConfig> RCJet::m_config

private

Definition at line 93 of file RCJet.h.

◆ 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_ECF1

std::shared_ptr<fastjet::contrib::EnergyCorrelator> RCJet::m_ECF1

private

Definition at line 124 of file RCJet.h.

◆ m_ECF2

std::shared_ptr<fastjet::contrib::EnergyCorrelator> RCJet::m_ECF2

private

Definition at line 125 of file RCJet.h.

◆ m_ECF3

std::shared_ptr<fastjet::contrib::EnergyCorrelator> RCJet::m_ECF3

private

Definition at line 126 of file RCJet.h.

◆ m_egamma

std::string RCJet::m_egamma

private

Definition at line 108 of file RCJet.h.

◆ m_etamax

float RCJet::m_etamax

private

Definition at line 98 of file RCJet.h.

◆ 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_gECF212

std::shared_ptr<JetSubStructureUtils::EnergyCorrelatorGeneralized> RCJet::m_gECF212

private

Definition at line 136 of file RCJet.h.

◆ m_gECF311

std::shared_ptr<JetSubStructureUtils::EnergyCorrelatorGeneralized> RCJet::m_gECF311

private

Definition at line 138 of file RCJet.h.

◆ m_gECF321

std::shared_ptr<JetSubStructureUtils::EnergyCorrelatorGeneralized> RCJet::m_gECF321

private

Definition at line 137 of file RCJet.h.

◆ m_gECF322

std::shared_ptr<JetSubStructureUtils::EnergyCorrelatorGeneralized> RCJet::m_gECF322

private

Definition at line 132 of file RCJet.h.

◆ m_gECF331

std::shared_ptr<JetSubStructureUtils::EnergyCorrelatorGeneralized> RCJet::m_gECF331

private

Definition at line 133 of file RCJet.h.

◆ m_gECF332

std::shared_ptr<JetSubStructureUtils::EnergyCorrelatorGeneralized> RCJet::m_gECF332

private

Definition at line 130 of file RCJet.h.

◆ m_gECF422

std::shared_ptr<JetSubStructureUtils::EnergyCorrelatorGeneralized> RCJet::m_gECF422

private

Definition at line 134 of file RCJet.h.

◆ m_gECF441

std::shared_ptr<JetSubStructureUtils::EnergyCorrelatorGeneralized> RCJet::m_gECF441

private

Definition at line 135 of file RCJet.h.

◆ m_gECF461

std::shared_ptr<JetSubStructureUtils::EnergyCorrelatorGeneralized> RCJet::m_gECF461

private

Definition at line 131 of file RCJet.h.

◆ m_InJetContainerBase

std::string RCJet::m_InJetContainerBase

private

Definition at line 113 of file RCJet.h.

◆ m_inputContainerNames

std::map<std::size_t, std::string> RCJet::m_inputContainerNames

private

Definition at line 143 of file RCJet.h.

◆ m_InputJetContainer

std::string RCJet::m_InputJetContainer

private

Definition at line 115 of file RCJet.h.

◆ m_inputJetEtaMax

float RCJet::m_inputJetEtaMax

private

Definition at line 100 of file RCJet.h.

◆ m_inputJetPtMin

float RCJet::m_inputJetPtMin

private

Definition at line 99 of file RCJet.h.

◆ m_jet_def_rebuild

std::shared_ptr<fastjet::JetDefinition> RCJet::m_jet_def_rebuild

private

Definition at line 120 of file RCJet.h.

◆ m_jetReclusteringTool

std::unordered_map<std::size_t, std::shared_ptr<JetReclusteringTool> > RCJet::m_jetReclusteringTool

private

Definition at line 155 of file RCJet.h.

◆ m_jetsyst

std::string RCJet::m_jetsyst

private

Definition at line 109 of file RCJet.h.

◆ m_loose_hashValue

int RCJet::m_loose_hashValue

private

Definition at line 117 of file RCJet.h.

◆ m_massscale

float RCJet::m_massscale

private

Definition at line 104 of file RCJet.h.

◆ m_minradius

float RCJet::m_minradius

private

Definition at line 103 of file RCJet.h.

◆ m_muonsyst

std::string RCJet::m_muonsyst

private

Definition at line 110 of file RCJet.h.

◆ m_name

std::string RCJet::m_name

private

Definition at line 91 of file RCJet.h.

◆ m_nSub1_beta1

std::shared_ptr<fastjet::contrib::Nsubjettiness> RCJet::m_nSub1_beta1

private

Definition at line 121 of file RCJet.h.

◆ m_nSub2_beta1

std::shared_ptr<fastjet::contrib::Nsubjettiness> RCJet::m_nSub2_beta1

private

Definition at line 122 of file RCJet.h.

◆ m_nSub3_beta1

std::shared_ptr<fastjet::contrib::Nsubjettiness> RCJet::m_nSub3_beta1

private

Definition at line 123 of file RCJet.h.

◆ m_OutJetContainerBase

std::string RCJet::m_OutJetContainerBase

private

Definition at line 114 of file RCJet.h.

◆ m_outputContainerNames

std::map<std::size_t, std::string> RCJet::m_outputContainerNames

private

Definition at line 144 of file RCJet.h.

◆ m_OutputJetContainer

std::string RCJet::m_OutputJetContainer

private

Definition at line 116 of file RCJet.h.

◆ m_ptcut

float RCJet::m_ptcut

private

Definition at line 97 of file RCJet.h.

◆ m_qw

std::shared_ptr<JetSubStructureUtils::Qw> RCJet::m_qw

private

Definition at line 129 of file RCJet.h.

◆ m_radius

float RCJet::m_radius

private

Definition at line 102 of file RCJet.h.

◆ m_split12

std::shared_ptr<JetSubStructureUtils::KtSplittingScale> RCJet::m_split12

private

Definition at line 127 of file RCJet.h.

◆ m_split23

std::shared_ptr<JetSubStructureUtils::KtSplittingScale> RCJet::m_split23

private

Definition at line 128 of file RCJet.h.

◆ m_tracksyst

std::string RCJet::m_tracksyst

private

Definition at line 111 of file RCJet.h.

◆ m_trim

float RCJet::m_trim

private

Definition at line 101 of file RCJet.h.

◆ m_unique_syst

bool RCJet::m_unique_syst

private

Definition at line 140 of file RCJet.h.

◆ m_useAdditionalJSS

bool RCJet::m_useAdditionalJSS

private

Definition at line 106 of file RCJet.h.

◆ m_useJSS

bool RCJet::m_useJSS

private

Definition at line 105 of file RCJet.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_VarRCjets

bool RCJet::m_VarRCjets

private

Definition at line 94 of file RCJet.h.

◆ m_VarRCjets_mass_scale

std::string RCJet::m_VarRCjets_mass_scale

private

Definition at line 96 of file RCJet.h.

◆ m_VarRCjets_rho

std::string RCJet::m_VarRCjets_rho

private

Definition at line 95 of file RCJet.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ mass_scales

std::map<std::string, float> RCJet::mass_scales

private

Initial value:

= {
    {"m_t", 172500.},
    {"m_w", 80385.},
    {"m_z", 91188.},
    {"m_h", 125090.}
  }

Definition at line 146 of file RCJet.h.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ m_iterator

◆ m_tool_iterator

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ RCJet() [1/3]

◆ ~RCJet()

◆ RCJet() [2/3]

◆ RCJet() [3/3]

Member Function Documentation

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ finalize()

◆ getEMTopoClusters()

◆ getKey()

◆ getLCTopoClusters()

◆ getName()

◆ getPflowConstituent()

◆ getProperty()

◆ initialize()

◆ inputContainerName()

◆ inputHandles()

◆ isUniqueSyst()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msg_level_name()

◆ msgLvl()

◆ operator=()

◆ outputHandles()

◆ passSelection()

◆ print()

◆ rcjetContainerName()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_config

◆ m_detStore

◆ m_ECF1

◆ m_ECF2

◆ m_ECF3

◆ m_egamma

◆ m_etamax

◆ m_evtStore

◆ m_gECF212

◆ m_gECF311

◆ m_gECF321

◆ m_gECF322

◆ m_gECF331

◆ m_gECF332

◆ m_gECF422

◆ m_gECF441

◆ m_gECF461

◆ m_InJetContainerBase

◆ m_inputContainerNames

◆ m_InputJetContainer

◆ m_inputJetEtaMax

◆ m_inputJetPtMin

◆ m_jet_def_rebuild