#include <ClassifyAndCalculateHFTool.h>

Inheritance diagram for DerivationFramework::ClassifyAndCalculateHFTool:

Collaboration diagram for DerivationFramework::ClassifyAndCalculateHFTool:

Public Member Functions
	ClassifyAndCalculateHFTool (const std::string &t, const std::string &n, const IInterface *p)
virtual	~ClassifyAndCalculateHFTool ()
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
void	jetPtCut (float a)
void	jetEtaCut (float a)
void	leadingBHadronPtCut (float a)
void	leadingCHadronPtCut (float a)
void	leadingHadronPtRatioCut (float a)
void	flagJets (const xAOD::JetContainer jets, const std::map< const xAOD::Jet , std::vector< xAOD::TruthParticleContainer::const_iterator > > &particleMatch, const std::map< const xAOD::TruthParticle *, DerivationFramework::HadronOriginClassifier::HF_id > &hadronMap, const std::string &hfDecorationName) const
int	computeHFClassification (const xAOD::JetContainer *jets, const std::string &hfDecorationName) const
int	getSimpleClassification (int hfclassif) const
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

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.

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
Gaudi::Property< float >	m_jetPtCut {this, "jetPtCut", 15000., "Cut on the jets pt that are considered to compute the HF classification."}
Gaudi::Property< float >	m_jetEtaCut {this, "jetEtaCut", 2.5, "Cut on the jets eta that are considered to compute the HF classification."}
Gaudi::Property< float >	m_leadingBHadronPtCut {this, "leadingBHadronPtCut", 5000., "Cut on the B-hadrons that are considered to compute the HF classification."}
Gaudi::Property< float >	m_leadingCHadronPtCut {this, "leadingCHadronPtCut", 5000., "Cut on the C-hadrons that are considered to compute the HF classification."}
Gaudi::Property< float >	m_leadingHadronPtRatioCut {this, "leadingHadronPtRatioCut", -1., "Cut on the ratio between the pt of the leading hadron matched to a jet and the jet pt."}
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 39 of file ClassifyAndCalculateHFTool.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

◆ ClassifyAndCalculateHFTool()

DerivationFramework::ClassifyAndCalculateHFTool::ClassifyAndCalculateHFTool	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Definition at line 25 of file ClassifyAndCalculateHFTool.cxx.

25 : AthAlgTool(t,n,p){

26 }

AthAlgTool::AthAlgTool

AthAlgTool()

Default constructor:

◆ ~ClassifyAndCalculateHFTool()

DerivationFramework::ClassifyAndCalculateHFTool::~ClassifyAndCalculateHFTool ( )

virtual

Definition at line 28 of file ClassifyAndCalculateHFTool.cxx.

28 {

29 }

Member Function Documentation

◆ computeHFClassification()

int DerivationFramework::ClassifyAndCalculateHFTool::computeHFClassification	(	const xAOD::JetContainer *	jets,
		const std::string &	hfDecorationName ) const

Definition at line 226 of file ClassifyAndCalculateHFTool.cxx.

                                                                                                                              {
 
    // Create a set of integer variables to save information that is required to compute the HF classifier.:
    //  -b:           Number of jets that has just one B-hadron that passes the cuts.
    //  -B:           Number of jets that has more than one B-hadron and at least one of them passes the cuts.
    //  -c:           Number of jets that has just one C-hadron that passes the cuts (and no B-hadron)
    //  -C:           Number of jets that has more than one C-hadron and at least one of them passes the cuts (and no B-hadron).
    //  -b_prompt:    Number of jets that has just one prompt B-hadron that passes the cuts.      
    //  -B_prompt:    Number of jets that has more than one prompt B-hadron and at least one of them passes the cuts.    
    //  -c_prompt:    Number of jets that has just one prompt C-hadron that passes the cuts (and no B-hadron).     
    //  -C_prompt:    Number of jets that has more than one prompt C-hadron and at least one of them passes the cuts (and no B-hadron).   
    //  -mpifsr_code: HF classifier for events with no prompt additional hadrons, just Multi-Parton Interaction (MPI) and/or Final State Radiation (FSR) hadrons.
    // Note: prompt hadrons in this context are hadrons that do not come from the direct decay of top, W or Higgs but they are not from MPI or FSR.
 
    int b=0, B=0, c=0, C=0;
    int b_prompt=0, B_prompt=0, c_prompt=0, C_prompt=0;
 
    int mpifsr_code=0;
 
    for(const xAOD::Jet* jet : *jets){
 
      // Check if the jet passes the cuts and if it does not, then skip it.
 
      if(jet->p4().Pt() < m_jetPtCut) continue;
      if(std::abs(jet->p4().Eta()) > m_jetEtaCut) continue;
      
      // Get the flavour, the id and the number of hadrons of the considered jet.
 
      int flav  = 0;
      int id    = 0;
      int count = 0;
 
      SG::ConstAccessor<int> hfflavAcc(hfDecorationName + "_flav");
      if(hfflavAcc.isAvailable(*jet)){
        flav=hfflavAcc(*jet);
      }else{
        ATH_MSG_WARNING("variable '" + hfDecorationName + "_flav' not found.");
        continue;
      }
 
      SG::ConstAccessor<int> hfidAcc(hfDecorationName + "_id");
      if(hfidAcc.isAvailable(*jet)){
        id=hfidAcc(*jet);
      }else{
        ATH_MSG_WARNING("variable '" + hfDecorationName + "_id' not found.");
        continue;
      }
 
      SG::ConstAccessor<int> hfcountAcc(hfDecorationName + "_count");
      if(hfcountAcc.isAvailable(*jet)){
        count=hfcountAcc(*jet);
      }else{
        ATH_MSG_WARNING("variable '" + hfDecorationName + "_count' not found.");
        continue;
      }
 
      // Check the flavour and the id of the jet.
 
      if(flav==5 && id < 3){
 
        // In this case, the flavour is 5 and id is less than 3.
        // This means that the jet has at least one B-hadron that is not from direct decay of top, W or Higgs.
        // Hence, the jet is an additional one.
        
        // Check the number of B-hadrons.
 
        if(count > 1){
 
          // In this case, there is more than one B-hadron, so add 1 to B.
 
          B++;
 
        }
        else{
          
          // In this case, there is just one B-hadron, so add 1 to b.
 
          b++;
 
        }
      }
      if(flav==4 && (id==0 || id==-1 || id==-2)){
 
        // In this case, the flavour is 4 and id is 0, -1 or -2.
        // This means that the jet has no B-hadron and at least one C-hadron that is not from direct decay of top, W or Higgs.
        // Hence, the jet is an additional one.
 
        // Check the number of C-hadrons.
 
        if(count > 1){
          
          // In this case, there is more than one C-hadron, so add 1 to C.
 
          C++;
        }
        else{
 
          // In this case, there is just one C-hadron, so add 1 to c.
 
          c++;
        }
      }
 
      // Check the flavour and the id of the jet but considering only prompt particles (id=0).
      
      if(flav==5 && id==0){
 
        // In this case, the flavour is 5 and id is 0.
        // This means that the jet has at least one B-hadron that is not from direct decay of top, W or Higgs neither from MPI or FSR.
        
        // Check the number of B-hadrons.
 
        if(count > 1){
          
          // In this case, there is more than one B-hadron, so add 1 to B_prompt.
 
          B_prompt++;
 
        }
        else{
         
          // In this case, there is jut one B-hadron, so add 1 to b_prompt.
 
          b_prompt++;
 
        }
      }
      if(flav==4 && id==0){
        
        // In this case, the flavour is 4 and id is 0.
        // This means that the jet has no B-hadron and at least one C-hadron that is not from direct decay of top, W or Higgs neither from MPI or FSR.
        
        // Check the number of C-hadrons.
 
        if(count > 1){
 
          // In this case, there is more than one C-hadron, so add 1 to C_prompt.
 
          C_prompt++;
        }
        else{
 
          // In this case, there is just one C-hadron, so add 1 to C_prompt.
 
          c_prompt++;
 
        }
      }
 
      // In the case when there is no prompt hadrons, then the HF classifier is computed with non-promt hadrons.
      // This hadrons come from Multi-Parton Interactions (MPI) and the Final State Radiation (FSR).
      // Compute mpifsr_code which will contain the HF classifier when there is no prompt hadrons.
      // Each jet adds a different quantity to mpifsr_code depending on its flavour and its id.
 
      if(id==1 && flav==5){ // b MPI
        mpifsr_code -= 1000;
      } 
      else if(id==2 && flav==5){ // b FSR
        mpifsr_code -= 100;
      } 
      else if(id==-1 && flav==4){ // c MPI
        mpifsr_code -= 10;
      } 
      else if(id==-2 && flav==4) { // c FSR
        mpifsr_code -= 1;
      }
    }
 
    // Compute the ext_code using the number of additional jets with HF hadrons.
    // Compute the prompt_code using the number of additional jets with propmt HF hadrons.
 
    int ext_code    = 1000*b+100*B+10*c+1*C;
    int prompt_code = 1000*b_prompt+100*B_prompt+10*c_prompt+1*C_prompt;
 
    // Check if there are prompt hadrons and non-prompt hadrons using ext_code and prompt_code.
 
    if(prompt_code==0 && ext_code!=0){
 
      // In this case, there is no prompt hadrons but there are MPI and FSR hadrons.
      // Hence, return mpifsr_code  as a HF classifier, which is equal to ext_code but in negative sign.
 
      return mpifsr_code;
      
    }
 
    // In this case, there are prompt hadrons, so return ext_code as HF classifier.
 
    return ext_code;
 
  }

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

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

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

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

85{ return m_evtStore; }

AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ 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 DerivationFramework::ClassifyAndCalculateHFTool::finalize ( )

overridevirtual

Definition at line 52 of file ClassifyAndCalculateHFTool.cxx.

                                                 {
    return StatusCode::SUCCESS;
  }

◆ flagJets()

void DerivationFramework::ClassifyAndCalculateHFTool::flagJets	(	const xAOD::JetContainer *	jets,
		const std::map< const xAOD::Jet *, std::vector< xAOD::TruthParticleContainer::const_iterator > > &	particleMatch,
		const std::map< const xAOD::TruthParticle *, DerivationFramework::HadronOriginClassifier::HF_id > &	hadronMap,
		const std::string &	hfDecorationName ) const

Definition at line 62 of file ClassifyAndCalculateHFTool.cxx.

                                                                                    {
 
    SG::Decorator< int > decorator_flav(hfDecorationName + "_flav");
    SG::Decorator< int > decorator_id(hfDecorationName + "_id");
    SG::Decorator< int > decorator_count(hfDecorationName + "_count");
 
    for(const xAOD::Jet* jet : *jets){
 
      // Check if the jet passes the cuts and if it does not, then skip it.
 
      if(jet->p4().Pt() < m_jetPtCut || std::abs(jet->p4().Eta()) > m_jetEtaCut) {
    decorator_flav(*jet) = -999;
    decorator_id(*jet) = -999;
    decorator_count(*jet) = -999;
    continue;
      }
 
      // Create a set of integer variables to save the necessary variables for the HF classifier:
      //  -flav:  Flavour of the jet.
      //  -id:    Origin of the most initial hadron of the jet.
      //  -count: Number of associated hadrons of the jet that have the same flavour as the jet.
 
      int flav=0;
      int id=0;
      int count=0;
 
      // Create a set of integer variables to save information that is required to compute the necessary variables for the HF classifier.:
      //  -bcount:    It contains the number of B-hadrons.
      //  -ccount:    It contains the number of C-hadrons.
      //  -bcountcut: It contains the number of B-hadron that pass the cuts.
      //  -ccountcut: It contains the number of C-hadron that pass the cuts.
      //  -bid:       The greatest value of the variable "TopHadronOriginFlag" for B-hadrons (most initial B-hadron).
      //  -cid:       The greatest value of the variable "TopHadronOriginFlag" for C-hadrons (most initial B-hadron).
 
      int bcount=0;
      int ccount=0;
      int bcountcut=0;
      int ccountcut=0;
 
      int bid=0;
      int cid=0;
 
      // Get the hadrons associated with the jet that is being considered.
 
      auto it = particleMatch.find (jet);
      if (it != particleMatch.end()) {
 
        for(xAOD::TruthParticleContainer::const_iterator hf : it->second){
        
          // Create two integer variables:
          //  -hforigin: It will contain the origin of the hadron if it is a HF hadron. Otherwise, it will be 6.
          //  -pdgId:    It will contain the value of the variable "pdgId" of the hadron.
 
          int hforigin = 6;
          int pdgId    = (*hf)->pdgId(); 
 
          // Extract the origin of the hadron.
 
          auto h_it = hadronMap.find(*hf);
          if(h_it!=hadronMap.end()){
            hforigin= static_cast<int>(h_it->second);
          }
 
          // Check if hforigin is 6 and if it is the case, then hadron is not HF and it is skipped.
 
          if(6==hforigin) continue;
 
          // Compute the ratio between the pt of the hadron and the pt of its associated jet.
 
          float ptratio = (*hf)->p4().Pt()/jet->p4().Pt();
 
          // Determine if the hadron is a B-hadron or a C-hadron.
 
          int hftype = 0;
          
          if(MC::isCharmHadron(pdgId)) hftype=4; // B-hadron
          if(MC::isBottomHadron(pdgId)) hftype=5; // C-hadron.
        
          // Check if hftype is 4 or 5.
 
          if(5==hftype){
 
            // In this case, hftype is 5 so the hadron is a B-hadron.
            // Save hforigin in bid if it is greater than the current bid.
 
            if(bid<hforigin)bid=hforigin;
          
            // Add one to bcount and to bcountcut if hadron passes the cuts.
          
            ++bcount;
 
            if((*hf)->p4().Pt()>m_leadingBHadronPtCut && ptratio>m_leadingHadronPtRatioCut){
              ++bcountcut;
            }
          }
          else if(4==hftype){
 
            // In this case, hftype is 4 so the hadron is a C-hadron.
            // Save hforigin in cid if it is greater than the current cid.
 
            if(cid>hforigin)cid=hforigin;
 
            // Add one to ccount and to ccountcut if hadron passes the cuts.
 
            ++ccount;
 
            if((*hf)->p4().Pt()>m_leadingCHadronPtCut && ptratio>m_leadingHadronPtRatioCut){
              ++ccountcut;
            }
          
          }
          else{
          
            // In this case, hftype is not 4 neither 5 so print an error.
 
            ATH_MSG_WARNING("Hadron type '" << hftype << "' is not 4 or 5");
 
          }
        
        }
      }
 
      // Check if there is at least one B-hadron or a C-hadron that passes the cuts.
 
      if(bcountcut){
        
        // In this case, at least one B-hadron passes the cuts.
        // The "flavour" of the jet (flav) is set to 5.
        // As a id of the jet, the greatest value of the variable "TopHadronOriginFlag" for B-hadrons is used (origin of the most initial hadron).
        // The number of B-hadrons is saved in count.
 
        flav=5;
        id=bid;
        count=bcount;
      }
      else if(ccountcut){
        
        // In this case, no B-hadron passes the cuts, but at least one C-hadron does.
        // The "flavour" of the jet (flav) is set to 4.
        // As a id of the jet, the greatest value of the variable "TopHadronOriginFlag" for C-hadrons is used (origin of the most initial hadron).
        // The number of C-hadrons is saved in count.
 
        flav=4;
        id=cid;
        count=ccount;
      }
 
      // Dectorate the jet with the flav, id and count.
      decorator_flav(*jet) = flav;
      decorator_id(*jet) = id;
      decorator_count(*jet) = count;
    }
 
  }

◆ getSimpleClassification()

int DerivationFramework::ClassifyAndCalculateHFTool::getSimpleClassification ( int hfclassif ) const

Definition at line 417 of file ClassifyAndCalculateHFTool.cxx.

                                                                            {
 
    // Check the value of the HF classifier (hfclassif) which is computed with the function computeHFClassification.
 
    if(std::abs(hfclassif)>=100){
 
      // If the absolute value of hfclassif is greater than 100, then there is at least one jet with a B-hadron.
      // In this case, return 1. 
 
      return 1;
 
 
    }
    else if(hfclassif==0){
 
      // If hfclassif is 0, then there is no jet with a B-hadron or a C-hadron.
      // In this case, return 0. 
 
      return 0;
    }
 
    // If the absolute value of hfclassif is lower than 100 and non-zero, then there is no jet with a B-hadron but at least one with a C-hadron.
    // In this case, return -1. 
 
    return -1;
  }

◆ initialize()

StatusCode DerivationFramework::ClassifyAndCalculateHFTool::initialize ( )

overridevirtual

Definition at line 37 of file ClassifyAndCalculateHFTool.cxx.

                                                    {
 
    ATH_MSG_INFO("Initialize");
    
    // Print the string variables.
 
    ATH_MSG_INFO("Cut on the pt of the jets: "           << m_jetPtCut);
    ATH_MSG_INFO("Cut on the eta of the jets: "          << m_jetEtaCut);
    ATH_MSG_INFO("Cut on the pt of the leading B-hadron: " << m_leadingBHadronPtCut);
    ATH_MSG_INFO("Cut on the pt of the leading C-hadron: " << m_leadingCHadronPtCut);
    ATH_MSG_INFO("Cut on the ratio between the pt of the leading hadron and the pt of its associated jet: " << m_leadingHadronPtRatioCut);
 
    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.

◆ jetEtaCut()

void DerivationFramework::ClassifyAndCalculateHFTool::jetEtaCut ( float a )

inline

Definition at line 67 of file ClassifyAndCalculateHFTool.h.

67{m_jetEtaCut=a;}

a

static Double_t a

Definition LArPhysWaveHECTool.cxx:38

◆ jetPtCut()

void DerivationFramework::ClassifyAndCalculateHFTool::jetPtCut ( float a )

inline

Definition at line 66 of file ClassifyAndCalculateHFTool.h.

66{m_jetPtCut=a;}

◆ leadingBHadronPtCut()

void DerivationFramework::ClassifyAndCalculateHFTool::leadingBHadronPtCut ( float a )

inline

Definition at line 68 of file ClassifyAndCalculateHFTool.h.

68{m_leadingBHadronPtCut=a;}

◆ leadingCHadronPtCut()

void DerivationFramework::ClassifyAndCalculateHFTool::leadingCHadronPtCut ( float a )

inline

Definition at line 69 of file ClassifyAndCalculateHFTool.h.

69{m_leadingCHadronPtCut=a;}

◆ leadingHadronPtRatioCut()

void DerivationFramework::ClassifyAndCalculateHFTool::leadingHadronPtRatioCut ( float a )

inline

Definition at line 70 of file ClassifyAndCalculateHFTool.h.

70{m_leadingHadronPtRatioCut=a;}

◆ msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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

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

◆ 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_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_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_jetEtaCut

Gaudi::Property<float> DerivationFramework::ClassifyAndCalculateHFTool::m_jetEtaCut {this, "jetEtaCut", 2.5, "Cut on the jets eta that are considered to compute the HF classification."}

private

Definition at line 100 of file ClassifyAndCalculateHFTool.h.

100{this, "jetEtaCut", 2.5, "Cut on the jets eta that are considered to compute the HF classification."};

◆ m_jetPtCut

Gaudi::Property<float> DerivationFramework::ClassifyAndCalculateHFTool::m_jetPtCut {this, "jetPtCut", 15000., "Cut on the jets pt that are considered to compute the HF classification."}

private

Definition at line 99 of file ClassifyAndCalculateHFTool.h.

99{this, "jetPtCut", 15000., "Cut on the jets pt that are considered to compute the HF classification."};

◆ m_leadingBHadronPtCut

Gaudi::Property<float> DerivationFramework::ClassifyAndCalculateHFTool::m_leadingBHadronPtCut {this, "leadingBHadronPtCut", 5000., "Cut on the B-hadrons that are considered to compute the HF classification."}

private

Definition at line 101 of file ClassifyAndCalculateHFTool.h.

101{this, "leadingBHadronPtCut", 5000., "Cut on the B-hadrons that are considered to compute the HF classification."};

◆ m_leadingCHadronPtCut

Gaudi::Property<float> DerivationFramework::ClassifyAndCalculateHFTool::m_leadingCHadronPtCut {this, "leadingCHadronPtCut", 5000., "Cut on the C-hadrons that are considered to compute the HF classification."}

private

Definition at line 102 of file ClassifyAndCalculateHFTool.h.

102{this, "leadingCHadronPtCut", 5000., "Cut on the C-hadrons that are considered to compute the HF classification."};

◆ m_leadingHadronPtRatioCut

Gaudi::Property<float> DerivationFramework::ClassifyAndCalculateHFTool::m_leadingHadronPtRatioCut {this, "leadingHadronPtRatioCut", -1., "Cut on the ratio between the pt of the leading hadron matched to a jet and the jet pt."}

private

Definition at line 103 of file ClassifyAndCalculateHFTool.h.

103{this, "leadingHadronPtRatioCut", -1., "Cut on the ratio between the pt of the leading hadron matched to a jet and the jet pt."};

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.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

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ ClassifyAndCalculateHFTool()

◆ ~ClassifyAndCalculateHFTool()

Member Function Documentation

◆ computeHFClassification()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ evtStore()

◆ extraDeps_update_handler()

◆ finalize()

◆ flagJets()

◆ getSimpleClassification()

◆ initialize()

◆ inputHandles()

◆ jetEtaCut()

◆ jetPtCut()

◆ leadingBHadronPtCut()

◆ leadingCHadronPtCut()

◆ leadingHadronPtRatioCut()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_detStore

◆ m_evtStore

◆ m_jetEtaCut

◆ m_jetPtCut

◆ m_leadingBHadronPtCut

◆ m_leadingCHadronPtCut

◆ m_leadingHadronPtRatioCut

◆ m_varHandleArraysDeclared

◆ m_vhka