CP::ElectronChargeEfficiencyCorrectionTool Class Reference

#include <ElectronChargeEfficiencyCorrectionTool.h>

Inheritance diagram for CP::ElectronChargeEfficiencyCorrectionTool:

Collaboration diagram for CP::ElectronChargeEfficiencyCorrectionTool:

Public Member Functions
virtual StatusCode	initialize () override final
	Gaudi Service Interface method implementations.
virtual CP::CorrectionCode	getEfficiencyScaleFactor (const xAOD::Electron &inputObject, double &sf) const override final
	Retrieve the Scale factor.
virtual CP::CorrectionCode	applyEfficiencyScaleFactor (const xAOD::Electron &inputObject) const override final
	Decorate the electron.
virtual bool	isAffectedBySystematic (const SystematicVariation &systematic) const override final
	Returns whether this tool is affected by the given systematics.
virtual SystematicSet	affectingSystematics () const override final
	Returns the list of all systematics this tool can be affected by.
virtual CP::SystematicSet	recommendedSystematics () const override final
	Returns the list of all systematics this tool recommends to use.
virtual StatusCode	applySystematicVariation (const SystematicSet &systConfig) override final
	effects: configure this tool for the given list of systematic variations.
virtual const CP::SystematicSet &	appliedSystematics () const override final
	returns: the currently applied systematics
virtual int	systUncorrVariationIndex (const xAOD::Electron &) const override final
virtual CP::CorrectionCode	getEfficiencyScaleFactor (const double, const double, const unsigned int, double &) const override final
virtual int	getNumberOfToys () const override final
virtual void	printCorrelationModels () const override final
	print available/implemented correlation models
virtual void	print () const
	Print the state of the tool.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
virtual ASG_TOOL_CLASS(ElectronChargeEfficiencyCorrectionTool, IAsgElectronEfficiencyCorrectionTool) public	~ElectronChargeEfficiencyCorrectionTool ()
	Standard destructor.
StatusCode	registerSystematics ()
float	getChargeFlipRate (double eta, double pt, TH2 *hrates, double &flipRate) const
	Get the charge flip rate rate given pt, eta, histogram.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
int	m_dataTypeOverwrite
	Force the data type to a given value.
std::string	m_eventInfoCollectionName
	The Event info collection name.
std::map< std::string, std::vector< TH2 * > >	m_SF_SS
	Histogram that holds the correction rates for Monte Carlo.
std::map< std::string, std::vector< TH2 * > >	m_SF_OS
std::vector< unsigned int >	m_RunNumbers
bool	m_useRandomRunNumber
unsigned int	m_defaultRandomRunNumber
std::string	m_filename
	The name of the input file that contains the histograms.
std::string	m_workingPoint
	The name of the folder defining the LH/iso working point.
double	m_eta_lowlimit
	Lower limit of eta range where corrections are available; taken from histogram.
double	m_eta_uplimit
	Upper limit of eta range where corrections are available; taken from histogram.
double	m_pt_lowlimit
	Lower limit of pt range where corrections are available; taken from histogram.
double	m_pt_uplimit
	Upper limit of pt range where corrections are available; taken from histogram.
float	m_gevmev
	Factor for GeV <-> MeV switching.
std::vector< std::string >	m_systematics
std::map< CP::SystematicSet, CP::SystematicSet >	m_filtered_sys_sets
CP::SystematicSet	m_mySysConf
CP::SystematicSet	m_affectingSys
CP::SystematicSet *	m_appliedSystematics
	Currently applied systematics.
std::string	m_sf_decoration_name
	Decorator.
SG::AuxElement::Decorator< float > *	m_sfDec
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 26 of file ElectronChargeEfficiencyCorrectionTool.h.

Member Typedef Documentation

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Function Documentation

affectingSystematics()

CP::SystematicSet ElectronChargeEfficiencyCorrectionTool::affectingSystematics ( ) const

finaloverridevirtual

Returns the list of all systematics this tool can be affected by.

Implements CP::IReentrantSystematicsTool.

Definition at line 633 of file ElectronChargeEfficiencyCorrectionTool.cxx.

{
  CP::SystematicSet result;
  result.insert(SystematicVariation("EL_CHARGEID_STAT", 1));
  result.insert(SystematicVariation("EL_CHARGEID_STAT", -1));
 
  for (unsigned int i = 0; i < m_systematics.size(); i++) {
    result.insert(SystematicVariation(
      Form("EL_CHARGEID_SYS%s", m_systematics.at(i).c_str()), 1));
    result.insert(SystematicVariation(
      Form("EL_CHARGEID_SYS%s", m_systematics.at(i).c_str()), -1));
  }
  return result;
}

appliedSystematics()

virtual const CP::SystematicSet & CP::ElectronChargeEfficiencyCorrectionTool::appliedSystematics ( ) const

inlinefinaloverridevirtual

returns: the currently applied systematics

Implements IAsgElectronEfficiencyCorrectionTool.

Definition at line 68 of file ElectronChargeEfficiencyCorrectionTool.h.

  {
    return *m_appliedSystematics;
  }

applyEfficiencyScaleFactor()

CP::CorrectionCode ElectronChargeEfficiencyCorrectionTool::applyEfficiencyScaleFactor ( const xAOD::Electron & inputObject ) const

finaloverridevirtual

Decorate the electron.

Implements IAsgElectronEfficiencyCorrectionTool.

Definition at line 581 of file ElectronChargeEfficiencyCorrectionTool.cxx.

{
  ATH_MSG_DEBUG(
    "In "
    "CP::ElectronChargeEfficiencyCorrectionTool::applyEfficiencyScaleFactor("
    "const xAOD::IParticle& part) const");
  double sf = 0.0;
  CP::CorrectionCode result = this->getEfficiencyScaleFactor(part, sf);
  // Decorate the electron
  (*m_sfDec)(part) = static_cast<float>(sf);
  return result;
}

applySystematicVariation()

StatusCode ElectronChargeEfficiencyCorrectionTool::applySystematicVariation ( const SystematicSet & systConfig )

finaloverridevirtual

effects: configure this tool for the given list of systematic variations.

any requested systematics that are not affecting this tool will be silently ignored (unless they cause other errors). failures: systematic unknown failures: requesting multiple variations on the same systematic (e.g. up & down) failures: requesting an unsupported variation on an otherwise supported systematic (e.g. a 2 sigma variation and the tool only supports 1 sigma variations) failures: unsupported combination of supported systematic failures: other tool specific errors

Implements CP::ISystematicsTool.

Definition at line 660 of file ElectronChargeEfficiencyCorrectionTool.cxx.

{
 
  if (!SystematicSet::filterForAffectingSystematics(
        systConfig, m_affectingSys, m_mySysConf)) {
    ATH_MSG_ERROR(
      "Unsupported combination of systematics passed to the tool! ");
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ 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

getChargeFlipRate()

float ElectronChargeEfficiencyCorrectionTool::getChargeFlipRate ( double eta, double pt, TH2 * hrates, double & flipRate ) const

private

Get the charge flip rate rate given pt, eta, histogram.

Definition at line 597 of file ElectronChargeEfficiencyCorrectionTool.cxx.

{
  ATH_MSG_VERBOSE(" -> in: getChargeFlipRate(" << pt << ", " << eta
                                               << " TH2, double&)");
 
  if (pt > m_pt_uplimit)
    pt = m_pt_uplimit * 0.999;
 
  int bin2D = hrates->FindBin(pt, eta);
  flipRate = hrates->GetBinContent(bin2D);
 
  ATH_MSG_VERBOSE(" -> flipRate is " << flipRate << ", for histogram "
                                     << hrates->GetName());
 
  return 0;
}

getEfficiencyScaleFactor() [1/2]

virtual CP::CorrectionCode CP::ElectronChargeEfficiencyCorrectionTool::getEfficiencyScaleFactor ( const double , const double , const unsigned int , double &  ) const

inlinefinaloverridevirtual

Implements IAsgElectronEfficiencyCorrectionTool.

Definition at line 81 of file ElectronChargeEfficiencyCorrectionTool.h.

                                   {
    ATH_MSG_ERROR(
        "No toysimplemented in "
        "ElectronChargeEfficiencyCorrectionTool");
    return CP::CorrectionCode::Error;
  }

getEfficiencyScaleFactor() [2/2]

CP::CorrectionCode ElectronChargeEfficiencyCorrectionTool::getEfficiencyScaleFactor ( const xAOD::Electron & inputObject, double & sf ) const

finaloverridevirtual

Retrieve the Scale factor.

STAT

STAT

Implements IAsgElectronEfficiencyCorrectionTool.

Definition at line 342 of file ElectronChargeEfficiencyCorrectionTool.cxx.

{
 
  // initialize the SF at 1
  sf = 1.0;
 
  // checking on the truth electron: up to now if this is not a good ele it's
  // returning
  bool goodEle = false;
  CP::CorrectionCode goodEle_result =
    ElectronEfficiencyHelpers::isGoodEle( ele, goodEle); 
  if (goodEle_result != CP::CorrectionCode::Ok) {
    sf = -999.0;
    ATH_MSG_DEBUG("This is the check of goodeleCC in getscalefactor. Scale "
                  "factor set to -999");
    return goodEle_result;
  }
 
  if (!goodEle) {
    // electron is background electron and should not be corrected
    return CP::CorrectionCode::Ok;
    ATH_MSG_DEBUG("Here goodele is false but CC ok");
  }
 
  // taking reconstructed variables
  int reco_ele_charge = ele.charge();
  const double ele_pt = ele.pt() * m_gevmev;
  const double ele_eta = std::abs(ele.caloCluster()->etaBE(2));
 
  // getting the truth charge
  int truth_ele_charge = 9999;
  CP::CorrectionCode charge_result = 
    ElectronEfficiencyHelpers::getEleTruthCharge( ele, truth_ele_charge);
  if (charge_result != CP::CorrectionCode::Ok) {
    sf = -9999.0;
    ATH_MSG_VERBOSE("This is check of geteletruthchargeCC in getscalefactor. "
                    "Scale factor set to -9999");
    return charge_result;
  }
 
  if (truth_ele_charge == 0) {
    ATH_MSG_DEBUG("Here truth charge is =0!!");
    return CP::CorrectionCode::Ok;
  }
 
  ATH_MSG_DEBUG("Reco charge = " << reco_ele_charge
                                 << "; Truth charge = " << truth_ele_charge);
 
  // getting the rates from file....
  float retVal(0.0);

  // here determine, WHICH of the [histid] to choose (after cuuts on runnumber
  // etc....)
  std::string cutRunNumber = "all";
 
  if (!m_RunNumbers.empty()) {
    unsigned int runnumber = m_defaultRandomRunNumber;
    ATH_MSG_DEBUG("RandomRunNumber: " << runnumber << " "
                                      << m_useRandomRunNumber);
    if (m_useRandomRunNumber) {
      const xAOD::EventInfo* eventInfo =
        evtStore()->retrieve<const xAOD::EventInfo>(m_eventInfoCollectionName);
      if (!eventInfo) {
        ATH_MSG_ERROR("Could not retrieve EventInfo object!");
        sf = 1.0;
        return CP::CorrectionCode::Error;
      }
      static const SG::AuxElement::Accessor<unsigned int> randomrunnumber(
        "RandomRunNumber");
      if (!randomrunnumber.isAvailable(*eventInfo)) {
        sf = 1.0;
        ATH_MSG_WARNING(
          "Pileup tool not run before using ElectronEfficiencyTool! SFs do not "
          "reflect PU distribution in data");
        return CP::CorrectionCode::Error;
      }
      runnumber = randomrunnumber(*(eventInfo));
    }
    ATH_MSG_DEBUG("Number of RunNumbers in file: " << m_RunNumbers.size());
    for (std::size_t r = 0; r < m_RunNumbers.size(); r++) {
      ATH_MSG_DEBUG( " - " << m_RunNumbers.at(r));
    }
    ATH_MSG_VERBOSE("DONE");
 
    bool isInRunNumberRange = false;
    for ( std::size_t r=0; r<m_RunNumbers.size()-1; r+=2 ){
      // increment by two, run numbers always come in pairs (upper and lower bound specified in the histogram name)
 
      if ( runnumber >= (unsigned int)m_RunNumbers.at(r) && 
       runnumber <= (unsigned int)m_RunNumbers.at(r+1) ) {
        cutRunNumber.clear();
        cutRunNumber =
          Form("RunNumber%d_%d", m_RunNumbers.at(r), m_RunNumbers.at(r + 1));
        ATH_MSG_DEBUG("Random run number lies in range " << m_RunNumbers.at(r) << " " << m_RunNumbers.at(r+1));
    isInRunNumberRange = true;
      }
    }
 
    if (runnumber < m_RunNumbers.at(0) ||
        (runnumber > m_RunNumbers.at(m_RunNumbers.size() - 1))) {
      ATH_MSG_DEBUG("RunNumber " << runnumber << " is not in valid RunNumber Range ");
      sf = 1.0;
      return CP::CorrectionCode::OutOfValidityRange;
    }
    
    if ( !isInRunNumberRange ) {
      return CP::CorrectionCode::OutOfValidityRange;
    }
  }
 
  // check if electron is within recommendations in eta/Et
  if ( ele_eta < m_eta_lowlimit || ele_eta > m_eta_uplimit ) {
 
    ATH_MSG_DEBUG("Got an electron outside of the range of eta validity " << ele_eta);
    return CP::CorrectionCode::OutOfValidityRange;
  }
 
  if ( ele_pt < m_pt_lowlimit ) {
 
    ATH_MSG_DEBUG("Got an electron outside of the range of pt validity: pt lower than lower limit");
    return CP::CorrectionCode::OutOfValidityRange;
  }
 
  // Determine WHICH histograms to use here
  const std::vector<TH2*>& SShistograms = m_SF_SS.at(cutRunNumber.c_str());
  const std::vector<TH2*>& OShistograms = m_SF_OS.at(cutRunNumber.c_str());
 
  // here check OS or SS
  bool isOS = false;
 
  if (truth_ele_charge * reco_ele_charge > 0)
    isOS = true;
 
  if (isOS) {
    retVal = this->getChargeFlipRate(ele_eta, ele_pt, OShistograms.at(0), sf);
    if (retVal != 0) {
      sf = -9999.0;
      return CP::CorrectionCode::OutOfValidityRange;
    }
  } else {
    ATH_MSG_DEBUG("Get SS his");
    retVal = this->getChargeFlipRate(ele_eta, ele_pt, SShistograms.at(0), sf);
    if (retVal != 0) {
      sf = -9999.0;
      return CP::CorrectionCode::OutOfValidityRange;
    }
  }
 
  ATH_MSG_DEBUG("eta: " << ele_eta << "  pt: " << ele_pt);
  ATH_MSG_DEBUG("SF Rates---- . SF: " << sf);
 
  // Systematics
  // ------------------------------------------------------------------------------------------------------
  double val_stat;

  if (isOS) {
    retVal =
      this->getChargeFlipRate(ele_eta, ele_pt, OShistograms.at(1), val_stat);
    if (retVal != 0) {
      sf = -9999.0;
      return CP::CorrectionCode::OutOfValidityRange;
    }
  } else {
    ATH_MSG_DEBUG("Get SS his");
    retVal =
      this->getChargeFlipRate(ele_eta, ele_pt, SShistograms.at(1), val_stat);
    if (retVal != 0) {
      sf = -9999.0;
      return CP::CorrectionCode::OutOfValidityRange;
    }
  }
 
  std::vector<float> systs;
  double val_sys{ 0.0 };
  for (unsigned int s = 2; s < OShistograms.size(); s++) {
    if (isOS) {
      retVal =
        this->getChargeFlipRate(ele_eta, ele_pt, OShistograms.at(s), val_sys);
      if (retVal != 0) {
        val_sys = -9999.0;
        return CP::CorrectionCode::OutOfValidityRange;
      }
    } else {
      ATH_MSG_DEBUG("Get SS his");
      retVal =
        this->getChargeFlipRate(ele_eta, ele_pt, SShistograms.at(s), val_sys);
      if (retVal != 0) {
        val_sys = -9999.0;
        return CP::CorrectionCode::OutOfValidityRange;
      }
    }
    systs.push_back(static_cast<float>(val_sys));
  }
 
  ATH_MSG_DEBUG(" ... nominal SF: " << sf);
 
  if (m_mySysConf.empty()) {
    ATH_MSG_DEBUG(" ... nominal SF: " << sf);
  } else if (*(m_mySysConf.begin()) ==
             SystematicVariation("EL_CHARGEID_STAT", 1)) {
    sf = (sf + (val_stat));
    ATH_MSG_DEBUG("SF after STATup = " << sf);
  } else if (*(m_mySysConf.begin()) ==
             SystematicVariation("EL_CHARGEID_STAT", -1)) {
    sf = (sf - (val_stat));
    ATH_MSG_DEBUG("SF after STATdown = " << sf);
  } else {
 
    for (unsigned int i = 0; i < m_systematics.size(); i++) {
      if (*(m_mySysConf.begin()) ==
          SystematicVariation(
            Form("EL_CHARGEID_SYS%s", m_systematics.at(i).c_str()), 1)) {
        sf = (sf + (val_sys));
        ATH_MSG_DEBUG("SF after SYSup = " << sf);
      }
 
      if (*(m_mySysConf.begin()) ==
          SystematicVariation(
            Form("EL_CHARGEID_SYS%s", m_systematics.at(i).c_str()), -1)) {
        sf = (sf - (val_sys));
        ATH_MSG_DEBUG("SF after SYSdown = " << sf);
      }
    }
 
  }
 
  return CP::CorrectionCode::Ok;
}

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
   }

getNumberOfToys()

virtual int CP::ElectronChargeEfficiencyCorrectionTool::getNumberOfToys ( ) const

inlinefinaloverridevirtual

Implements IAsgElectronEfficiencyCorrectionTool.

Definition at line 90 of file ElectronChargeEfficiencyCorrectionTool.h.

  {
    ATH_MSG_ERROR(
        "No toysimplemented in "
        "ElectronChargeEfficiencyCorrectionTool");
    return -1;
  };

getProperty()

template<class T>

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

inherited

Get one of the tool's properties.

initialize()

StatusCode ElectronChargeEfficiencyCorrectionTool::initialize ( void )

finaloverridevirtual

Gaudi Service Interface method implementations.

STAT ERROR

STAT ERROR

end // if ( name.find(Form("SYST") ) != std::string::npos)

here: need to use iterator over map!!!

Reimplemented from asg::AsgTool.

Definition at line 88 of file ElectronChargeEfficiencyCorrectionTool.cxx.

{
  ATH_MSG_DEBUG("initializing");
 
  // initialize the random number generator (used in case of charge flip
  // approach)
  // m_Rndm = new TRandom3(1);
 
  if (m_sfDec)
    delete m_sfDec;
  m_sfDec = new SG::AuxElement::Decorator<float>(m_sf_decoration_name); // xxxx
 
  // Resolve the path to the input file for the charge flip rates
  const std::string rootfilename = PathResolverFindCalibFile(m_filename);
  if (m_filename.empty()) {
    ATH_MSG_ERROR(" PathResolver was not able to find the file ... aborting");
    return StatusCode::FAILURE;
  }
 
  // Getting the root file and histograms
  TFile* rootFile = TFile::Open(rootfilename.c_str());
 
  // protection against bad file
  if (rootFile == nullptr) {
    ATH_MSG_ERROR(" Was not able to open file: " << rootfilename
                                                 << " ...... aborting");
    return StatusCode::FAILURE;
  }

  //
  // explanation: attempt to loop generally over a file
  // -- if certain SINGALWORD is present -- then this is taken as a signal,
  // that this is another dimension... can be dynamically added.
  // e.g.
  // SFSyst<number>_RunNumber<minRN>-<maxRN>_Nvtx<minNvtx>-<maxNvtx>
  // SFStat_RunNumber<minRN>-<maxRN>_Nvtx<minNvtx>-<maxNvtx>
  // SFCentral_RunNumber<minRN>-<maxRN>_Nvtx<minNvtx>-<maxNvtx>
 
  //     Then can create a key that will dynamically give us access to a map:
  //    std::map<std::string key, std::vector<TH2 *>> m_SF_SS;     // keys (e.g.
  //    RunNumber223333_319200_Nvtx0_10_Phi1.5_1.6) mapping to vector of SF
  //    histograms --> vector m_SF: 0=nominal, 1=stat, 2,3,4...n=syst
  //     std::map<std::string key, std::vector<TH2 *>> m_SF_OS;     // keys
  //     (e.g. RunNumber223333_319200_Nvtx0_10_Phi1.5_1.6) mapping to vector of
  //     SF histograms --> vector m_SF: 0=nominal, 1=stat, 2,3,4...n=syst
  // TFile*         data/ChMisIDSF_TightLL_FixedCutTight.root
  //  KEY: TH2F     SFCentral_RunNumber296939_311481_SS;1
  //  SFCentral_RunNumber296939_311481_SS KEY: TH2F
  //  SFCentral_RunNumber296939_311481_OS;1 SFCentral_RunNumber296939_311481_OS
  //  KEY: TH2F     STAT_RunNumber296939_311481_SS;1
  //  STAT_RunNumber296939_311481_SS KEY: TH2F STAT_RunNumber296939_311481_OS;1
  //  STAT_RunNumber296939_311481_OS KEY: TH2F
  //  SYST_RunNumber296939_311481_total_SS;1  SYST_RunNumber296939_311481_SS:
  //  total KEY: TH2F     SYST_RunNumber296939_311481_total_OS;1
  //  SYST_RunNumber296939_311481_OS: total
 
  m_SF_SS.clear();
  m_SF_OS.clear();
  TList* keyListfolder = rootFile->GetListOfKeys();
  std::vector<std::string> names;
  std::set<std::string> set_systematics;
 
  names.reserve(keyListfolder->GetEntries());
  for (int j = 0; j < keyListfolder->GetEntries(); j++) {
    names.emplace_back((keyListfolder->At(j)->GetName()));
  }
  std::sort(names.begin(), names.end());
 
  for (unsigned int j = 0; j < names.size(); j++) {
 
    std::string name = names.at(j);
    ATH_MSG_DEBUG("Got ROOT object with name: " << name);
    if (name.find(Form("SFCentral_")) != std::string::npos) {
      ATH_MSG_VERBOSE("Found name 'SFCentral_' in ROOT object name");
      // Check for opposite-sign (=opposite-charge)
      bool isOS = false;
      if (name.find(Form("_OS")) != std::string::npos) {
        isOS = true;
        ATH_MSG_VERBOSE("Found name '_OS' in ROOT object name");
      }
      if (isOS) {
        std::string histid = (names.at(j));
        histid.erase(0, 10);
        histid.erase(histid.size() - 3, 3); // remove _SS, _OS
        ATH_MSG_VERBOSE("Using histid: " << histid);
 
        if (histid.find("RunNumber") != std::string::npos) {
          ATH_MSG_VERBOSE("Found name 'RunNumber' in histid");
          std::string runlow = histid;
          runlow.erase(histid.find(Form("RunNumber")), 9);
          runlow.erase(runlow.find('_'), runlow.size());
          m_RunNumbers.push_back(
            static_cast<unsigned int>(atoi(runlow.c_str())));
          std::string runhigh = histid;
          runhigh.erase(histid.find(Form("RunNumber")), 9);
          runhigh.erase(0, runhigh.find('_') + 1);
          m_RunNumbers.push_back(
            static_cast<unsigned int>(atoi(runhigh.c_str())));
        }
        ATH_MSG_VERBOSE("Using histid (OS hid): " << histid);
        m_SF_OS[histid].push_back((TH2*)rootFile->Get(names.at(j).c_str()));
      } else {
        std::string histid = (names.at(j));
        histid.erase(0, 10);
        histid.erase(histid.size() - 3, 3); // remove _SS, _OS
        ATH_MSG_VERBOSE("Using histid (do we this in ? SS): " << histid);
        m_SF_SS[histid].push_back((TH2*)rootFile->Get(names.at(j).c_str()));
      }
    } 

    if (name.find(Form("STAT_")) != std::string::npos) {
      ATH_MSG_VERBOSE("Found name 'STAT_' in ROOT object name");
      bool isOS = false;
      if (name.find(Form("_OS")) != std::string::npos) {
        isOS = true;
        ATH_MSG_VERBOSE("Found name '_OS' in ROOT object name");
      }
      if (isOS) {
        std::string histid = (names.at(j));
        histid.erase(0, 5);
        histid.erase(histid.size() - 3, 3); // remove _SS, _OS
        ATH_MSG_VERBOSE("Using histid: " << histid);
 
        if (histid.find("RunNumber") != std::string::npos) {
          ATH_MSG_VERBOSE("Found name 'RunNumber' in histid");
          std::string runlow = histid;
          runlow.erase(histid.find(Form("RunNumber")), 9);
          runlow.erase(runlow.find('_'), runlow.size());
          //          m_RunNumbers.push_back( static_cast<unsigned
          //          int>(atoi(runlow.c_str())) );
          std::string runhigh = histid;
          runhigh.erase(histid.find(Form("RunNumber")), 9);
          runhigh.erase(0, runhigh.find('_') + 1);
          //          m_RunNumbers.push_back( static_cast<unsigned
          //          int>(atoi(runhigh.c_str())) );
        }
        ATH_MSG_VERBOSE("Using histid (OS hid): " << histid);
        m_SF_OS[histid].push_back((TH2*)rootFile->Get(names.at(j).c_str()));
      } else {
        std::string histid = (names.at(j));
        ATH_MSG_VERBOSE("Found  histid: " << histid);
        histid.erase(0, 5);
        histid.erase(histid.size() - 3, 3); // remove _SS, _OS
        ATH_MSG_VERBOSE("Using histid (do we this in ? SS): " << histid);
        m_SF_SS[histid].push_back((TH2*)rootFile->Get(names.at(j).c_str()));
      }
 
    } 

    if (name.find(Form("SYST")) != std::string::npos) {
      ATH_MSG_VERBOSE("Found name 'SYST' in ROOT object name");
      bool isOS = false;
      if (name.find(Form("_OS")) != std::string::npos) {
        isOS = true;
        ATH_MSG_VERBOSE("Found name '_OS' in ROOT object name");
      }
      if (isOS) {
        std::string histid = (names.at(j));
        histid.erase(0, 4);
        histid.erase(histid.size() - 3, 3); // remove _SS, _OS
 
        std::string sysname = histid;
        sysname.erase(sysname.find('_'), sysname.size());
        set_systematics.insert(sysname);
 
        histid.erase(0, histid.find('_') + 1); // remove _SS, _OS
        ATH_MSG_VERBOSE("Using syst histid: " << histid);
 
        if (histid.find("RunNumber") != std::string::npos) {
          std::string runlow = histid;
          runlow.erase(histid.find(Form("RunNumber")), 9);
          runlow.erase(runlow.find('_'), runlow.size());
          //        m_RunNumbers.push_back( static_cast<unsigned
          //        int>(atoi(runlow.c_str())) );
          std::string runhigh = histid;
          runhigh.erase(histid.find(Form("RunNumber")), 9);
          runhigh.erase(0, runhigh.find('_') + 1);
          //      m_RunNumbers.push_back( static_cast<unsigned
          //      int>(atoi(runhigh.c_str())) );
        }
        ATH_MSG_VERBOSE("Using histid (OS hid): " << histid);
        m_SF_OS[histid].push_back((TH2*)rootFile->Get(names.at(j).c_str()));
      } else {
        std::string histid = (names.at(j));
        histid.erase(0, 4);
        histid.erase(histid.size() - 3, 3);    // remove _SS, _OS
        histid.erase(0, histid.find('_') + 1); // remove _SS, _OS
        ATH_MSG_VERBOSE("Using histid (sys ? SS): " << histid);
        m_SF_SS[histid].push_back((TH2*)rootFile->Get(names.at(j).c_str()));
      }
 
    } 
  }

 
  if (m_SF_OS.empty() || m_SF_SS.empty() || m_SF_SS.size() != m_SF_OS.size()) {
    ATH_MSG_ERROR(
      "OS/SS SF vectors not filled or of different size. -- Problem with "
      "files. -- Report to <hn-atlas-EGammaWG@cern.ch>");
    return StatusCode::FAILURE;
  }
 
  m_systematics.insert(m_systematics.end(), set_systematics.begin(), set_systematics.end());
 
  std::sort(m_RunNumbers.begin(), m_RunNumbers.end());
  // Determine the limits of validity

  ATH_MSG_DEBUG("Having m_SF_OS.size() = " << m_SF_OS.size());
  std::map<std::string, std::vector<TH2*>>::iterator it = m_SF_OS.begin();
 
  // Get the kinematic limits
  m_eta_lowlimit = (*it).second.at(0)->GetYaxis()->GetXmin();
  m_eta_uplimit = (*it).second.at(0)->GetYaxis()->GetXmax();
  ATH_MSG_VERBOSE("|eta| limits " << m_eta_lowlimit << ", " << m_eta_uplimit);
 
  m_pt_lowlimit = (*it).second.at(0)->GetXaxis()->GetXmin();
  m_pt_uplimit = (*it).second.at(0)->GetXaxis()->GetXmax();
  ATH_MSG_VERBOSE("pt limits " << m_pt_lowlimit << ", " << m_pt_uplimit);
 
  // Check if the input file is in GeV or MeV
  if (m_pt_uplimit > 1500) {
    ATH_MSG_VERBOSE("Rates in input file are in MeV");
    m_gevmev = 1.;
  } else {
    ATH_MSG_VERBOSE("Rates in input file are in GeV");
    m_gevmev = 0.001;
  }
 
  // Systematics // dynamic too?
  m_affectingSys = affectingSystematics();
 
  // Add the recommended systematics to the registry
  if (registerSystematics() != StatusCode::SUCCESS) {
    ATH_MSG_ERROR("(registerSystematics() != CP::SystematicCode::Ok)");
    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 ElectronChargeEfficiencyCorrectionTool::isAffectedBySystematic ( const SystematicVariation & systematic ) const

finaloverridevirtual

Returns whether this tool is affected by the given systematics.

Implements CP::ISystematicsTool.

Definition at line 621 of file ElectronChargeEfficiencyCorrectionTool.cxx.

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

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

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

Definition at line 131 of file AsgTool.cxx.

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

printCorrelationModels()

virtual void CP::ElectronChargeEfficiencyCorrectionTool::printCorrelationModels ( ) const

inlinefinaloverridevirtual

print available/implemented correlation models

Implements IAsgElectronEfficiencyCorrectionTool.

Definition at line 98 of file ElectronChargeEfficiencyCorrectionTool.h.

  {
    ATH_MSG_INFO(
      "ONLY A DEFAULT Correlation model available for now");
  };

recommendedSystematics()

CP::SystematicSet ElectronChargeEfficiencyCorrectionTool::recommendedSystematics ( ) const

finaloverridevirtual

Returns the list of all systematics this tool recommends to use.

Implements CP::IReentrantSystematicsTool.

Definition at line 651 of file ElectronChargeEfficiencyCorrectionTool.cxx.

{
 
  return affectingSystematics();
}

registerSystematics()

StatusCode ElectronChargeEfficiencyCorrectionTool::registerSystematics ( )

private

Definition at line 675 of file ElectronChargeEfficiencyCorrectionTool.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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

systUncorrVariationIndex()

virtual int CP::ElectronChargeEfficiencyCorrectionTool::systUncorrVariationIndex ( const xAOD::Electron & ) const

inlinefinaloverridevirtual

Implements IAsgElectronEfficiencyCorrectionTool.

Definition at line 73 of file ElectronChargeEfficiencyCorrectionTool.h.

  {
    ATH_MSG_ERROR(
        "systUncorrVariationIndex is not implemented in "
        "ElectronChargeEfficiencyCorrectionTool");
    return -999;
  }

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

~ElectronChargeEfficiencyCorrectionTool()

ElectronChargeEfficiencyCorrectionTool::~ElectronChargeEfficiencyCorrectionTool ( )

privatevirtual

Standard destructor.

Definition at line 77 of file ElectronChargeEfficiencyCorrectionTool.cxx.

{
  if (m_sfDec)
    delete m_sfDec;
}

Member Data Documentation

m_affectingSys

CP::SystematicSet CP::ElectronChargeEfficiencyCorrectionTool::m_affectingSys

private

Definition at line 166 of file ElectronChargeEfficiencyCorrectionTool.h.

m_appliedSystematics

CP::SystematicSet* CP::ElectronChargeEfficiencyCorrectionTool::m_appliedSystematics

private

Currently applied systematics.

Definition at line 169 of file ElectronChargeEfficiencyCorrectionTool.h.

m_dataTypeOverwrite

int CP::ElectronChargeEfficiencyCorrectionTool::m_dataTypeOverwrite

private

Force the data type to a given value.

Definition at line 114 of file ElectronChargeEfficiencyCorrectionTool.h.

m_defaultRandomRunNumber

unsigned int CP::ElectronChargeEfficiencyCorrectionTool::m_defaultRandomRunNumber

private

Definition at line 133 of file ElectronChargeEfficiencyCorrectionTool.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_eta_lowlimit

double CP::ElectronChargeEfficiencyCorrectionTool::m_eta_lowlimit

private

Lower limit of eta range where corrections are available; taken from histogram.

Definition at line 143 of file ElectronChargeEfficiencyCorrectionTool.h.

m_eta_uplimit

double CP::ElectronChargeEfficiencyCorrectionTool::m_eta_uplimit

private

Upper limit of eta range where corrections are available; taken from histogram.

Definition at line 147 of file ElectronChargeEfficiencyCorrectionTool.h.

m_eventInfoCollectionName

std::string CP::ElectronChargeEfficiencyCorrectionTool::m_eventInfoCollectionName

private

The Event info collection name.

Definition at line 118 of file ElectronChargeEfficiencyCorrectionTool.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_filename

std::string CP::ElectronChargeEfficiencyCorrectionTool::m_filename

private

The name of the input file that contains the histograms.

Definition at line 136 of file ElectronChargeEfficiencyCorrectionTool.h.

m_filtered_sys_sets

std::map<CP::SystematicSet, CP::SystematicSet> CP::ElectronChargeEfficiencyCorrectionTool::m_filtered_sys_sets

private

Definition at line 163 of file ElectronChargeEfficiencyCorrectionTool.h.

m_gevmev

float CP::ElectronChargeEfficiencyCorrectionTool::m_gevmev

private

Factor for GeV <-> MeV switching.

Definition at line 158 of file ElectronChargeEfficiencyCorrectionTool.h.

m_mySysConf

CP::SystematicSet CP::ElectronChargeEfficiencyCorrectionTool::m_mySysConf

private

Definition at line 165 of file ElectronChargeEfficiencyCorrectionTool.h.

m_pt_lowlimit

double CP::ElectronChargeEfficiencyCorrectionTool::m_pt_lowlimit

private

Lower limit of pt range where corrections are available; taken from histogram.

Definition at line 151 of file ElectronChargeEfficiencyCorrectionTool.h.

m_pt_uplimit

double CP::ElectronChargeEfficiencyCorrectionTool::m_pt_uplimit

private

Upper limit of pt range where corrections are available; taken from histogram.

Definition at line 155 of file ElectronChargeEfficiencyCorrectionTool.h.

m_RunNumbers

std::vector<unsigned int> CP::ElectronChargeEfficiencyCorrectionTool::m_RunNumbers

private

Definition at line 131 of file ElectronChargeEfficiencyCorrectionTool.h.

m_sf_decoration_name

std::string CP::ElectronChargeEfficiencyCorrectionTool::m_sf_decoration_name

private

Decorator.

Definition at line 172 of file ElectronChargeEfficiencyCorrectionTool.h.

m_SF_OS

std::map<std::string, std::vector<TH2*> > CP::ElectronChargeEfficiencyCorrectionTool::m_SF_OS

private

Definition at line 126 of file ElectronChargeEfficiencyCorrectionTool.h.

m_SF_SS

std::map<std::string, std::vector<TH2*> > CP::ElectronChargeEfficiencyCorrectionTool::m_SF_SS

private

Histogram that holds the correction rates for Monte Carlo.

Definition at line 122 of file ElectronChargeEfficiencyCorrectionTool.h.

m_sfDec

SG::AuxElement::Decorator<float>* CP::ElectronChargeEfficiencyCorrectionTool::m_sfDec

private

Definition at line 173 of file ElectronChargeEfficiencyCorrectionTool.h.

m_systematics

std::vector<std::string> CP::ElectronChargeEfficiencyCorrectionTool::m_systematics

private

Definition at line 161 of file ElectronChargeEfficiencyCorrectionTool.h.

m_useRandomRunNumber

bool CP::ElectronChargeEfficiencyCorrectionTool::m_useRandomRunNumber

private

Definition at line 132 of file ElectronChargeEfficiencyCorrectionTool.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.

m_workingPoint

std::string CP::ElectronChargeEfficiencyCorrectionTool::m_workingPoint

private

The name of the folder defining the LH/iso working point.

Definition at line 139 of file ElectronChargeEfficiencyCorrectionTool.h.

---

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

• ElectronChargeEfficiencyCorrectionTool.h
• ElectronChargeEfficiencyCorrectionTool.cxx