top::ScaleFactorCalculator Class Reference

#include <ScaleFactorCalculator.h>

Inheritance diagram for top::ScaleFactorCalculator:

Collaboration diagram for top::ScaleFactorCalculator:

Public Member Functions
	ScaleFactorCalculator (const std::string &name)
virtual	~ScaleFactorCalculator ()
	ScaleFactorCalculator (const ScaleFactorCalculator &rhs)=delete
	ScaleFactorCalculator (ScaleFactorCalculator &&rhs)=delete
ScaleFactorCalculator &	operator= (const ScaleFactorCalculator &rhs)=delete
StatusCode	initialize ()
	Dummy implementation of the initialisation function. More...
StatusCode	initialize_nominal_MC_weight ()
StatusCode	execute ()
StatusCode	executePileup ()
float	pileupWeight () const
float	mcEventWeight () const
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 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::shared_ptr< top::TopConfig >	m_config
std::unique_ptr< top::PhotonScaleFactorCalculator >	m_photonSF
std::unique_ptr< top::ElectronScaleFactorCalculator >	m_electronSF
std::unique_ptr< top::FwdElectronScaleFactorCalculator >	m_fwdElectronSF
std::unique_ptr< top::MuonScaleFactorCalculator >	m_muonSF
std::unique_ptr< top::TauScaleFactorCalculator >	m_tauSF
std::unique_ptr< top::JetScaleFactorCalculator >	m_jetSF
std::unique_ptr< top::BTagScaleFactorCalculator >	m_btagSF
std::unique_ptr< top::PileupScaleFactorCalculator >	m_pileupSF
ToolHandle< PMGTools::PMGSherpa22VJetsWeightTool >	m_sherpa_22_reweight_tool
std::unique_ptr< top::GlobalLeptonTriggerCalculator >	m_globalLeptonTriggerSF
ToolHandle< PMGTools::IPMGTruthWeightTool >	m_pmg_truth_weight_tool
std::string	m_nominal_weight_name
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 44 of file ScaleFactorCalculator.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

ScaleFactorCalculator() [1/3]

top::ScaleFactorCalculator::ScaleFactorCalculator ( const std::string &  name )

explicit

Definition at line 17 of file ScaleFactorCalculator.cxx.

                                                                    :
    asg::AsgTool(name),
    m_config(nullptr),
 
    m_photonSF(nullptr),
    m_electronSF(nullptr),
    m_fwdElectronSF(nullptr),
    m_muonSF(nullptr),
    m_tauSF(nullptr),
    m_jetSF(nullptr),
    m_btagSF(nullptr),
    m_pileupSF(nullptr),
    m_sherpa_22_reweight_tool("PMGSherpa22VJetsWeightTool"),
    m_globalLeptonTriggerSF(nullptr),
    m_pmg_truth_weight_tool("PMGTruthWeightTool"),
    m_nominal_weight_name("") {
    declareProperty("config", m_config);
  }

~ScaleFactorCalculator()

virtual top::ScaleFactorCalculator::~ScaleFactorCalculator ( )

inlinevirtual

Definition at line 47 of file ScaleFactorCalculator.h.

{}

ScaleFactorCalculator() [2/3]

top::ScaleFactorCalculator::ScaleFactorCalculator ( const ScaleFactorCalculator &  rhs )

delete

ScaleFactorCalculator() [3/3]

top::ScaleFactorCalculator::ScaleFactorCalculator ( ScaleFactorCalculator &&  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.

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

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

{ return m_evtStore; }

execute()

StatusCode top::ScaleFactorCalculator::execute

(

)

Definition at line 182 of file ScaleFactorCalculator.cxx.

                                            {
    if (m_config->isMC()) {
      if (m_config->usePhotons()) top::check(m_photonSF->execute(), "Failed to execute photon SF");
      if (m_config->useElectrons()) top::check(m_electronSF->execute(), "Failed to execute electron SF");
      if (m_config->useFwdElectrons()) top::check(m_fwdElectronSF->execute(), "Failed to execute fwd electron SF");
      if (m_config->useMuons() &&
          !m_config->isTruthDxAOD()) top::check(m_muonSF->execute(), "Failed to execute muon SF");
      if (m_config->useTaus()) top::check(m_tauSF->execute(), "Failed to execute tau SF");
      if (m_config->useJets()) top::check(m_jetSF->execute(), "Failed to execute jet SF");
      if (m_config->useJets()) {
        top::check(m_btagSF->execute(), "Failed to execute btag SF");
      }
      // Add Sherpa 22 weights directly here, if we get more
      // PMG tools for reweighting then we should consider making
      // a m_PMG_SF class, as with other corrections
      if (m_config->isSherpa22Vjets()) {
        const xAOD::EventInfo* eventInfo(nullptr);
        top::check(evtStore()->retrieve(eventInfo, m_config->sgKeyEventInfo()), "Failed to retrieve EventInfo");
        double sherpa_weight = m_sherpa_22_reweight_tool->getWeight();
        eventInfo->auxdecor<double>("Sherpa22VJetsWeight") = sherpa_weight;
      }
      if ((m_config->useElectrons() || m_config->useMuons()) && m_config->useGlobalTrigger()) {
        top::check(m_globalLeptonTriggerSF->execute(), "Failed to exectute global trigger SF");
      }
    }
    return StatusCode::SUCCESS;
  }

executePileup()

StatusCode top::ScaleFactorCalculator::executePileup

(

)

Definition at line 210 of file ScaleFactorCalculator.cxx.

                                                  {
    if (m_config->doPileupReweighting()) top::check(m_pileupSF->execute(), "Failed to execute pileup SF");
    return StatusCode::SUCCESS;
  }

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

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.

initialize()

StatusCode top::ScaleFactorCalculator::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 36 of file ScaleFactorCalculator.cxx.

                                               {
    ATH_MSG_INFO(" top::ScaleFactorCalculator initialize");
 
    m_photonSF = std::make_unique<top::PhotonScaleFactorCalculator>("top::PhotonScaleFactorCalculator");
    m_electronSF = std::make_unique<top::ElectronScaleFactorCalculator>("top::ElectronScaleFactorCalculator");
    m_fwdElectronSF = std::make_unique<top::FwdElectronScaleFactorCalculator>("top::FwdElectronScaleFactorCalculator");
    m_muonSF = std::make_unique<top::MuonScaleFactorCalculator>("top::MuonScaleFactorCalculator");
    m_tauSF = std::make_unique<top::TauScaleFactorCalculator>("top::TauScaleFactorCalculator");
    m_jetSF = std::make_unique<top::JetScaleFactorCalculator>("top::JetScaleFactorCalculator");
    m_btagSF = std::make_unique<top::BTagScaleFactorCalculator>("top::BTagScaleFactorCalculator");
    m_pileupSF = std::make_unique<top::PileupScaleFactorCalculator>("top::PileupScaleFactorCalculator");
    m_globalLeptonTriggerSF =
      std::make_unique<top::GlobalLeptonTriggerCalculator>("top::GlobalLeptonTriggerCalculator");
 
    if (m_config->isMC()) {
      if (m_config->usePhotons()) {
        top::check(m_photonSF->setProperty("config", m_config), "Failed to setProperty");
        top::check(m_photonSF->initialize(), "Failed to initialize");
      }
 
      if (m_config->useElectrons()) {
        top::check(m_electronSF->setProperty("config", m_config), "Failed to setProperty");
        top::check(m_electronSF->initialize(), "Failed to initialize");
      }
 
      if (m_config->useFwdElectrons()) {
        top::check(m_fwdElectronSF->setProperty("config", m_config), "Failed to setProperty");
        top::check(m_fwdElectronSF->initialize(), "Failed to initialize");
      }
 
      if (m_config->useMuons() && !m_config->isTruthDxAOD()) {
        top::check(m_muonSF->setProperty("config", m_config), "Failed to setProperty");
        top::check(m_muonSF->initialize(), "Failed to initialize");
      }
 
      if (m_config->useTaus()) {
        top::check(m_tauSF->setProperty("config", m_config), "Failed to setProperty");
        top::check(m_tauSF->initialize(), "Failed to initialize");
      }
 
      if (m_config->useJets()) {
        top::check(m_jetSF->setProperty("config", m_config), "Failed to setProperty");
        top::check(m_jetSF->initialize(), "Failed to initialize");
 
        top::check(m_btagSF->setProperty("config", m_config), "Failed to setProperty");
        top::check(m_btagSF->initialize(), "Failed to initialize");
      }
 
      if (m_config->isSherpa22Vjets()) top::check(m_sherpa_22_reweight_tool.retrieve(),
                                                  "Failed to retrieve PMGSherpa22VJetsWeightTool");
 
      if ((m_config->useElectrons() || m_config->useMuons()) && m_config->useGlobalTrigger()) {
        top::check(m_globalLeptonTriggerSF->setProperty("config", m_config), "Failed to setProperty");
        top::check(m_globalLeptonTriggerSF->initialize(), "Failed to initalize");
      }
 
      top::check(initialize_nominal_MC_weight(), "Failed to initialize nominal MC weight in SF calculator");
    }
 
    if (m_config->doPileupReweighting()) {
      top::check(m_pileupSF->setProperty("config", m_config), "Failed to add config to pileup SF calculator");
      top::check(m_pileupSF->initialize(), "Failed to initialize pileup SF calculator");
    }
 
    return StatusCode::SUCCESS;
  }

initialize_nominal_MC_weight()

StatusCode top::ScaleFactorCalculator::initialize_nominal_MC_weight

(

)

– Start using the PMG tool to get the nominal event weights –///

Definition at line 103 of file ScaleFactorCalculator.cxx.

                                                                 {
    // check if user force-requested to use plain MC weights vector index
    // in that case ignore all the additional checks if metadata broken
    // as well as the method to determine nominal weight by name
    if (m_config->forceNominalWeightFallbackIndex()) {
      ATH_MSG_WARNING("ForceNominalWeightFallbackIndex option was set to true."
          << "\nWill use weight with index: " << m_config->nominalWeightIndex()
          << " instead of determining it from metadata!");
      return StatusCode::SUCCESS;
    }
    // in case PMGTruthWeightTool init fails, e.g. due to broken metadata
    // leave the possibility to force nominal weight above
    if (!m_pmg_truth_weight_tool.retrieve()) {
      ATH_MSG_ERROR("\nPMGTruthWeightTool instance could not be retrieved."
                    << "\nWe cannot determine if this sample has multiple weights, "
                    << "nor which one is nominal. Please specify the index of "
                    << "nominal MC weight via config option NominalWeightFallbackIndex, "
                    << " and set ForceNominalWeightFallbackIndex to true.");
      return StatusCode::FAILURE;
    }
 
    // PMGTruthWeightTool was initialized succesfully, let's see if we have weights
    const std::vector<std::string>& pmg_weight_names = m_pmg_truth_weight_tool->getWeightNames();
 
    // scenario 1 -- sample has only one weight
    if (pmg_weight_names.size() == 1) {
      ATH_MSG_INFO("PMGTruthWeightTool reports single weight in sample, assuming nominal weight index = 0");
        m_config->setNominalWeightIndex(0);
      return StatusCode::SUCCESS;
    }
 
    // scenario 2 -- sample has multiple weights, try to find the nominal one
    // one should not blindly assume that 0th weight is nominal
    // here we try to find the first weight name from the NominalWeightNames config option,
    // which that matches any MC weight in the sample
    const std::vector<std::string> &nominal_weight_names = m_config->nominalWeightNames();
    bool found_match = false;
    std::vector<std::string> multiple_matches;
    for (const std::string& weight_name : nominal_weight_names) {
      // Check whether this weight name does exist
      if (m_pmg_truth_weight_tool->hasWeight(weight_name)) {
        // pick only the first match, but check if there are multiple matches -- that is a problem
        if (!found_match)
          m_nominal_weight_name = weight_name;
        found_match = true;
        multiple_matches.push_back(weight_name);
      }
    }
    // we have to find the index, because PMGTruthWeightTool has no method to give us the index
    auto weight_index = std::find(pmg_weight_names.begin(), pmg_weight_names.end(), m_nominal_weight_name);
    m_config->setNominalWeightName(m_nominal_weight_name);
    m_config->setNominalWeightIndex(weight_index - pmg_weight_names.begin());
    if (multiple_matches.size() > 1) {
      std::stringstream s_multiple_matches;
      for (const std::string &wname : multiple_matches)
        s_multiple_matches << "\"" << wname << "\"\n";
      ATH_MSG_WARNING("Multiple NominalWeightNames match for this MC sample!\n" + s_multiple_matches.str()
          + "\nThe one we will use is \"" + m_nominal_weight_name + "\". Check whether this is really correct!");
    }
    if (!found_match) {
      // if we get here, it means we are missing the correct name of the nominal weight
      // user has to find it in the sample meta-data and add it to AT config file
      ATH_MSG_ERROR("No MC weight matches any of the names specified by NominalWeightNames "
          "option\nThis may indicate a sample with non-standard nominal MC weight name!");
      std::stringstream weights_log;
      for (size_t w_indx=0; w_indx < pmg_weight_names.size(); ++w_indx) {
        weights_log << "Weight " << w_indx << ": \"" << pmg_weight_names.at(w_indx) << "\"\n";
      }
      ATH_MSG_ERROR("The following weight names are available based on sample metadata:\n" + weights_log.str()
          + "\nAdd the correct nominal weight name from this list into the NominalWeightNames option in your config file.");
      return StatusCode::FAILURE;
    }
 
    ATH_MSG_INFO("Using the following MC weight as nominal: \"" + m_config->nominalWeightName()
        << "\", index: " << m_config->nominalWeightIndex());
    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.

mcEventWeight()

float top::ScaleFactorCalculator::mcEventWeight

(

)

const

Definition at line 231 of file ScaleFactorCalculator.cxx.

                                                   {
    float sf(1.);
 
    if (!m_config->isMC()) {
      return sf;
    }
    // Decorate the updated nominal weight if appropriate - note this is called early in top-xaod
    const xAOD::EventInfo* eventInfo(nullptr);
    top::check(evtStore()->retrieve(eventInfo, m_config->sgKeyEventInfo()), "Failed to retrieve EventInfo");
 
    // Check if the decoration is already present, and return it if so
    if (eventInfo->isAvailable<float>("AnalysisTop_eventWeight")) return eventInfo->auxdataConst<float>(
        "AnalysisTop_eventWeight");
 
    try {
      sf = eventInfo->mcEventWeights().at(m_config->nominalWeightIndex());
      eventInfo->auxdecor<float>("AnalysisTop_eventWeight") = sf;
    } catch (std::out_of_range &e) {
      ATH_MSG_ERROR("MC weight specified by index " << m_config->nominalWeightIndex()
          << " does not exist: ");
      throw;
    }
    return sf;
  }

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

ScaleFactorCalculator& top::ScaleFactorCalculator::operator= ( const ScaleFactorCalculator &  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.

pileupWeight()

float top::ScaleFactorCalculator::pileupWeight

(

)

const

Definition at line 215 of file ScaleFactorCalculator.cxx.

                                                  {
    float sf(1.);
 
    if (!m_config->isMC()) {
      return sf;
    }
 
    const xAOD::EventInfo* eventInfo(nullptr);
    top::check(evtStore()->retrieve(eventInfo, m_config->sgKeyEventInfo()),
               "Failed to retrieve EventInfo");
 
    if (eventInfo->isAvailable<float>("PileupWeight")) sf = eventInfo->auxdataConst<float>("PileupWeight");
 
    return sf;
  }

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

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_btagSF

std::unique_ptr<top::BTagScaleFactorCalculator> top::ScaleFactorCalculator::m_btagSF

private

Definition at line 69 of file ScaleFactorCalculator.h.

m_config

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

private

Definition at line 61 of file ScaleFactorCalculator.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_electronSF

std::unique_ptr<top::ElectronScaleFactorCalculator> top::ScaleFactorCalculator::m_electronSF

private

Definition at line 64 of file ScaleFactorCalculator.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_fwdElectronSF

std::unique_ptr<top::FwdElectronScaleFactorCalculator> top::ScaleFactorCalculator::m_fwdElectronSF

private

Definition at line 65 of file ScaleFactorCalculator.h.

m_globalLeptonTriggerSF

std::unique_ptr<top::GlobalLeptonTriggerCalculator> top::ScaleFactorCalculator::m_globalLeptonTriggerSF

private

Definition at line 72 of file ScaleFactorCalculator.h.

m_jetSF

std::unique_ptr<top::JetScaleFactorCalculator> top::ScaleFactorCalculator::m_jetSF

private

Definition at line 68 of file ScaleFactorCalculator.h.

m_muonSF

std::unique_ptr<top::MuonScaleFactorCalculator> top::ScaleFactorCalculator::m_muonSF

private

Definition at line 66 of file ScaleFactorCalculator.h.

m_nominal_weight_name

std::string top::ScaleFactorCalculator::m_nominal_weight_name

private

Definition at line 75 of file ScaleFactorCalculator.h.

m_photonSF

std::unique_ptr<top::PhotonScaleFactorCalculator> top::ScaleFactorCalculator::m_photonSF

private

Definition at line 63 of file ScaleFactorCalculator.h.

m_pileupSF

std::unique_ptr<top::PileupScaleFactorCalculator> top::ScaleFactorCalculator::m_pileupSF

private

Definition at line 70 of file ScaleFactorCalculator.h.

m_pmg_truth_weight_tool

ToolHandle<PMGTools::IPMGTruthWeightTool> top::ScaleFactorCalculator::m_pmg_truth_weight_tool

private

Definition at line 73 of file ScaleFactorCalculator.h.

m_sherpa_22_reweight_tool

ToolHandle<PMGTools::PMGSherpa22VJetsWeightTool> top::ScaleFactorCalculator::m_sherpa_22_reweight_tool

private

Definition at line 71 of file ScaleFactorCalculator.h.

m_tauSF

std::unique_ptr<top::TauScaleFactorCalculator> top::ScaleFactorCalculator::m_tauSF

private

Definition at line 67 of file ScaleFactorCalculator.h.

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:

• ScaleFactorCalculator.h
• ScaleFactorCalculator.cxx