AsgPhotonEfficiencyCorrectionTool Class Reference

#include <AsgPhotonEfficiencyCorrectionTool.h>

Inheritance diagram for AsgPhotonEfficiencyCorrectionTool:

Collaboration diagram for AsgPhotonEfficiencyCorrectionTool:

Classes
struct	Accessors

Public Member Functions
	AsgPhotonEfficiencyCorrectionTool (const std::string &myname)
	Standard constructor. More...
virtual	~AsgPhotonEfficiencyCorrectionTool ()
	Standard destructor. More...
virtual StatusCode	initialize () override
	Gaudi Service Interface method implementations. More...
virtual CP::CorrectionCode	getEfficiencyScaleFactor (const xAOD::Egamma &inputObject, double &efficiencyScaleFactor) const override
	Add some method for now as a first step to move the tool to then new interface. More...
CP::CorrectionCode	getEfficiencyScaleFactor (columnar::EgammaId inputObject, columnar::EventInfoId eventInfo, double &efficiencyScaleFactor) const
virtual CP::CorrectionCode	getEfficiencyScaleFactorError (const xAOD::Egamma &inputObject, double &efficiencyScaleFactorError) const override
	Get the "photon scale factor error" as a return value. More...
CP::CorrectionCode	getEfficiencyScaleFactorError (columnar::EgammaId inputObject, columnar::EventInfoId eventInfo, double &efficiencyScaleFactorError) const
virtual CP::CorrectionCode	applyEfficiencyScaleFactor (xAOD::Egamma &inputObject) const override
	Decorate the photon with its scale factor. More...
virtual bool	isAffectedBySystematic (const CP::SystematicVariation &systematic) const override
	The methods below should notify the user of what is actually in the list , without him having to go in the wiki. More...
virtual CP::SystematicSet	affectingSystematics () const override
	returns: the list of all systematics this tool can be affected by More...
virtual CP::SystematicSet	recommendedSystematics () const override
	returns: the list of all systematics this tool recommends to use More...
const CP::SystematicSet &	appliedSystematics () const
	returns: the currently applied systematics More...
virtual StatusCode	applySystematicVariation (const CP::SystematicSet &systConfig) override
	Configure this tool for the given systematics. More...
StatusCode	registerSystematics ()
	Register the systematics with the registry and add them to the recommended list. More...
void	callSingleEvent (columnar::EgammaRange photons, columnar::EventInfoId event) const
void	callEvents (columnar::EventContextRange events) const override
virtual void	print () const =0
	Print the state of the tool. More...
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, V, H > &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 Root::TElectronEfficiencyCorrectionTool::Result	Result
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
CP::CorrectionCode	calculate (columnar::EgammaId egam, columnar::EventInfoId eventInfo, Result &result) const
	I think these calculate methods are only used internally. More...
std::string	getFileName (const std::string &isoWP, const std::string &trigWP, bool isConv)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
Root::TElectronEfficiencyCorrectionTool *	m_rootTool_unc
	Pointer to the underlying ROOT based tool. More...
Root::TElectronEfficiencyCorrectionTool *	m_rootTool_con
std::unordered_map< CP::SystematicSet, CP::SystematicSet >	m_systFilter
	Systematics filter map. More...
CP::SystematicSet *	m_appliedSystematics = nullptr
	Currently applied systematics. More...
std::string	m_sysSubstring
std::string	m_file_prefix_ID ="efficiencySF.offline."
std::string	m_file_prefix_ISO ="efficiencySF.Isolation."
std::string	m_file_prefix_Trig ="efficiencySF."
std::string	m_file_prefix_TrigEff ="efficiency."
std::string	m_corrFileNameConv
	The list of input file names. More...
std::string	m_corrFileNameUnconv
std::string	m_resultPrefix
	The prefix string for the result. More...
std::string	m_resultName
	The string for the result. More...
int	m_dataTypeOverwrite
	Force the data type to a given value. More...
std::string	m_isoWP
	Isolation working point. More...
std::string	m_trigger
	Trigger name for trigger SF. More...
std::string	m_mapFile
	map filename More...
std::map< float, std::vector< float > >	m_pteta_bins
bool	m_useRandomRunNumber
int	m_defaultRandomRunNumber
bool	m_removeTRTConversion
Gaudi::Property< bool >	m_allowMissingLinks { this, "AllowMissingLinks", false, "Allow missing links in the input objects. This should only be used by experts running on expert formats." }
std::unique_ptr< Accessors >	m_accessors {std::make_unique<Accessors>(*this)}
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 41 of file AsgPhotonEfficiencyCorrectionTool.h.

Member Typedef Documentation

Result

typedef Root::TElectronEfficiencyCorrectionTool::Result AsgPhotonEfficiencyCorrectionTool::Result

private

Definition at line 92 of file AsgPhotonEfficiencyCorrectionTool.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

AsgPhotonEfficiencyCorrectionTool()

AsgPhotonEfficiencyCorrectionTool::AsgPhotonEfficiencyCorrectionTool

(

const std::string &

myname

)

Standard constructor.

Definition at line 42 of file AsgPhotonEfficiencyCorrectionTool.cxx.

                                                                                              : 
  AsgTool(myname),
  m_rootTool_unc(nullptr),
  m_rootTool_con(nullptr),
  m_appliedSystematics(nullptr),
  m_sysSubstring("")
{
 
  // Create an instances of the underlying ROOT tools
  m_rootTool_unc = new Root::TElectronEfficiencyCorrectionTool();
  m_rootTool_con = new Root::TElectronEfficiencyCorrectionTool();
 
  // Declare the needed properties
  declareProperty( "CorrectionFileNameConv", m_corrFileNameConv="",
                   "File that stores the correction factors for simulation for converted photons");
 
  declareProperty( "CorrectionFileNameUnconv", m_corrFileNameUnconv="",
                   "File that stores the correction factors for simulation for unconverted photons");
                   
  declareProperty("MapFilePath", m_mapFile = "PhotonEfficiencyCorrection/2015_2025/rel22.2/2024_FinalRun2_Recommendation_v1/map1.txt",
                  "Full path to the map file");  
                  
  declareProperty( "ForceDataType", m_dataTypeOverwrite=-1,
                   "Force the DataType of the Photon to specified value");
 
  declareProperty( "ResultPrefix",       m_resultPrefix="", "The prefix string for the result");
  declareProperty( "ResultName",         m_resultName="",   "The string for the result");
  
  // Properties needed for isolation corrections
  declareProperty( "IsoKey",         m_isoWP="",   "Set isolation WP, if this string is empty the tool will return ID SF");
  
  // Properties needed for trigger SF
  declareProperty( "TriggerKey",         m_trigger="",   "Set trigger, if this string is empty the tool will return ID SF");
  
  // Properties related to the receiving of event run number
  declareProperty("UseRandomRunNumber",  m_useRandomRunNumber = true,
                                        "Set if use RandomRunNumber from eventinfo");
  declareProperty("DefaultRandomRunNumber",  m_defaultRandomRunNumber = 999999,
                                        "Set default run number manually");
  declareProperty("removeTRTConversion", m_removeTRTConversion = true, 
          "boolean to treat barrel standalone TRT conversion as unconverted for Run3 ");   
                                        
 
}

~AsgPhotonEfficiencyCorrectionTool()

AsgPhotonEfficiencyCorrectionTool::~AsgPhotonEfficiencyCorrectionTool ( )

virtual

Standard destructor.

Definition at line 90 of file AsgPhotonEfficiencyCorrectionTool.cxx.

{
  if ( m_rootTool_unc ) delete m_rootTool_unc;
  if ( m_rootTool_con ) delete m_rootTool_con;
}

Member Function Documentation

affectingSystematics()

CP::SystematicSet AsgPhotonEfficiencyCorrectionTool::affectingSystematics ( ) const

overridevirtual

returns: the list of all systematics this tool can be affected by

returns: the list of all systematics this tool can be affected by (for now keep +-1 sigma variation, but ignore it later in applySystematicVariation() )

Implements CP::IReentrantSystematicsTool.

Definition at line 378 of file AsgPhotonEfficiencyCorrectionTool.cxx.

                                                                              {
  CP::SystematicSet mySysSet;
 
  mySysSet.insert(CP::SystematicVariation("PH_EFF_"+m_sysSubstring+"Uncertainty", CP::SystematicVariation::CONTINUOUS));
  mySysSet.insert(CP::SystematicVariation("PH_EFF_"+m_sysSubstring+"Uncertainty", 1));
  mySysSet.insert(CP::SystematicVariation("PH_EFF_"+m_sysSubstring+"Uncertainty", -1));
   
  return mySysSet;
}

appliedSystematics()

const CP::SystematicSet& AsgPhotonEfficiencyCorrectionTool::appliedSystematics ( ) const

inline

returns: the currently applied systematics

Definition at line 80 of file AsgPhotonEfficiencyCorrectionTool.h.

                                                    {
    assert (m_appliedSystematics != nullptr);
    return *m_appliedSystematics;
  }

applyEfficiencyScaleFactor()

CP::CorrectionCode AsgPhotonEfficiencyCorrectionTool::applyEfficiencyScaleFactor ( xAOD::Egamma &  ) const

overridevirtual

Decorate the photon with its scale factor.

Implements IAsgPhotonEfficiencyCorrectionTool.

Definition at line 356 of file AsgPhotonEfficiencyCorrectionTool.cxx.

                                                                                                            {
  
  double efficiencyScaleFactor = 1.0;
  CP::CorrectionCode result = getEfficiencyScaleFactor(inputObject, efficiencyScaleFactor);
  const static SG::AuxElement::Decorator<float> dec(m_resultPrefix+m_resultName+"SF");
  dec(inputObject) = efficiencyScaleFactor;
  return result;
}

applySystematicVariation()

StatusCode AsgPhotonEfficiencyCorrectionTool::applySystematicVariation ( const CP::SystematicSet &  systConfig )

overridevirtual

Configure this tool for the given systematics.

Implements CP::ISystematicsTool.

Definition at line 408 of file AsgPhotonEfficiencyCorrectionTool.cxx.

{
  // First, check if we already know this systematic configuration
  auto itr = m_systFilter.find(systConfig);
 
  // If it's a new input set, we need to filter it
  if( itr == m_systFilter.end() ){
 
    CP::SystematicSet affectingSys = affectingSystematics();
    CP::SystematicSet filteredSys;   
    if (!CP::SystematicSet::filterForAffectingSystematics(systConfig, affectingSys, filteredSys)){
      ATH_MSG_ERROR("Unsupported combination of systematics passed to the tool!");
      return StatusCode::FAILURE;
    }
    // Insert filtered set into the map
    itr = m_systFilter.insert(std::make_pair(systConfig, filteredSys)).first;
  }
 
  CP::SystematicSet& mySysConf = itr->second;
  m_appliedSystematics = &mySysConf;
  return StatusCode::SUCCESS;
}

calculate()

CP::CorrectionCode AsgPhotonEfficiencyCorrectionTool::calculate ( columnar::EgammaId  egam, columnar::EventInfoId  eventInfo, Result &  result  ) const

private

I think these calculate methods are only used internally.

Definition at line 181 of file AsgPhotonEfficiencyCorrectionTool.cxx.

{
  const auto& acc = *m_accessors;
 
  // retrieve transverse energy from e/cosh(etaS2)
  auto clusters  = egam(acc.caloClusterAcc);  
  if (clusters.size()<1||!clusters[0].has_value()){
    ATH_MSG_ERROR("No  cluster associated to the Photon \n"); 
    return  CP::CorrectionCode::Error;
  } 
  auto cluster = clusters[0].value();
 
  // use et from cluster because it is immutable under syst variations of ele energy scale
  const double energy = cluster(acc.clusterEAcc);
  double et = 0.;
  if ( std::abs(egam(acc.etaAcc)) < 999.) {
    const double cosheta = std::cosh(egam(acc.etaAcc));
    et = (cosheta != 0.) ? energy / cosheta : 0.;
  }
 
  // eta from second layer
  double eta2 = cluster(acc.clusterEtaBEAcc,2);
 
  // allow for a 5% margin at the lowest pT bin boundary (i.e. increase et by 5% 
  // for sub-threshold electrons). This assures that electrons that pass the 
  // threshold only under syst variations of energy get a scale factor assigned.
  std::map<float, std::vector<float>>::const_iterator itr_pt = m_pteta_bins.begin();
  if (itr_pt!=m_pteta_bins.end() && et<itr_pt->first) {
    et=et*1.05;
  }
 
  // Check if photon in the range to get the SF
  if (std::abs(eta2) > MAXETA) {
    result.SF = 1;
    result.Total = 1;
    ATH_MSG_DEBUG("No correction factor provided for eta "
                  << eta2 << " Returning SF = 1 + / - 1");
    return CP::CorrectionCode::OutOfValidityRange;
  }
  if (et < MIN_ET) {
    result.SF = 1;
    result.Total = 1;
    ATH_MSG_DEBUG("No correction factor provided for eT "
                  << et << " Returning SF = 1 + / - 1");
    return CP::CorrectionCode::OutOfValidityRange;
  }
  if (itr_pt != m_pteta_bins.end() && et < itr_pt->first) {
    result.SF = 1;
    result.Total = 1;
    ATH_MSG_DEBUG("No scale factor uncertainty provided for et "
                  << et / 1e3 << "GeV Returning SF = 1 + / - 1");
    return CP::CorrectionCode::OutOfValidityRange;
  }
 
  // Retrieve the proper random Run Number
  unsigned int runnumber = m_defaultRandomRunNumber;
  if (m_useRandomRunNumber) {
    if (!acc.randomRunNumberAcc.isAvailable(eventInfo)) {
      ATH_MSG_WARNING(
          "Pileup tool not run before using PhotonEfficiencyTool! SFs do not "
          "reflect PU distribution in data");
      return CP::CorrectionCode::Error;
    }
    runnumber = acc.randomRunNumberAcc(eventInfo);
  }
 
  /* For now the dataType must be set by the user. May be added to the IParticle
   * class later.  */
  // probably event info should be able to tell us if it's data, fullsim, AF,..
  PATCore::ParticleDataType::DataType dataType =
      PATCore::ParticleDataType::DataType::Data;
  if (m_dataTypeOverwrite >= 0)
    dataType = (PATCore::ParticleDataType::DataType)m_dataTypeOverwrite;
 
 
   //exclude TRT 
   bool excludeTRT = false;
   if(runnumber >= 410000 && m_removeTRTConversion) excludeTRT = true;
  // check if converted
  const auto [isConv, missingLinks] = acc.isConvertedPhotonAcc(egam, excludeTRT);
  if (missingLinks) { // missing vertex or track links
    if (!m_allowMissingLinks.value()) {
      ATH_MSG_ERROR("Missing vertex or track links when trying to calculate the conversion type. missingLinks=" << std::hex << missingLinks);
      return CP::CorrectionCode::Error;
    }
    static std::atomic<bool> warned {false};
    if (warned.exchange(true) == false) {
      ATH_MSG_WARNING("Missing vertex or track links when trying to calculate the conversion type. missingLinks=" << std::hex << missingLinks);
      ATH_MSG_WARNING("This may indicate that the DAOD is incorrectly missing some conversion vertices.");
      ATH_MSG_WARNING("This is your only warning, repeat occurrences will be reported at the DEBUG level.");
    } else {
      ATH_MSG_DEBUG("Missing vertex or track links when trying to calculate the conversion type. missingLinks=" << std::hex << missingLinks);
    }
    result.SF = 1;
    result.Total = 1;
    return CP::CorrectionCode::OutOfValidityRange;
  }
 
 
  // Call the ROOT tool to get an answer (for photons we need just the total)
  const int status = isConv ? m_rootTool_con->calculate(dataType, runnumber,
                                                        eta2, et, result, true)
                            : m_rootTool_unc->calculate(dataType, runnumber,
                                                        eta2, et, result, true);
 
  // if status 0 something went wrong
  if (!status) {
    result.SF = 1;
    result.Total = 1;
    return CP::CorrectionCode::OutOfValidityRange;
  }
 
  return CP::CorrectionCode::Ok;
}

callEvents()

void AsgPhotonEfficiencyCorrectionTool::callEvents ( columnar::EventContextRange  events ) const

override

Definition at line 502 of file AsgPhotonEfficiencyCorrectionTool.cxx.

{
  const Accessors& acc = *m_accessors;
  for (columnar::EventContextId event : events)
  {
    auto eventInfo = acc.eventInfoAcc(event);
    callSingleEvent (acc.photonsAcc(event), eventInfo);
  }
}

callSingleEvent()

void AsgPhotonEfficiencyCorrectionTool::callSingleEvent	(	columnar::EgammaRange	photons,
		columnar::EventInfoId	event
	)		const

Definition at line 479 of file AsgPhotonEfficiencyCorrectionTool.cxx.

{
  const Accessors& acc = *m_accessors;
  for (auto photon : photons)
  {
    double sf = 0;
    switch (getEfficiencyScaleFactor(photon, event, sf).code())
    {
      using enum CP::CorrectionCode::ErrorCode;
      case Ok:
        acc.sfDec(photon) = sf;
        acc.validDec(photon) = true;
        break;
      case OutOfValidityRange:
        acc.sfDec(photon) = sf;
        acc.validDec(photon) = false;
        break;
      default:
        throw std::runtime_error("Error in getEfficiencyScaleFactor");
    }
  }
}

declareGaudiProperty() [1/4]

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

declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  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, V, H > &  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, V, H > &  t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

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

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

getEfficiencyScaleFactor() [1/2]

CP::CorrectionCode AsgPhotonEfficiencyCorrectionTool::getEfficiencyScaleFactor	(	columnar::EgammaId	inputObject,
		columnar::EventInfoId	eventInfo,
		double &	efficiencyScaleFactor
	)		const

Definition at line 309 of file AsgPhotonEfficiencyCorrectionTool.cxx.

                                                                                                                                                                            {
  
  Result sfresult;
  CP::CorrectionCode status = calculate(inputObject, eventInfo, sfresult);
 
  if ( status != CP::CorrectionCode::Ok ) {
    return status;
  }
 
  if(m_appliedSystematics==nullptr){
    efficiencyScaleFactor=sfresult.SF;
    return CP::CorrectionCode::Ok;
  }
  
  //Get the result + the uncertainty
  float sigma(0);
  sigma=appliedSystematics().getParameterByBaseName("PH_EFF_"+m_sysSubstring+"Uncertainty");
  efficiencyScaleFactor=sfresult.SF+sigma*sfresult.Total;
  return  CP::CorrectionCode::Ok;
}

getEfficiencyScaleFactor() [2/2]

CP::CorrectionCode AsgPhotonEfficiencyCorrectionTool::getEfficiencyScaleFactor ( const xAOD::Egamma &  inputObject, double &  efficiencyScaleFactor  ) const

overridevirtual

Add some method for now as a first step to move the tool to then new interface.

Implements IAsgPhotonEfficiencyCorrectionTool.

Definition at line 296 of file AsgPhotonEfficiencyCorrectionTool.cxx.

                                                                                                                                              {
 
  // Get the run number
  const xAOD::EventInfo* eventInfo =
      evtStore()->retrieve<const xAOD::EventInfo>("EventInfo");
  if (!eventInfo) {
    ATH_MSG_ERROR("Could not retrieve EventInfo object!");
    return CP::CorrectionCode::Error;
  }
 
  return getEfficiencyScaleFactor(columnar::EgammaId{inputObject}, columnar::EventInfoId{*eventInfo}, efficiencyScaleFactor);
}

getEfficiencyScaleFactorError() [1/2]

CP::CorrectionCode AsgPhotonEfficiencyCorrectionTool::getEfficiencyScaleFactorError	(	columnar::EgammaId	inputObject,
		columnar::EventInfoId	eventInfo,
		double &	efficiencyScaleFactorError
	)		const

Definition at line 343 of file AsgPhotonEfficiencyCorrectionTool.cxx.

                                                                                                                                                                                      {   
 
  Result sfresult;
  CP::CorrectionCode status = calculate(inputObject, eventInfo, sfresult);
 
  if ( status != CP::CorrectionCode::Ok ) {
    return status;
  }
 
  efficiencyScaleFactorError=sfresult.Total;
  return  CP::CorrectionCode::Ok;
}

getEfficiencyScaleFactorError() [2/2]

CP::CorrectionCode AsgPhotonEfficiencyCorrectionTool::getEfficiencyScaleFactorError ( const xAOD::Egamma &  , double &    ) const

overridevirtual

Get the "photon scale factor error" as a return value.

Implements IAsgPhotonEfficiencyCorrectionTool.

Definition at line 330 of file AsgPhotonEfficiencyCorrectionTool.cxx.

                                                                                                                                                        {   
 
  // Get the run number
  const xAOD::EventInfo* eventInfo =
      evtStore()->retrieve<const xAOD::EventInfo>("EventInfo");
  if (!eventInfo) {
    ATH_MSG_ERROR("Could not retrieve EventInfo object!");
    return CP::CorrectionCode::Error;
  }
 
  return getEfficiencyScaleFactorError(columnar::EgammaId{inputObject}, columnar::EventInfoId{*eventInfo}, efficiencyScaleFactorError);
}

getFileName()

std::string AsgPhotonEfficiencyCorrectionTool::getFileName ( const std::string &  isoWP, const std::string &  trigWP, bool  isConv  )

private

Definition at line 436 of file AsgPhotonEfficiencyCorrectionTool.cxx.

                                                                                                                     {  
 
  // First locate the map file:
  std::string mapFileName = PathResolverFindCalibFile( m_mapFile );
  if(mapFileName.empty()){
    ATH_MSG_ERROR ( "Can't read map file " << m_mapFile );
    return mapFileName; // return an empty string
  }
  
  // Construct correction type:
  std::string correction_type = "ID_Tight";
  if(!trigWP.empty()) correction_type = "Trigger_"+trigWP+"_"+isoWP;
  else if(!isoWP.empty()) correction_type = "ISO_"+isoWP;
  
  // trigger SF same for con/unc photons
  if(trigWP.empty()) {correction_type += isConv ? "_Converted" : "_Unconverted";}
 
  std::string value;
  
  // Read the map file to find the proper correction filename
  std::ifstream is(mapFileName);
  if (!is.is_open()){
    ATH_MSG_ERROR("Couldn't read Map File" + mapFileName);
    return  "";
  }
  while (!is.eof()) {
    std::string strLine;
    getline(is,strLine);
    
    int nPos = strLine.find('=');
    
    if ((signed int)std::string::npos == nPos) continue; // no '=', invalid line;
    std::string strKey = strLine.substr(0,nPos);
    std::string strVal = strLine.substr(nPos + 1, strLine.length() - nPos + 1);
    
    // check if this is the right key, if the right one stop the search
    if(0==correction_type.compare(strKey)) {value=strVal; break;}
  }
  
  return value;
 
}

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 AsgPhotonEfficiencyCorrectionTool::initialize ( )

overridevirtual

Gaudi Service Interface method implementations.

Reimplemented from asg::AsgTool.

Definition at line 99 of file AsgPhotonEfficiencyCorrectionTool.cxx.

{
  // Resolve the paths to the input files
  std::vector < std::string > corrFileNameList;
 
  // First check if the tool is initialized using the input files or map
  if(!m_mapFile.empty()){ // using map file
         corrFileNameList.push_back(getFileName(m_isoWP,m_trigger,true)); // converted photons input
     corrFileNameList.push_back(getFileName(m_isoWP,m_trigger,false)); // unconverted photons input
  }
  else if(!m_corrFileNameConv.empty() && !m_corrFileNameUnconv.empty()){ // initialize the tool using input files (old scheme)
    corrFileNameList.push_back(m_corrFileNameConv);
    corrFileNameList.push_back(m_corrFileNameUnconv);
  }
  else{
      ATH_MSG_ERROR ( "Fail to resolve input file name, check if you set MapFilePath or CorrectionFileName properly" );
      return StatusCode::FAILURE ; 
  }
 
  // once the input files are retrieved, update the path using PathResolver or TOOL/data folder
  for (auto & i : corrFileNameList){
 
    //Using the PathResolver to locate the file
    std::string filename = PathResolverFindCalibFile( i );
 
    if (filename.empty()){
      ATH_MSG_ERROR ( "Could NOT resolve file name " << i );
      return StatusCode::FAILURE ;
    } else{
      ATH_MSG_INFO(" Using path = "<<filename);
    }
 
    i = filename;
 
  }
   
  // Set prefix for sustematics if this is ISO, Trigger or ID SF
  if( corrFileNameList[0].find(m_file_prefix_Trig) != std::string::npos) m_sysSubstring="TRIGGER_";
  if( corrFileNameList[0].find(m_file_prefix_ID) != std::string::npos) m_sysSubstring="ID_";
  if( corrFileNameList[0].find(m_file_prefix_ISO) != std::string::npos) m_sysSubstring="ISO_";
  if( corrFileNameList[0].find(m_file_prefix_TrigEff) != std::string::npos) m_sysSubstring="TRIGGER_";
  if(m_sysSubstring.empty()) {ATH_MSG_ERROR ( "Invalid input file" ); return StatusCode::FAILURE;}
 
  // Configure the underlying Root tool
  m_rootTool_con->addFileName( corrFileNameList[0] );
  m_rootTool_unc->addFileName( corrFileNameList[1] );
 
  // Forward the message level
  m_rootTool_con->msg().setLevel(this->msg().level());
  m_rootTool_unc->msg().setLevel(this->msg().level());
 
  // We need to initialize the underlying ROOT TSelectorTool
  if ( (0 == m_rootTool_con->initialize()) || (0 == m_rootTool_unc->initialize()) )
    {
      ATH_MSG_ERROR("Could not initialize the TElectronEfficiencyCorrectionTool!");
      return StatusCode::FAILURE;
    }
 
  // get the map of pt/eta bins
  // let's start with converted 
  m_rootTool_con->getNbins(m_pteta_bins);
  std::map<float, std::vector<float>> pteta_bins_unc;
  // now let's get unconverted
  m_rootTool_unc->getNbins(pteta_bins_unc);
  // let's loop the unconverted map and copy over to the common one
  // in this tool we only ever care about et, so don't care if we overwrite eta information
  for (const auto& [pt_unc, eta_unc]: pteta_bins_unc) {
    m_pteta_bins[pt_unc] = eta_unc;
  }
 
  // Add the recommended systematics to the registry
  if ( registerSystematics() != StatusCode::SUCCESS) {
    return StatusCode::FAILURE;
  }
  
  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.

isAffectedBySystematic()

bool AsgPhotonEfficiencyCorrectionTool::isAffectedBySystematic ( const CP::SystematicVariation &  systematic ) const

overridevirtual

The methods below should notify the user of what is actually in the list , without him having to go in the wiki.

returns: whether this tool is affected by the given systematic

Implements CP::ISystematicsTool.

Definition at line 368 of file AsgPhotonEfficiencyCorrectionTool.cxx.

                                                                                                              {
    if(!systematic.empty()){
        CP::SystematicSet sys = affectingSystematics();
        return sys.find(systematic) != sys.end();
    }
    return true;
}

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

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.

print() [1/2]

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

print() [2/2]

virtual void asg::IAsgTool::print ( ) const

pure virtualinherited

Print the state of the tool.

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

recommendedSystematics()

CP::SystematicSet AsgPhotonEfficiencyCorrectionTool::recommendedSystematics ( ) const

overridevirtual

returns: the list of all systematics this tool recommends to use

Implements CP::IReentrantSystematicsTool.

Definition at line 399 of file AsgPhotonEfficiencyCorrectionTool.cxx.

                                                                                {
  CP::SystematicSet mySysSet;
  mySysSet.insert(CP::SystematicVariation("PH_EFF_"+m_sysSubstring+"Uncertainty", 1));
  mySysSet.insert(CP::SystematicVariation("PH_EFF_"+m_sysSubstring+"Uncertainty", -1));
   
  return mySysSet;
}

registerSystematics()

StatusCode AsgPhotonEfficiencyCorrectionTool::registerSystematics

(

)

Register the systematics with the registry and add them to the recommended list.

Definition at line 389 of file AsgPhotonEfficiencyCorrectionTool.cxx.

                                                                  {
  CP::SystematicRegistry& registry = CP::SystematicRegistry::getInstance();
  if (registry.registerSystematics(*this) != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("Failed to add systematic to list of recommended systematics.");
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

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_accessors

std::unique_ptr<Accessors> AsgPhotonEfficiencyCorrectionTool::m_accessors {std::make_unique<Accessors>(*this)}

private

Definition at line 180 of file AsgPhotonEfficiencyCorrectionTool.h.

m_allowMissingLinks

Gaudi::Property<bool> AsgPhotonEfficiencyCorrectionTool::m_allowMissingLinks { this, "AllowMissingLinks", false, "Allow missing links in the input objects. This should only be used by experts running on expert formats." }

private

Definition at line 152 of file AsgPhotonEfficiencyCorrectionTool.h.

m_appliedSystematics

CP::SystematicSet* AsgPhotonEfficiencyCorrectionTool::m_appliedSystematics = nullptr

private

Currently applied systematics.

Definition at line 104 of file AsgPhotonEfficiencyCorrectionTool.h.

m_corrFileNameConv

std::string AsgPhotonEfficiencyCorrectionTool::m_corrFileNameConv

private

The list of input file names.

Definition at line 121 of file AsgPhotonEfficiencyCorrectionTool.h.

m_corrFileNameUnconv

std::string AsgPhotonEfficiencyCorrectionTool::m_corrFileNameUnconv

private

Definition at line 122 of file AsgPhotonEfficiencyCorrectionTool.h.

m_dataTypeOverwrite

int AsgPhotonEfficiencyCorrectionTool::m_dataTypeOverwrite

private

Force the data type to a given value.

Definition at line 131 of file AsgPhotonEfficiencyCorrectionTool.h.

m_defaultRandomRunNumber

int AsgPhotonEfficiencyCorrectionTool::m_defaultRandomRunNumber

private

Definition at line 147 of file AsgPhotonEfficiencyCorrectionTool.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_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_file_prefix_ID

std::string AsgPhotonEfficiencyCorrectionTool::m_file_prefix_ID ="efficiencySF.offline."

private

Definition at line 113 of file AsgPhotonEfficiencyCorrectionTool.h.

m_file_prefix_ISO

std::string AsgPhotonEfficiencyCorrectionTool::m_file_prefix_ISO ="efficiencySF.Isolation."

private

Definition at line 114 of file AsgPhotonEfficiencyCorrectionTool.h.

m_file_prefix_Trig

std::string AsgPhotonEfficiencyCorrectionTool::m_file_prefix_Trig ="efficiencySF."

private

Definition at line 115 of file AsgPhotonEfficiencyCorrectionTool.h.

m_file_prefix_TrigEff

std::string AsgPhotonEfficiencyCorrectionTool::m_file_prefix_TrigEff ="efficiency."

private

Definition at line 116 of file AsgPhotonEfficiencyCorrectionTool.h.

m_isoWP

std::string AsgPhotonEfficiencyCorrectionTool::m_isoWP

private

Isolation working point.

Definition at line 134 of file AsgPhotonEfficiencyCorrectionTool.h.

m_mapFile

std::string AsgPhotonEfficiencyCorrectionTool::m_mapFile

private

map filename

Definition at line 140 of file AsgPhotonEfficiencyCorrectionTool.h.

m_pteta_bins

std::map<float, std::vector<float> > AsgPhotonEfficiencyCorrectionTool::m_pteta_bins

private

Definition at line 143 of file AsgPhotonEfficiencyCorrectionTool.h.

m_removeTRTConversion

bool AsgPhotonEfficiencyCorrectionTool::m_removeTRTConversion

private

Definition at line 150 of file AsgPhotonEfficiencyCorrectionTool.h.

m_resultName

std::string AsgPhotonEfficiencyCorrectionTool::m_resultName

private

The string for the result.

Definition at line 128 of file AsgPhotonEfficiencyCorrectionTool.h.

m_resultPrefix

std::string AsgPhotonEfficiencyCorrectionTool::m_resultPrefix

private

The prefix string for the result.

Definition at line 125 of file AsgPhotonEfficiencyCorrectionTool.h.

m_rootTool_con

Root::TElectronEfficiencyCorrectionTool* AsgPhotonEfficiencyCorrectionTool::m_rootTool_con

private

Definition at line 98 of file AsgPhotonEfficiencyCorrectionTool.h.

m_rootTool_unc

Root::TElectronEfficiencyCorrectionTool* AsgPhotonEfficiencyCorrectionTool::m_rootTool_unc

private

Pointer to the underlying ROOT based tool.

Definition at line 97 of file AsgPhotonEfficiencyCorrectionTool.h.

m_sysSubstring

std::string AsgPhotonEfficiencyCorrectionTool::m_sysSubstring

private

Definition at line 107 of file AsgPhotonEfficiencyCorrectionTool.h.

m_systFilter

std::unordered_map<CP::SystematicSet, CP::SystematicSet> AsgPhotonEfficiencyCorrectionTool::m_systFilter

private

Systematics filter map.

Definition at line 101 of file AsgPhotonEfficiencyCorrectionTool.h.

m_trigger

std::string AsgPhotonEfficiencyCorrectionTool::m_trigger

private

Trigger name for trigger SF.

Definition at line 137 of file AsgPhotonEfficiencyCorrectionTool.h.

m_useRandomRunNumber

bool AsgPhotonEfficiencyCorrectionTool::m_useRandomRunNumber

private

Definition at line 146 of file AsgPhotonEfficiencyCorrectionTool.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:

• AsgPhotonEfficiencyCorrectionTool.h
• AsgPhotonEfficiencyCorrectionTool.cxx