Prompt::DecoratePromptLeptonImproved Class Reference

#include <DecoratePromptLeptonImproved.h>

Inheritance diagram for Prompt::DecoratePromptLeptonImproved:

Public Member Functions
	DecoratePromptLeptonImproved (const std::string &name, ISvcLocator *pSvcLocator)
virtual StatusCode	initialize () override
virtual StatusCode	execute () override
virtual StatusCode	finalize () override
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
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	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
using	decoratorFloatH_t = SG::WriteDecorHandle<xAOD::IParticleContainer, float>
using	decoratorShortH_t = SG::WriteDecorHandle<xAOD::IParticleContainer, short>
using	AccessFloat = SG::ConstAccessor<float>
using	AccessVertex = SG::ConstAccessor<std::vector<ElementLink<xAOD::VertexContainer> > >
using	floatAccessorMap = std::map<Prompt::Def::Var, AccessFloat>
using	DecorMap_t = std::unordered_map<Def::Var, size_t>
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	initializeTMVAReader ()
StatusCode	initializeDecorators ()
void	initializeConstAccessors ()
void	decorateElec (const xAOD::Electron &electron, const xAOD::JetContainer &trackJets, const xAOD::CaloClusterContainer &clusters, const xAOD::Vertex *primaryVertex, std::vector< decoratorFloatH_t > &floatDecors, std::vector< decoratorShortH_t > &shortDecors)
void	decorateMuon (const xAOD::Muon &muon, const xAOD::JetContainer &trackJets, const xAOD::Vertex *primaryVertex, std::vector< decoratorFloatH_t > &floatDecors, std::vector< decoratorShortH_t > &shortDecors)
void	getMutualVariables (const xAOD::IParticle &particle, const xAOD::Jet &track_jet, const xAOD::TrackParticle *track, Prompt::VarHolder &vars) const
void	getMuonAnpVariables (const xAOD::Muon &muon, Prompt::VarHolder &vars, const xAOD::Vertex *primaryVertex) const
void	getElectronAnpVariables (const xAOD::Electron &elec, const xAOD::CaloClusterContainer &clusters, Prompt::VarHolder &vars, const xAOD::Vertex *primaryVertex)
float	accessIsolation (const SG::ConstAccessor< float > &isoAccessor, const xAOD::IParticle &particle) const
void	addVarsToTMVA (Prompt::VarHolder &vars)
void	fillVarDefault (Prompt::VarHolder &vars) const
void	decorateAuxLepton (const xAOD::IParticle &particle, Prompt::VarHolder &vars, std::vector< decoratorFloatH_t > &floatDecors, std::vector< decoratorShortH_t > &shortDecors) const
template<class T>
std::pair< double, const xAOD::Jet * >	findTrackJet (const T &part, const xAOD::JetContainer &jets)
double	getVertexLongitudinalNormDist (const xAOD::IParticle &lepton, const xAOD::Vertex *secondaryVertex, const xAOD::Vertex *primaryVertex) const
double	getVertexCosThetaWithLepDir (const xAOD::IParticle &lepton, const xAOD::Vertex *secondaryVertex, const xAOD::Vertex *primaryVertex) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
Gaudi::Property< std::string >	m_leptonsName
Gaudi::Property< std::string >	m_configFileVersion {this, "ConfigFileVersion", "", "BDT weight file version"}
Gaudi::Property< std::string >	m_configPathOverride {this, "ConfigPathOverride", "", "Path of the local BDT weight file you want to study/test"}
Gaudi::Property< std::string >	m_inputVarDecoratePrefix {this, "InputVarDecoratePrefix", "", "Prefix of the variables that will be decorated into the lepton"}
Gaudi::Property< std::string >	m_BDTName {this, "BDTName", "", "BDT name"}
Gaudi::Property< std::string >	m_methodTitleMVA {this, "MethodTitleMVA", "BDT", "Help to config the path of the BDT xml file"}
Gaudi::Property< std::vector< std::string > >	m_accessorRNNVars {this, "accessorRNNVars", {}, "Name of the RNN accessor of the lepton"}
Gaudi::Property< std::vector< std::string > >	m_stringIntVars {this, "stringIntVars", {}, "Vector of the BDT int variables' names and they will be decorated into lepton if not in the veto list"}
Gaudi::Property< std::vector< std::string > >	m_stringFloatVars {this, "stringFloatVars", {}, "Vector of the BDT float variables' names and they will be decorated into lepton if not in the veto list"}
Gaudi::Property< std::vector< std::string > >	m_extraDecoratorFloatVars {this, "extraDecoratorFloatVars", {}, "Extra float variables' names you want to compute and decorate into the lepton"}
Gaudi::Property< std::vector< std::string > >	m_extraDecoratorShortVars {this, "extraDecoratorShortVars", {}, "Extra short variables' names you want to compute and decorate into the lepton"}
Gaudi::Property< std::vector< std::string > >	m_vetoDecoratorFloatVars {this, "vetoDecoratorFloatVars", {}, "Vector of the float variables' names you do not want to save"}
Gaudi::Property< std::vector< std::string > >	m_vetoDecoratorShortVars {this, "vetoDecoratorShortVars", {}, "Vector of the short variables' names you do not want to save"}
Gaudi::Property< std::vector< double > >	m_leptonPtBinsVector {this, "leptonPtBinsVector", {}, "pT bin edges that are used for MVABin calculation"}
Gaudi::Property< bool >	m_printTime {this, "PrintTime", false, "Whether to print current time"}
Gaudi::Property< std::string >	m_vertexLinkName {this, "VertexLinkName", "", "ElementLink name of the secondary vertices"}
Gaudi::Property< double >	m_vertexMinChiSquaredProb {this, "VertexMinChiSquaredProb", 0.03, "Vertex chi2 cut"}
Gaudi::Property< double >	m_vertexMinThetaBarrElec {this, "VertexMinThetaBarrElec", 0.002, "Vertex theta between lepton and the direction of sv-pv cut for barrel electrons"}
Gaudi::Property< double >	m_vertexMinThetaEcapElec {this, "VertexMinThetaEcapElec", 0.001, "Vertex theta between lepton and the direction of sv-pv cut for central electrons"}
Gaudi::Property< double >	m_vertexBarrEcapAbsEtaAt {this, "VertexBarrEcapAbsEtaAt", 1.37, "Relate to the vertex cut above, define the barrel and central electrons by abs(eta)"}
Gaudi::Property< double >	m_elecMinCalErelConeSize {this, "ElecMinCalErelConeSize", 0.15, "Cut of the cluster for calculating the core energy of the lepton"}
Gaudi::Property< double >	m_maxLepTrackJetDR {this, "maxLepTrackJetDR", 0.4, "Maximum distance between lepton and track jet for track jet matching"}
SG::ReadHandleKey< xAOD::JetContainer >	m_trackJetsKey
SG::ReadHandleKey< xAOD::VertexContainer >	m_primaryVertexKey
SG::ReadHandleKey< xAOD::CaloClusterContainer >	m_clusterContainerKey
SG::ReadHandleKey< xAOD::ElectronContainer >	m_electronsKey
SG::ReadHandleKey< xAOD::MuonContainer >	m_muonsKey
std::vector< Prompt::Def::Var >	m_intVars
std::vector< Prompt::Def::Var >	m_floatVars
std::vector< Prompt::Def::Var >	m_allVars
std::unique_ptr< Prompt::VarHolder >	m_vars
Prompt::Def::Var	m_BDTVarKey
std::unique_ptr< TMVA::Reader >	m_TMVAReader
std::vector< Float_t >	m_varTMVA
std::optional< AccessVertex >	m_accessDeepSecondaryVertex
floatAccessorMap	m_accessRNNMap
std::unique_ptr< TH1D >	m_leptonPtBinHist
TStopwatch	m_timerAll
TStopwatch	m_timerExec
TStopwatch	m_timerMuon
TStopwatch	m_timerElec
SG::WriteDecorHandleKeyArray< xAOD::IParticleContainer >	m_floatDecorHandleKeys { this, "FloatDecorHandleKeys", {} }
SG::WriteDecorHandleKeyArray< xAOD::IParticleContainer >	m_shortDecorHandleKeys { this, "ShortDecorHandleKeys", {} }
DecorMap_t	m_floatDecorMap
DecorMap_t	m_shortDecorMap
DataObjIDColl	m_extendedExtraObjects
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 51 of file DecoratePromptLeptonImproved.h.

Member Typedef Documentation

AccessFloat

using Prompt::DecoratePromptLeptonImproved::AccessFloat = SG::ConstAccessor<float>

private

Definition at line 142 of file DecoratePromptLeptonImproved.h.

AccessVertex

using Prompt::DecoratePromptLeptonImproved::AccessVertex = SG::ConstAccessor<std::vector<ElementLink<xAOD::VertexContainer> > >

private

Definition at line 143 of file DecoratePromptLeptonImproved.h.

decoratorFloatH_t

using Prompt::DecoratePromptLeptonImproved::decoratorFloatH_t = SG::WriteDecorHandle<xAOD::IParticleContainer, float>

private

Definition at line 73 of file DecoratePromptLeptonImproved.h.

decoratorShortH_t

using Prompt::DecoratePromptLeptonImproved::decoratorShortH_t = SG::WriteDecorHandle<xAOD::IParticleContainer, short>

private

Definition at line 74 of file DecoratePromptLeptonImproved.h.

DecorMap_t

using Prompt::DecoratePromptLeptonImproved::DecorMap_t = std::unordered_map<Def::Var, size_t>

private

Definition at line 228 of file DecoratePromptLeptonImproved.h.

floatAccessorMap

using Prompt::DecoratePromptLeptonImproved::floatAccessorMap = std::map<Prompt::Def::Var, AccessFloat>

private

Definition at line 145 of file DecoratePromptLeptonImproved.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

DecoratePromptLeptonImproved()

Prompt::DecoratePromptLeptonImproved::DecoratePromptLeptonImproved	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 38 of file DecoratePromptLeptonImproved.cxx.

                                                                                                               :
  AthAlgorithm(name, pSvcLocator),
  m_BDTVarKey(Def::NONE)
{}

Member Function Documentation

accessIsolation()

float Prompt::DecoratePromptLeptonImproved::accessIsolation ( const SG::ConstAccessor< float > & isoAccessor, const xAOD::IParticle & particle ) const

private

Definition at line 741 of file DecoratePromptLeptonImproved.cxx.

        {
  double isolation = -99., isolationrel = -99.;
 
  if(isoAccessor.isAvailable(particle)) {
    isolation = isoAccessor(particle);
  }
  else {
    ATH_MSG_WARNING("Lepton isolation not found in auxiliary store");
  }
 
  if(particle.pt() > 0.0) {
    isolationrel = isolation / particle.pt();
  }
 
  return isolationrel;
}

addVarsToTMVA()

void Prompt::DecoratePromptLeptonImproved::addVarsToTMVA ( Prompt::VarHolder & vars )

private

Definition at line 762 of file DecoratePromptLeptonImproved.cxx.

{
  //
  // Add variables to TMVA reader
  //
  for(unsigned i = 0; i < m_allVars.size(); ++i) {  
    m_varTMVA[i] = 0.0;
 
    if(!vars.getVar(m_allVars.at(i), m_varTMVA[i])) {
      ATH_MSG_WARNING("Missing input variable: " << m_vars->asStr(m_allVars.at(i)));   
    }
  }
 
  //
  // Decorate lepton with classifier response, if goodJet
  //
  float bdt_weight = m_TMVAReader->EvaluateMVA(m_methodTitleMVA.toString());
 
  if(m_BDTVarKey != Def::NONE) {
    vars.addVar(m_BDTVarKey, bdt_weight);
  }
  else {
    ATH_MSG_WARNING("addVarsToTMVA - invalid Def::Var key for " << m_BDTName);
  }
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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());
  }

decorateAuxLepton()

void Prompt::DecoratePromptLeptonImproved::decorateAuxLepton ( const xAOD::IParticle & particle, Prompt::VarHolder & vars, std::vector< decoratorFloatH_t > & floatDecors, std::vector< decoratorShortH_t > & shortDecors ) const

private

Definition at line 804 of file DecoratePromptLeptonImproved.cxx.

{
  //
  // Decorate lepton with input short variables
  //
  for(const DecorMap_t::value_type &dec: m_shortDecorMap) {
    double val = 0.0;
 
    if(vars.getVar(dec.first, val)) {
      shortDecors.at(dec.second)(particle) = static_cast<short>(val);
 
      ATH_MSG_DEBUG("Short variable: " << vars.asStr(dec.first) << " = " << val);
    }
    else {
      ATH_MSG_WARNING("Short variable " << vars.asStr(dec.first) << " not decorated to lepton");
    }
  }
 
  //
  // Decorate lepton with input float variables
  //
  for(const DecorMap_t::value_type &dec: m_floatDecorMap) {
    double val = 0.0;
 
    if(vars.getVar(dec.first, val)) {
      floatDecors.at(dec.second)(particle) = val;
 
      ATH_MSG_DEBUG("Float variable: " << vars.asStr(dec.first) << " = " << val);
    }
    else {
      ATH_MSG_WARNING("Float variable " << vars.asStr(dec.first) << " not decorated to lepton");
    }
  }
}

decorateElec()

void Prompt::DecoratePromptLeptonImproved::decorateElec ( const xAOD::Electron & electron, const xAOD::JetContainer & trackJets, const xAOD::CaloClusterContainer & clusters, const xAOD::Vertex * primaryVertex, std::vector< decoratorFloatH_t > & floatDecors, std::vector< decoratorShortH_t > & shortDecors )

private

Definition at line 404 of file DecoratePromptLeptonImproved.cxx.

{
  //
  // Find nearest track jet to electron
  //
  TimerScopeHelper timer(m_timerElec);
 
  Prompt::VarHolder vars;
 
  std::pair<double, const xAOD::Jet*> match = findTrackJet(electron, trackJets);
 
  if(match.second) {
    //
    // Get muon calorimeter energy variable, RNN and secondary vertex variables
    //
    getElectronAnpVariables(electron, clusters, vars, primaryVertex);
 
    //
    // Get mutual variables, passing track as argument
    //
    getMutualVariables(electron, *match.second, electron.trackParticle(), vars);
 
    //
    // Pass variables to TMVA
    //
    addVarsToTMVA(vars);
  }
  else {
    //
    // Decorate electron with default values
    //
    fillVarDefault(vars);
 
    ATH_MSG_DEBUG("No track jet found near to electron");
  }
 
  //
  // Decorate electron with input vars and BDT weight
  //
  decorateAuxLepton(electron, vars, floatDecors, shortDecors);
}

decorateMuon()

void Prompt::DecoratePromptLeptonImproved::decorateMuon ( const xAOD::Muon & muon, const xAOD::JetContainer & trackJets, const xAOD::Vertex * primaryVertex, std::vector< decoratorFloatH_t > & floatDecors, std::vector< decoratorShortH_t > & shortDecors )

private

Definition at line 455 of file DecoratePromptLeptonImproved.cxx.

{
  //
  // Find nearest track jet to muon
  //
  TimerScopeHelper timer(m_timerMuon);
 
  Prompt::VarHolder vars;
 
  std::pair<double, const xAOD::Jet*> match = findTrackJet(muon, trackJets);
 
  if(match.second) {
    //
    // Get muon calorimeter energy variable, RNN and secondary vertex variables
    //
    getMuonAnpVariables(muon, vars, primaryVertex);
 
    //
    // Get mutual variables, passing track as argument
    //
    getMutualVariables(muon, *match.second, muon.primaryTrackParticle(), vars);
 
    //
    // Add variables to TMVA Reader
    //
    addVarsToTMVA(vars);
  }
  else {
    //
    // Decorate muon with default values
    //
    fillVarDefault(vars);
 
    ATH_MSG_DEBUG("No track jet found near to muon");
  }
 
  //
  // Decorate muon with input vars and BDT weight
  //
  decorateAuxLepton(muon, vars, floatDecors, shortDecors);
}

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::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; }

execute()

StatusCode Prompt::DecoratePromptLeptonImproved::execute ( )

overridevirtual

Definition at line 144 of file DecoratePromptLeptonImproved.cxx.

{
  //
  // Start execute timer
  //
  TimerScopeHelper timer(m_timerExec);
 
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  //
  // Retrieve containers from evtStore
  //
  SG::ReadHandle<xAOD::JetContainer> trackJets(m_trackJetsKey, ctx);
  SG::ReadHandle<xAOD::VertexContainer> vertices(m_primaryVertexKey, ctx);
  SG::ReadHandle<xAOD::CaloClusterContainer> clusters(m_clusterContainerKey, ctx);
 
  ATH_MSG_DEBUG("======================================="
    << "\n\t\t\t  Size of vertex    container: " << vertices ->size()
    << "\n\t\t\t  Size of track jet container: " << trackJets->size()
    << "\n-----------------------------------------------------------------");
 
  //
  // Find default Primary Vertex
  //
  const xAOD::Vertex *primaryVertex = nullptr;
 
  for(const xAOD::Vertex *vertex: *vertices) {
    if(vertex->vertexType() == xAOD::VxType::PriVtx) {
      primaryVertex = vertex;
      break;
    }
  }
 
  std::vector<decoratorFloatH_t> floatDecors;
  floatDecors.reserve (m_floatDecorHandleKeys.size());
  for (const SG::WriteDecorHandleKey<xAOD::IParticleContainer>& k : m_floatDecorHandleKeys) {
    floatDecors.emplace_back (k, ctx);
  }
 
  std::vector<decoratorShortH_t> shortDecors;
  shortDecors.reserve (m_shortDecorHandleKeys.size());
  for (const SG::WriteDecorHandleKey<xAOD::IParticleContainer>& k : m_shortDecorHandleKeys) {
    shortDecors.emplace_back (k, ctx);
  }
 
  if(m_leptonsName == "Electrons") {
    //
    // Process electrons
    //
    ATH_MSG_DEBUG("Reading " << m_electronsKey);
    SG::ReadHandle<xAOD::ElectronContainer> electrons(m_electronsKey, ctx);
 
    for(const xAOD::Electron *elec: *electrons) {
      decorateElec(*elec, *trackJets, *clusters, primaryVertex, floatDecors, shortDecors);
    }
  } else if(m_leptonsName == "Muons") {
    //
    // Process muons
    //
    ATH_MSG_DEBUG("Reading " << m_muonsKey);
    SG::ReadHandle<xAOD::MuonContainer> muons(m_muonsKey, ctx);
 
    for(const xAOD::Muon *muon: *muons) {
      decorateMuon(*muon, *trackJets, primaryVertex, floatDecors, shortDecors);
      ATH_MSG_DEBUG("Muon decorated");
    }
  } else {
    ATH_MSG_ERROR("Must specify Electrons or Muons");
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::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

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

fillVarDefault()

void Prompt::DecoratePromptLeptonImproved::fillVarDefault ( Prompt::VarHolder & vars ) const

private

Definition at line 789 of file DecoratePromptLeptonImproved.cxx.

{
  //
  // Add default values to VarHolder
  //
  for(const DecorMap_t::value_type &dec: m_floatDecorMap) {
    vars.addVar(dec.first, -99.0);
  }
 
  for(const DecorMap_t::value_type &dec: m_shortDecorMap) {
    vars.addVar(dec.first, -99.0);
  }
}

finalize()

StatusCode Prompt::DecoratePromptLeptonImproved::finalize ( )

overridevirtual

Definition at line 124 of file DecoratePromptLeptonImproved.cxx.

{
  if(m_printTime) {
    //
    // Print full time stopwatch
    //
    m_timerAll.Stop();
 
    ATH_MSG_INFO("Real time: " << m_timerAll.RealTime() << "\t CPU time: " << m_timerAll.CpuTime());
 
    ATH_MSG_INFO("Execute time: " << PrintResetStopWatch(m_timerExec));
    ATH_MSG_INFO("Muon    time: " << PrintResetStopWatch(m_timerMuon));
    ATH_MSG_INFO("Elec    time: " << PrintResetStopWatch(m_timerElec));
  }
 
  return StatusCode::SUCCESS;
}

findTrackJet()

template<class T>

std::pair< double, const xAOD::Jet * > Prompt::DecoratePromptLeptonImproved::findTrackJet ( const T & part, const xAOD::JetContainer & jets )

private

Definition at line 845 of file DecoratePromptLeptonImproved.cxx.

{
  //
  // Find nearest track jet and a return a pair of dR and xAOD::Jet*
  //
  const xAOD::Jet *minjet = 0;
  double           mindr  = 10.0;
  std::pair<double, const xAOD::Jet*> match(mindr, minjet);
 
  for(const xAOD::Jet* jet: jets) {
    const double dr = part.p4().DeltaR(jet->p4());
 
    if(!minjet || dr < mindr) {
      mindr  = dr;
      minjet = jet;
      match = std::make_pair(mindr, minjet);
    }
  }
 
 
  if(minjet && mindr < m_maxLepTrackJetDR) {
    return match;
  }
  
  minjet = 0;
  return std::make_pair(10., minjet);
}

getElectronAnpVariables()

void Prompt::DecoratePromptLeptonImproved::getElectronAnpVariables ( const xAOD::Electron & elec, const xAOD::CaloClusterContainer & clusters, Prompt::VarHolder & vars, const xAOD::Vertex * primaryVertex )

private

Definition at line 504 of file DecoratePromptLeptonImproved.cxx.

{
  //
  // Get Muon variables - calorimeter
  //
  double sumCoreEt_large = 0.0, CaloClusterSumEtRel = 0.0;
 
  if(elec.caloCluster()) {
    const double elec_calEta = elec.caloCluster()->eta();
    const double elec_calPhi = elec.caloCluster()->phi();
 
    for(const xAOD::CaloCluster *cluster: clusters) {
      const double deta =                      elec_calEta - cluster->eta();
      const double dphi = TVector2::Phi_mpi_pi(elec_calPhi - cluster->phi());
      const double dr   = std::sqrt(deta*deta + dphi*dphi);
 
      if(dr < m_elecMinCalErelConeSize) {
        sumCoreEt_large += cluster->pt();
      }
    }
  }
 
  if(elec.pt() > 0.0) CaloClusterSumEtRel = sumCoreEt_large/elec.pt();
 
  vars.addVar(Prompt::Def::CaloClusterSumEtRel, CaloClusterSumEtRel);
 
  //
  // Get lepton isolation variables
  //
  const double Topoetcone30rel = accessIsolation(accessCalIsolation30, elec);
  const double Ptvarcone30rel  = accessIsolation(accessTrackIsolation30, elec);
 
  vars.addVar(Prompt::Def::Topoetcone30rel, Topoetcone30rel);
  vars.addVar(Prompt::Def::Ptvarcone30rel,  Ptvarcone30rel);
 
  //
  // Get secondary vertex variable
  //
  std::vector<double> goodVertexNdistLong;
 
  if(m_accessDeepSecondaryVertex->isAvailable(elec)) {
    std::vector<ElementLink<xAOD::VertexContainer> > vtxLinks = (*m_accessDeepSecondaryVertex)(elec);
 
    for(ElementLink<xAOD::VertexContainer> &vtxLink: vtxLinks) {
      if(!vtxLink.isValid()) {
        ATH_MSG_WARNING("VertexContainer : invalid link");
        continue;
      }
 
      const xAOD::Vertex *vtx = *vtxLink;
 
      const double fitProb = Prompt::getVertexFitProb(vtx);
 
      if(fitProb < m_vertexMinChiSquaredProb) {
        continue;
      }
 
      const double theta = std::acos(getVertexCosThetaWithLepDir(elec, vtx, primaryVertex));
 
      if      (theta < m_vertexMinThetaBarrElec && std::fabs(elec.eta()) <= m_vertexBarrEcapAbsEtaAt) continue;
      else if (theta < m_vertexMinThetaEcapElec && std::fabs(elec.eta()) >  m_vertexBarrEcapAbsEtaAt) continue;
 
      const double vertex_ndist_long = getVertexLongitudinalNormDist(elec, vtx, primaryVertex);
 
      goodVertexNdistLong.push_back(vertex_ndist_long);
    }
  }
  else {
    ATH_MSG_WARNING("VertexContainer : " << m_vertexLinkName << " not found for the electron");
  }
 
  double best_vertex_ndist_long = 0.0;
 
  if(goodVertexNdistLong.size() > 0) {
    std::sort(goodVertexNdistLong.begin(), goodVertexNdistLong.end());
    best_vertex_ndist_long = goodVertexNdistLong.back();
  }
 
  vars.addVar(Prompt::Def::CandVertex_normDistToPriVtxLongitudinalBest_ThetaCutVtx, best_vertex_ndist_long);
  vars.addVar(Prompt::Def::CandVertex_NPassVtx,                         goodVertexNdistLong.size());
}

getMuonAnpVariables()

void Prompt::DecoratePromptLeptonImproved::getMuonAnpVariables ( const xAOD::Muon & muon, Prompt::VarHolder & vars, const xAOD::Vertex * primaryVertex ) const

private

Definition at line 592 of file DecoratePromptLeptonImproved.cxx.

{
  //
  // Get Muon variables - calorimeter
  //
  double calE = -99.0, peloss = -99.0, caloClusterERel = -99.0;
 
  if(muon.clusterLink().isValid()) {
    const xAOD::CaloCluster* cluster = *(muon.clusterLink());
 
    if(accessMuonCalE.isAvailable(*cluster) && accessMuonParamEnergyLoss.isAvailable(muon)) {
      calE   = accessMuonCalE(*cluster);
      peloss = accessMuonParamEnergyLoss(muon);
 
      caloClusterERel = calE/peloss;
    }
    else {
      ATH_MSG_WARNING("Muon calE or ParamEnergyLoss not found in auxiliary store");
    }
  }
 
  vars.addVar(Prompt::Def::CaloClusterERel, caloClusterERel);
 
  //
  // Get lepton isolation variables
  //
  const double Topoetcone30rel = accessIsolation(accessCalIsolation30, muon);
  const double ptvarcone30TightTTVAPt500rel = accessIsolation(accessTrackIsolation30TTVA, muon);
 
  vars.addVar(Prompt::Def::Topoetcone30rel,              Topoetcone30rel);
  vars.addVar(Prompt::Def::Ptvarcone30_TightTTVA_pt500rel, ptvarcone30TightTTVAPt500rel);
 
  //
  // Get Muon Secondary Vertex variable
  //
  std::vector<double> goodVertexNdistLong;
 
  if(m_accessDeepSecondaryVertex->isAvailable(muon)) {
    std::vector<ElementLink<xAOD::VertexContainer> > vtxLinks = (*m_accessDeepSecondaryVertex)(muon);
    goodVertexNdistLong.reserve(vtxLinks.size());
 
    for(ElementLink<xAOD::VertexContainer> &vtxLink: vtxLinks) {
      if(!vtxLink.isValid()) {
        ATH_MSG_WARNING("VertexContainer : invalid link");
        continue;
      }
 
      const xAOD::Vertex *vtx = *vtxLink;
 
      const double fitProb = Prompt::getVertexFitProb(vtx);
 
      if(fitProb > m_vertexMinChiSquaredProb) {
        const double vertex_ndist_long = getVertexLongitudinalNormDist(muon, vtx, primaryVertex);
 
        goodVertexNdistLong.push_back(vertex_ndist_long);
      }
    }
  }
  else {
    ATH_MSG_WARNING("VertexContainer : " << m_vertexLinkName << " not found for the muon");
  }
 
  double best_vertex_ndist_long = 0.0;
 
  if(goodVertexNdistLong.size() > 0) {
    std::sort(goodVertexNdistLong.begin(), goodVertexNdistLong.end());
    best_vertex_ndist_long = goodVertexNdistLong.back();
  }
 
  vars.addVar(Prompt::Def::CandVertex_normDistToPriVtxLongitudinalBest, best_vertex_ndist_long);
  vars.addVar(Prompt::Def::CandVertex_NPassVtx,                         goodVertexNdistLong.size());
}

getMutualVariables()

void Prompt::DecoratePromptLeptonImproved::getMutualVariables ( const xAOD::IParticle & particle, const xAOD::Jet & track_jet, const xAOD::TrackParticle * track, Prompt::VarHolder & vars ) const

private

Definition at line 670 of file DecoratePromptLeptonImproved.cxx.

{
  //
  // Add lepton - jet variables to VarHolder
  //
  double PtFrac = -99.;
  double PtRel  = -99.;
 
  if(particle.pt() > 0.0 && track_jet.pt() > 0.0) {
 
    if(track) {
      PtFrac = track->pt()/track_jet.pt();
    }
 
    const double angle = particle.p4().Vect().Angle(track_jet.p4().Vect());
 
    PtRel = particle.pt() * std::sin(angle);
  }
 
  //
  // Add vars to VarHolder
  //
  vars.addVar(Prompt::Def::PtFrac,         PtFrac);
  vars.addVar(Prompt::Def::PtRel,          PtRel);
  vars.addVar(Prompt::Def::DRlj,           track_jet.p4().DeltaR(particle.p4()));
  vars.addVar(Prompt::Def::TrackJetNTrack, track_jet.getConstituents().size());
 
  //
  // Get RNN variables
  //
  for(const floatAccessorMap::value_type &acc: m_accessRNNMap) {
    if(acc.second.isAvailable(particle)) {
      vars.addVar(acc.first, acc.second(particle));
    }
    else {
      ATH_MSG_WARNING("LeptonTagger RNN not found in auxiliary store for variable=" << vars.asStr(acc.first));
    }
  }
 
  //
  // Get lepton variables - pT X bin
  //
  const double lepPt = particle.pt();
 
  const double xmax = m_leptonPtBinHist->GetXaxis()->GetXmax();
  const double xmin = m_leptonPtBinHist->GetXaxis()->GetXmin();
 
  int curr_bin = 0;
 
  if(xmin < lepPt && lepPt < xmax) {
    curr_bin = m_leptonPtBinHist->FindBin(lepPt);
  }
  else if (!(lepPt < xmax)) {
    curr_bin = m_leptonPtBinHist->GetNbinsX();
  }
  else if (!(lepPt > xmin)) {
    curr_bin = 1;
  }
 
  vars.addVar(Prompt::Def::MVAXBin, curr_bin);
  vars.addVar(Prompt::Def::RawPt,   lepPt);
 
  ATH_MSG_DEBUG("getMutualVariables - lepPt = " << lepPt << ", MVAXBin = " << curr_bin);
}

getVertexCosThetaWithLepDir()

double Prompt::DecoratePromptLeptonImproved::getVertexCosThetaWithLepDir ( const xAOD::IParticle & lepton, const xAOD::Vertex * secondaryVertex, const xAOD::Vertex * primaryVertex ) const

private

Definition at line 902 of file DecoratePromptLeptonImproved.cxx.

{
  //
  // get the Longitudinal nomalized distance between the secondary vertex and primary vertex
  //
  if(!secondaryVertex || !primaryVertex) {
    ATH_MSG_WARNING("GetVertexThetaWithLepDir - invalid pointer of lepton/secondaryVertex/primaryVertex");
    return 0.0;
  }
 
  const Amg::Vector3D sv_to_pv_v3 = secondaryVertex->position() - primaryVertex->position();
 
  const TVector3 sv_to_pv_t3 = TVector3(sv_to_pv_v3.x(), sv_to_pv_v3.y(), sv_to_pv_v3.z());
  const TVector3 lepton_dirt = lepton.p4().Vect();
 
  const double cos_theta = sv_to_pv_t3.Unit()*lepton_dirt.Unit();
 
  return cos_theta;
}

getVertexLongitudinalNormDist()

double Prompt::DecoratePromptLeptonImproved::getVertexLongitudinalNormDist ( const xAOD::IParticle & lepton, const xAOD::Vertex * secondaryVertex, const xAOD::Vertex * primaryVertex ) const

private

Definition at line 875 of file DecoratePromptLeptonImproved.cxx.

{
  //
  // get the Longitudinal normalized distance between the secondary vertex and primary vertex
  //
  if(!secondaryVertex || !primaryVertex) {
    ATH_MSG_WARNING("getVertexLongitudinalNormDist - invalid pointer of lepton/secondaryVertex/primaryVertex");
    return 0.0;
  }
 
 
  float normDist_SVPV  = 0.0;
 
  if(!Prompt::GetAuxVar(*secondaryVertex, normDist_SVPV,  "normDistToPriVtx")) {
    ATH_MSG_WARNING("getVertexLongitudinalNormDist - missing \"normDistToPriVtx\"");
  }
 
  double cos_theta = getVertexCosThetaWithLepDir(lepton, secondaryVertex, primaryVertex);
 
  return normDist_SVPV*cos_theta;
}

initialize()

StatusCode Prompt::DecoratePromptLeptonImproved::initialize ( )

overridevirtual

Definition at line 44 of file DecoratePromptLeptonImproved.cxx.

{
  ATH_MSG_DEBUG("Initializing DecoratePromptLeptonImproved...");
  ATH_MSG_DEBUG("m_leptonsName = " << m_leptonsName);
  if (m_printTime)
  {
    //
    // Reset timers
    //
    m_timerAll .Reset();
    m_timerExec.Reset();
    m_timerMuon.Reset();
    m_timerElec.Reset();
 
    //
    // Start full timer
    //
    m_timerAll.Start();
  }
 
  ATH_CHECK(m_trackJetsKey.initialize());
  ATH_CHECK(m_primaryVertexKey.initialize());
  ATH_CHECK(m_clusterContainerKey.initialize());
 
  ATH_MSG_DEBUG("Initializing " << m_electronsKey);
 
  ATH_CHECK(m_electronsKey.initialize(m_leptonsName == "Electrons"));
  ATH_CHECK(m_muonsKey.initialize(m_leptonsName == "Muons"));
 
  ATH_MSG_DEBUG("Number of int vars to read: " << m_stringIntVars.size());
  ATH_MSG_DEBUG("Number of float vars to read: " << m_stringFloatVars.size());
 
  // Setup variable holder
  m_vars = std::make_unique<Prompt::VarHolder>();
 
  //
  // Read vector<string> vars into vector<Var> and append
  //
  m_intVars   = m_vars->readVectorVars(m_stringIntVars);
  m_floatVars = m_vars->readVectorVars(m_stringFloatVars);
 
  m_allVars.insert(m_allVars.end(), m_intVars  .begin(), m_intVars  .end());
  m_allVars.insert(m_allVars.end(), m_floatVars.begin(), m_floatVars.end());
 
  m_varTMVA.resize(m_allVars.size());
 
 
  //
  // Get key for recording BDT output
  //
  m_BDTVarKey = m_vars->registerDynamicVar(m_BDTName);
  
  if(m_BDTVarKey == Def::NONE) {
    ATH_MSG_ERROR("Failed to create key for BDT name=" << m_BDTName);
    return StatusCode::FAILURE;
  }
 
  //
  // Fill decorator maps
  //
  ATH_CHECK(initializeDecorators());
 
  //
  // Initialize const accessors
  //
  initializeConstAccessors();
 
  ATH_MSG_DEBUG("Initialized DecoratePromptLeptonImproved.");
 
  //
  // Initialize TMVA Reader
  //
  ATH_CHECK(initializeTMVAReader());
  
  ATH_MSG_DEBUG("Initialized TMVA Reader.");
 
  return StatusCode::SUCCESS;
}

initializeConstAccessors()

void Prompt::DecoratePromptLeptonImproved::initializeConstAccessors ( )

private

Definition at line 381 of file DecoratePromptLeptonImproved.cxx.

{
  //
  // Instantiate isolation accessors
  //
  m_accessDeepSecondaryVertex.emplace (m_vertexLinkName);
 
  //
  // Instantiate accessors for RNN variables
  //
  for(const std::string &name: m_accessorRNNVars) {
    const Def::Var akey = m_vars->registerDynamicVar(name);
 
    if(m_accessRNNMap.insert(floatAccessorMap::value_type(akey, AccessFloat(name))).second) {
      ATH_MSG_DEBUG("Add float RNN accessor: " << name);
    }
    else {
      ATH_MSG_WARNING("Skip duplicate float accessor: " << name);
    }
  }
}

initializeDecorators()

StatusCode Prompt::DecoratePromptLeptonImproved::initializeDecorators ( )

private

Definition at line 262 of file DecoratePromptLeptonImproved.cxx.

{
  std::string inputContName;
  if (m_leptonsName == "Electrons") {
    inputContName = m_electronsKey.key();
  }
  else if (m_leptonsName == "Muons") {
    inputContName = m_muonsKey.key();
  }
  else {
    ATH_MSG_ERROR ("LeptonContainerName was " << m_leptonsName <<
                   "; must be either Electrons or Muons");
    return StatusCode::FAILURE;
  }
 
  DecorMap_t vetoedVars;
  for(const std::string &vvar: m_vetoDecoratorFloatVars) {
    const Def::Var vkey = m_vars->registerDynamicVar(vvar);
 
    if(vkey == Def::NONE) {
      ATH_MSG_ERROR("Failed to create key for variable name=" << vvar);
      return StatusCode::FAILURE;
    }
 
    vetoedVars.try_emplace (vkey, 0);
  }
  for(const std::string &vvar: m_vetoDecoratorShortVars) {
    const Def::Var vkey = m_vars->registerDynamicVar(vvar);
 
    if(vkey == Def::NONE) {
      ATH_MSG_ERROR("Failed to create key for variable name=" << vvar);
      return StatusCode::FAILURE;
    }
 
    vetoedVars.try_emplace (vkey, 0);
  }
 
  //
  // Fill short variable map
  //
  for(Prompt::Def::Var &var: m_intVars) {
    if (!vetoedVars.contains (var)) {
      m_shortDecorMap.try_emplace (var, m_shortDecorHandleKeys.size());
      m_shortDecorHandleKeys.push_back (SG::makeContDecorKey (inputContName, m_inputVarDecoratePrefix + m_vars->asStr(var)));
    }
  }
 
  //
  // Fill float variable map
  //
  m_floatDecorHandleKeys.clear();
  for(Prompt::Def::Var &var: m_floatVars) {
    if (!vetoedVars.contains (var)) {
      m_floatDecorMap.try_emplace (var, m_floatDecorHandleKeys.size());
      m_floatDecorHandleKeys.push_back (SG::makeContDecorKey (inputContName, m_inputVarDecoratePrefix + m_vars->asStr(var)));
    }
  }
 
  //
  // Fill additional variables
  //
  if (!vetoedVars.contains (m_BDTVarKey)) {
    m_floatDecorMap.try_emplace (m_BDTVarKey, m_floatDecorHandleKeys.size());
    m_floatDecorHandleKeys.push_back (SG::makeContDecorKey (inputContName, m_BDTName));
  }
 
  for(const std::string &evar: m_extraDecoratorFloatVars) {
    const Def::Var ekey = m_vars->registerDynamicVar(evar);
 
    if(ekey == Def::NONE) {
      ATH_MSG_ERROR("Failed to create key for variable name=" << evar);
      return StatusCode::FAILURE;
    }
 
    if (!vetoedVars.contains (ekey)) {
      m_floatDecorMap.try_emplace (ekey, m_floatDecorHandleKeys.size());
      m_floatDecorHandleKeys.push_back (SG::makeContDecorKey (inputContName, m_inputVarDecoratePrefix + evar));
    }
  }
 
  for(const std::string &evar: m_extraDecoratorShortVars) {
    const Def::Var ekey = m_vars->registerDynamicVar(evar);
 
    if(ekey == Def::NONE) {
      ATH_MSG_ERROR("Failed to create key for variable name=" << evar);
      return StatusCode::FAILURE;
    }
 
    if (!vetoedVars.contains (ekey)) {
      m_shortDecorMap.try_emplace (ekey, m_shortDecorHandleKeys.size());
      m_shortDecorHandleKeys.push_back (SG::makeContDecorKey (inputContName, m_inputVarDecoratePrefix + evar));
    }
  }
 
  ATH_CHECK(m_shortDecorHandleKeys.initialize());
  ATH_CHECK(m_floatDecorHandleKeys.initialize());
 
  // Print decorator counts
  ATH_MSG_DEBUG("Added " << m_shortDecorHandleKeys.size() << " short decorators");
  ATH_MSG_DEBUG("Added " << m_floatDecorHandleKeys.size() << " float decorators");
 
  // Instantiate MVA X bin
  if(m_leptonPtBinsVector.size() < 2) {
    ATH_MSG_ERROR("Invalid PtBins size=" << m_leptonPtBinsVector.size());
    return StatusCode::FAILURE;
  }
 
  std::unique_ptr<double []> PtBins = std::make_unique<double []>(m_leptonPtBinsVector.size());
 
  for(unsigned i = 0; i < m_leptonPtBinsVector.size(); i++) {
    PtBins[i] = m_leptonPtBinsVector[i];
  }
 
  m_leptonPtBinHist = std::make_unique<TH1D>("PtBin", "PtBin", m_leptonPtBinsVector.size() - 1, PtBins.get());
 
  return StatusCode::SUCCESS;
}

initializeTMVAReader()

bool Prompt::DecoratePromptLeptonImproved::initializeTMVAReader ( )

private

Definition at line 220 of file DecoratePromptLeptonImproved.cxx.

{   
  //
  // Make new instance of TMVA Reader and add variables
  //
  m_TMVAReader = std::make_unique<TMVA::Reader>();
 
  for(unsigned i = 0; i < m_allVars.size(); ++i) { 
    m_TMVAReader->AddVariable(m_vars->asStr(m_allVars.at(i)), &m_varTMVA[i]);
  }
  
  //
  // Get path to xml training file
  //
  std::string fullPathToFile = PathResolverFindCalibFile("JetTagNonPromptLepton/" 
                             + m_configFileVersion 
                             + "/TMVAClassification_" + m_methodTitleMVA + ".weights.xml");
 
  if(!m_configPathOverride.empty()) {
    ATH_MSG_INFO("Override path resolver result");
    fullPathToFile = m_configPathOverride;
  }
 
  ATH_MSG_INFO("TMVA configuration file: " + fullPathToFile);
  ATH_MSG_INFO("TMVA method name: " + m_methodTitleMVA);
 
  //
  // Book an instance of BDT reader if path is available
  //
  if(fullPathToFile == "") {
    ATH_MSG_ERROR("Could not find path to xml training file");
    return false;
  }
  else {
    m_TMVAReader->BookMVA(m_methodTitleMVA.toString(), fullPathToFile);
  }
 
  return true;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::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.

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Algorithm >::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< Algorithm > >::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< Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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_accessDeepSecondaryVertex

std::optional<AccessVertex> Prompt::DecoratePromptLeptonImproved::m_accessDeepSecondaryVertex

private

Definition at line 212 of file DecoratePromptLeptonImproved.h.

m_accessorRNNVars

Gaudi::Property<std::vector<std::string> > Prompt::DecoratePromptLeptonImproved::m_accessorRNNVars {this, "accessorRNNVars", {}, "Name of the RNN accessor of the lepton"}

private

Definition at line 159 of file DecoratePromptLeptonImproved.h.

{this, "accessorRNNVars", {}, "Name of the RNN accessor of the lepton"};

m_accessRNNMap

floatAccessorMap Prompt::DecoratePromptLeptonImproved::m_accessRNNMap

private

Definition at line 214 of file DecoratePromptLeptonImproved.h.

m_allVars

std::vector<Prompt::Def::Var> Prompt::DecoratePromptLeptonImproved::m_allVars

private

Definition at line 203 of file DecoratePromptLeptonImproved.h.

m_BDTName

Gaudi::Property<std::string> Prompt::DecoratePromptLeptonImproved::m_BDTName {this, "BDTName", "", "BDT name"}

private

Definition at line 156 of file DecoratePromptLeptonImproved.h.

{this, "BDTName", "", "BDT name"};

m_BDTVarKey

Prompt::Def::Var Prompt::DecoratePromptLeptonImproved::m_BDTVarKey

private

Definition at line 207 of file DecoratePromptLeptonImproved.h.

m_clusterContainerKey

SG::ReadHandleKey<xAOD::CaloClusterContainer> Prompt::DecoratePromptLeptonImproved::m_clusterContainerKey

private

Initial value:

{
      this, "ClusterContainerName", "",
      "Container name of the Clusters which are used to calculate the input variables for the PromptLeptonImproved"
    }

Definition at line 185 of file DecoratePromptLeptonImproved.h.

                                                                    {
      this, "ClusterContainerName", "",
      "Container name of the Clusters which are used to calculate the input variables for the PromptLeptonImproved"
    };

m_configFileVersion

Gaudi::Property<std::string> Prompt::DecoratePromptLeptonImproved::m_configFileVersion {this, "ConfigFileVersion", "", "BDT weight file version"}

private

Definition at line 153 of file DecoratePromptLeptonImproved.h.

{this, "ConfigFileVersion", "", "BDT weight file version"};

m_configPathOverride

Gaudi::Property<std::string> Prompt::DecoratePromptLeptonImproved::m_configPathOverride {this, "ConfigPathOverride", "", "Path of the local BDT weight file you want to study/test"}

private

Definition at line 154 of file DecoratePromptLeptonImproved.h.

{this, "ConfigPathOverride", "", "Path of the local BDT weight file you want to study/test"};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_elecMinCalErelConeSize

Gaudi::Property<double> Prompt::DecoratePromptLeptonImproved::m_elecMinCalErelConeSize {this, "ElecMinCalErelConeSize", 0.15, "Cut of the cluster for calculating the core energy of the lepton"}

private

Definition at line 175 of file DecoratePromptLeptonImproved.h.

{this, "ElecMinCalErelConeSize", 0.15, "Cut of the cluster for calculating the core energy of the lepton"};

m_electronsKey

SG::ReadHandleKey<xAOD::ElectronContainer> Prompt::DecoratePromptLeptonImproved::m_electronsKey

private

Initial value:

{
      this, "ElectronContainerKey", "Electrons",
      "Container's name of the electrons that you want to decorate"
    }

Definition at line 190 of file DecoratePromptLeptonImproved.h.

                                                          {
      this, "ElectronContainerKey", "Electrons",
      "Container's name of the electrons that you want to decorate"
    };

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_extraDecoratorFloatVars

Gaudi::Property<std::vector<std::string> > Prompt::DecoratePromptLeptonImproved::m_extraDecoratorFloatVars {this, "extraDecoratorFloatVars", {}, "Extra float variables' names you want to compute and decorate into the lepton"}

private

Definition at line 162 of file DecoratePromptLeptonImproved.h.

{this, "extraDecoratorFloatVars", {}, "Extra float variables' names you want to compute and decorate into the lepton"};

m_extraDecoratorShortVars

Gaudi::Property<std::vector<std::string> > Prompt::DecoratePromptLeptonImproved::m_extraDecoratorShortVars {this, "extraDecoratorShortVars", {}, "Extra short variables' names you want to compute and decorate into the lepton"}

private

Definition at line 163 of file DecoratePromptLeptonImproved.h.

{this, "extraDecoratorShortVars", {}, "Extra short variables' names you want to compute and decorate into the lepton"};

m_floatDecorHandleKeys

SG::WriteDecorHandleKeyArray<xAOD::IParticleContainer> Prompt::DecoratePromptLeptonImproved::m_floatDecorHandleKeys { this, "FloatDecorHandleKeys", {} }

private

Definition at line 223 of file DecoratePromptLeptonImproved.h.

{ this, "FloatDecorHandleKeys", {} };

m_floatDecorMap

DecorMap_t Prompt::DecoratePromptLeptonImproved::m_floatDecorMap

private

Definition at line 229 of file DecoratePromptLeptonImproved.h.

m_floatVars

std::vector<Prompt::Def::Var> Prompt::DecoratePromptLeptonImproved::m_floatVars

private

Definition at line 202 of file DecoratePromptLeptonImproved.h.

m_inputVarDecoratePrefix

Gaudi::Property<std::string> Prompt::DecoratePromptLeptonImproved::m_inputVarDecoratePrefix {this, "InputVarDecoratePrefix", "", "Prefix of the variables that will be decorated into the lepton"}

private

Definition at line 155 of file DecoratePromptLeptonImproved.h.

{this, "InputVarDecoratePrefix", "", "Prefix of the variables that will be decorated into the lepton"};

m_intVars

std::vector<Prompt::Def::Var> Prompt::DecoratePromptLeptonImproved::m_intVars

private

Definition at line 201 of file DecoratePromptLeptonImproved.h.

m_leptonPtBinHist

std::unique_ptr<TH1D> Prompt::DecoratePromptLeptonImproved::m_leptonPtBinHist

private

Definition at line 216 of file DecoratePromptLeptonImproved.h.

m_leptonPtBinsVector

Gaudi::Property<std::vector<double> > Prompt::DecoratePromptLeptonImproved::m_leptonPtBinsVector {this, "leptonPtBinsVector", {}, "pT bin edges that are used for MVABin calculation"}

private

Definition at line 166 of file DecoratePromptLeptonImproved.h.

{this, "leptonPtBinsVector", {}, "pT bin edges that are used for MVABin calculation"};

m_leptonsName

Gaudi::Property<std::string> Prompt::DecoratePromptLeptonImproved::m_leptonsName

private

Initial value:

{
      this, "LeptonContainerName", "",
      "Container's name of the lepton that you want to decorate. Also need to set ElectronContainerKey or MuonContainerKey accordingly"
    }

Definition at line 148 of file DecoratePromptLeptonImproved.h.

                                           {
      this, "LeptonContainerName", "",
      "Container's name of the lepton that you want to decorate. Also need to set ElectronContainerKey or MuonContainerKey accordingly"
    };

m_maxLepTrackJetDR

Gaudi::Property<double> Prompt::DecoratePromptLeptonImproved::m_maxLepTrackJetDR {this, "maxLepTrackJetDR", 0.4, "Maximum distance between lepton and track jet for track jet matching"}

private

Definition at line 176 of file DecoratePromptLeptonImproved.h.

{this, "maxLepTrackJetDR", 0.4, "Maximum distance between lepton and track jet for track jet matching"};

m_methodTitleMVA

Gaudi::Property<std::string> Prompt::DecoratePromptLeptonImproved::m_methodTitleMVA {this, "MethodTitleMVA", "BDT", "Help to config the path of the BDT xml file"}

private

Definition at line 157 of file DecoratePromptLeptonImproved.h.

{this, "MethodTitleMVA", "BDT", "Help to config the path of the BDT xml file"};

m_muonsKey

SG::ReadHandleKey<xAOD::MuonContainer> Prompt::DecoratePromptLeptonImproved::m_muonsKey

private

Initial value:

{
      this, "MuonContainerKey", "Muons",
      "Container's name of the muons that you want to decorate"
    }

Definition at line 194 of file DecoratePromptLeptonImproved.h.

                                                  {
      this, "MuonContainerKey", "Muons",
      "Container's name of the muons that you want to decorate"
    };

m_primaryVertexKey

SG::ReadHandleKey<xAOD::VertexContainer> Prompt::DecoratePromptLeptonImproved::m_primaryVertexKey

private

Initial value:

{
      this, "PrimaryVertexContainerName", "", "Primary vertex container name"
    }

Definition at line 182 of file DecoratePromptLeptonImproved.h.

                                                            {
      this, "PrimaryVertexContainerName", "", "Primary vertex container name"
    };

m_printTime

Gaudi::Property<bool> Prompt::DecoratePromptLeptonImproved::m_printTime {this, "PrintTime", false, "Whether to print current time"}

private

Definition at line 168 of file DecoratePromptLeptonImproved.h.

{this, "PrintTime", false, "Whether to print current time"};

m_shortDecorHandleKeys

SG::WriteDecorHandleKeyArray<xAOD::IParticleContainer> Prompt::DecoratePromptLeptonImproved::m_shortDecorHandleKeys { this, "ShortDecorHandleKeys", {} }

private

Definition at line 225 of file DecoratePromptLeptonImproved.h.

{ this, "ShortDecorHandleKeys", {} };

m_shortDecorMap

DecorMap_t Prompt::DecoratePromptLeptonImproved::m_shortDecorMap

private

Definition at line 230 of file DecoratePromptLeptonImproved.h.

m_stringFloatVars

Gaudi::Property<std::vector<std::string> > Prompt::DecoratePromptLeptonImproved::m_stringFloatVars {this, "stringFloatVars", {}, "Vector of the BDT float variables' names and they will be decorated into lepton if not in the veto list"}

private

Definition at line 161 of file DecoratePromptLeptonImproved.h.

{this, "stringFloatVars", {}, "Vector of the BDT float variables' names and they will be decorated into lepton if not in the veto list"};

m_stringIntVars

Gaudi::Property<std::vector<std::string> > Prompt::DecoratePromptLeptonImproved::m_stringIntVars {this, "stringIntVars", {}, "Vector of the BDT int variables' names and they will be decorated into lepton if not in the veto list"}

private

Definition at line 160 of file DecoratePromptLeptonImproved.h.

{this, "stringIntVars", {}, "Vector of the BDT int variables' names and they will be decorated into lepton if not in the veto list"};

m_timerAll

TStopwatch Prompt::DecoratePromptLeptonImproved::m_timerAll

private

Definition at line 218 of file DecoratePromptLeptonImproved.h.

m_timerElec

TStopwatch Prompt::DecoratePromptLeptonImproved::m_timerElec

private

Definition at line 221 of file DecoratePromptLeptonImproved.h.

m_timerExec

TStopwatch Prompt::DecoratePromptLeptonImproved::m_timerExec

private

Definition at line 219 of file DecoratePromptLeptonImproved.h.

m_timerMuon

TStopwatch Prompt::DecoratePromptLeptonImproved::m_timerMuon

private

Definition at line 220 of file DecoratePromptLeptonImproved.h.

m_TMVAReader

std::unique_ptr<TMVA::Reader> Prompt::DecoratePromptLeptonImproved::m_TMVAReader

private

Definition at line 209 of file DecoratePromptLeptonImproved.h.

m_trackJetsKey

SG::ReadHandleKey<xAOD::JetContainer> Prompt::DecoratePromptLeptonImproved::m_trackJetsKey

private

Initial value:

{
      this, "TrackJetContainerName", "", "Track Jet container name"
    }

Definition at line 179 of file DecoratePromptLeptonImproved.h.

                                                     {
      this, "TrackJetContainerName", "", "Track Jet container name"
    };

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vars

std::unique_ptr<Prompt::VarHolder> Prompt::DecoratePromptLeptonImproved::m_vars

private

Definition at line 205 of file DecoratePromptLeptonImproved.h.

m_varTMVA

std::vector<Float_t> Prompt::DecoratePromptLeptonImproved::m_varTMVA

private

Definition at line 210 of file DecoratePromptLeptonImproved.h.

m_vertexBarrEcapAbsEtaAt

Gaudi::Property<double> Prompt::DecoratePromptLeptonImproved::m_vertexBarrEcapAbsEtaAt {this, "VertexBarrEcapAbsEtaAt", 1.37, "Relate to the vertex cut above, define the barrel and central electrons by abs(eta)"}

private

Definition at line 174 of file DecoratePromptLeptonImproved.h.

{this, "VertexBarrEcapAbsEtaAt", 1.37, "Relate to the vertex cut above, define the barrel and central electrons by abs(eta)"};

m_vertexLinkName

Gaudi::Property<std::string> Prompt::DecoratePromptLeptonImproved::m_vertexLinkName {this, "VertexLinkName", "", "ElementLink name of the secondary vertices"}

private

Definition at line 170 of file DecoratePromptLeptonImproved.h.

{this, "VertexLinkName", "", "ElementLink name of the secondary vertices"};

m_vertexMinChiSquaredProb

Gaudi::Property<double> Prompt::DecoratePromptLeptonImproved::m_vertexMinChiSquaredProb {this, "VertexMinChiSquaredProb", 0.03, "Vertex chi2 cut"}

private

Definition at line 171 of file DecoratePromptLeptonImproved.h.

{this, "VertexMinChiSquaredProb", 0.03, "Vertex chi2 cut"};

m_vertexMinThetaBarrElec

Gaudi::Property<double> Prompt::DecoratePromptLeptonImproved::m_vertexMinThetaBarrElec {this, "VertexMinThetaBarrElec", 0.002, "Vertex theta between lepton and the direction of sv-pv cut for barrel electrons"}

private

Definition at line 172 of file DecoratePromptLeptonImproved.h.

{this, "VertexMinThetaBarrElec", 0.002, "Vertex theta between lepton and the direction of sv-pv cut for barrel electrons"};

m_vertexMinThetaEcapElec

Gaudi::Property<double> Prompt::DecoratePromptLeptonImproved::m_vertexMinThetaEcapElec {this, "VertexMinThetaEcapElec", 0.001, "Vertex theta between lepton and the direction of sv-pv cut for central electrons"}

private

Definition at line 173 of file DecoratePromptLeptonImproved.h.

{this, "VertexMinThetaEcapElec", 0.001, "Vertex theta between lepton and the direction of sv-pv cut for central electrons"};

m_vetoDecoratorFloatVars

Gaudi::Property<std::vector<std::string> > Prompt::DecoratePromptLeptonImproved::m_vetoDecoratorFloatVars {this, "vetoDecoratorFloatVars", {}, "Vector of the float variables' names you do not want to save"}

private

Definition at line 164 of file DecoratePromptLeptonImproved.h.

{this, "vetoDecoratorFloatVars", {}, "Vector of the float variables' names you do not want to save"};

m_vetoDecoratorShortVars

Gaudi::Property<std::vector<std::string> > Prompt::DecoratePromptLeptonImproved::m_vetoDecoratorShortVars {this, "vetoDecoratorShortVars", {}, "Vector of the short variables' names you do not want to save"}

private

Definition at line 165 of file DecoratePromptLeptonImproved.h.

{this, "vetoDecoratorShortVars", {}, "Vector of the short variables' names you do not want to save"};

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• DecoratePromptLeptonImproved.h
• DecoratePromptLeptonImproved.cxx