AsgElectronEfficiencyCorrectionTool.h File Reference

#include "ElectronEfficiencyCorrection/TElectronEfficiencyCorrectionTool.h"
#include "xAODEgamma/ElectronFwd.h"
#include "EgammaAnalysisInterfaces/IAsgElectronEfficiencyCorrectionTool.h"
#include <map>
#include <string>
#include <unordered_map>
#include <vector>
#include "AsgTools/AsgMetadataTool.h"
#include "PATCore/PATCoreEnums.h"
#include "PATInterfaces/CorrectionCode.h"
#include "PATInterfaces/SystematicRegistry.h"
#include <ColumnarCore/ColumnAccessor.h>
#include "ColumnarCluster/ClusterHelpers.h"
#include <ColumnarEventInfo/EventInfoDef.h>
#include <ColumnarCore/LinkColumn.h>
#include <ColumnarCore/ObjectColumn.h>
#include <ColumnarCore/VectorColumn.h>
#include <ColumnarEgamma/EgammaDef.h>

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
namespace	ADD_CMODE (CP)

Function Documentation

ADD_CMODE()

namespace ADD_CMODE

(

CP

)

Standard constructor

Standard destructor

Gaudi Service Interface method implementations

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

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

returns: whether this tool is affected by the given systematis

Configure this tool for the given systematics

print available/implemented correlation models

returns: the currently applied systematics

initialize the systematics

To check if the metadata can be retrieved

Pointer to the underlying ROOT based tool

Systematics filter map

Affected systematic, should be done only once

Currently applied systematics

The list of file names

The prefix string for the result

The string for the result

The Event info collection name

Force the data type to a given value

Definition at line 1 of file AsgElectronEfficiencyCorrectionTool.h.

{
 
class AsgElectronEfficiencyCorrectionTool final
  : virtual public IAsgElectronEfficiencyCorrectionTool
  , public asg::AsgMetadataTool
  , public columnar::ColumnarTool<>
{
  ASG_TOOL_CLASS(AsgElectronEfficiencyCorrectionTool,
                 IAsgElectronEfficiencyCorrectionTool)
 
public:
  AsgElectronEfficiencyCorrectionTool(const std::string& myname);
  virtual ~AsgElectronEfficiencyCorrectionTool() override final;
  virtual StatusCode initialize() override final;
 
  /*
   * Metadata tool methods
   */
  virtual StatusCode beginInputFile() override final;
  virtual StatusCode beginEvent() override final;
 
  /*
   * ISystematic tool methods
   */
  virtual CP::SystematicSet affectingSystematics() const override final;
  virtual CP::SystematicSet recommendedSystematics() const override final;
  virtual bool isAffectedBySystematic(
    const CP::SystematicVariation& systematic) const override final;
  virtual StatusCode applySystematicVariation(
    const CP::SystematicSet& systConfig) override final;
 
  /*
   * IAsgElectronEfficiencyCorrectionTool methods
   */
  virtual CP::CorrectionCode getEfficiencyScaleFactor(
    const xAOD::Electron& inputObject,
    double& efficiencyScaleFactor) const override final;
  CP::CorrectionCode getEfficiencyScaleFactor(
    columnar::ElectronId inputObject,
    double& efficiencyScaleFactor,
    columnar::EventInfoId info) const;
  //
  virtual CP::CorrectionCode getEfficiencyScaleFactor(
    const double et,  /*in MeV*/
    const double cluster_eta, /*cluster*/
    const unsigned int runNumber,
    double& efficiencyScaleFactor) const override final;
  //
  virtual CP::CorrectionCode applyEfficiencyScaleFactor(
    const xAOD::Electron& inputObject) const override final;
  //
  virtual int getNumberOfToys() const override final
  {
    return m_number_of_toys;
  };
  virtual void printCorrelationModels() const override final
  {
    ATH_MSG_INFO(
      " Available Correlation Models for the ElectronEfficiencyCorrectionTool");
    ATH_MSG_INFO("FULL");
    ATH_MSG_INFO("SIMPLIFIED");
    ATH_MSG_INFO("MCTOYS");
    ATH_MSG_INFO("SYST");
    ATH_MSG_INFO("COMBMCTOYS");
    ATH_MSG_INFO("TOTAL");
  };

  virtual const CP::SystematicSet& appliedSystematics() const override final
  {
    return *m_appliedSystematics;
  }
 
  virtual int systUncorrVariationIndex(
    const xAOD::Electron& inputObject) const override final;
  int systUncorrVariationIndex(
    columnar::ElectronId inputObject) const;
 
private:
  StatusCode registerSystematics();
 
  int currentSimplifiedUncorrSystRegion(const double cluster_eta,
                                        const double et) const;
  int currentUncorrSystRegion(const double cluster_eta, const double et) const;

  StatusCode InitSystematics();
 
  // Gets the correction filename from map
  StatusCode getFile(const std::string& recokey,
                     const std::string& idkey,
                     const std::string& isokey,
                     const std::string& trigkey);
  // Get the simulation type from metadata
  StatusCode get_simType_from_metadata(
    PATCore::ParticleDataType::DataType& result) const;
 
  // struct for toys
  struct SystConf
  {
    float m_total;
    unsigned m_toy_index;
    float m_toy_scale;
  };

  bool m_metadata_retrieved = false;

  std::unique_ptr<Root::TElectronEfficiencyCorrectionTool> m_rootTool = nullptr;

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

  CP::SystematicSet m_affectedSys;

  CP::SystematicSet* m_appliedSystematics;
 
  // Correlation Model
  std::string m_correlation_model_name;
  int m_correlation_model;
 
  // Map-key properties
  std::string m_mapFile;
 
  // Four SF key Properties
  std::string m_recoKey;
  std::string m_idKey;
  std::string m_isoKey;
  std::string m_trigKey;

  std::vector<std::string> m_corrFileNameList;

  std::string m_resultPrefix;

  std::string m_resultName;
 
  // The prefix for the systematic name
  std::string m_sysSubstring;

  std::string m_eventInfoCollectionName;
 
  // use RandomRun Number
  bool m_useRandomRunNumber;
  int m_defaultRandomRunNumber;
 
  // The data type
  PATCore::ParticleDataType::DataType m_dataType;

  int m_dataTypeOverwrite;
 
  // Number of toys:
  int m_number_of_toys;
 
  // seed for toys:
  int m_seed_toys;
 
  // scale for toy uncertainty:
  double m_scale_toys;
 
  // number of systematic uncertainties
  int m_nCorrSyst;
  int m_nUncorrSyst;
  std::vector<std::pair<float, std::vector<float>>> m_pteta_bins;
 
  // custom binning for SIMPLIFIED model
  std::vector<float> m_uncorrSimplfEtaBinsUser;
  std::vector<float> m_uncorrSimplfEtBinsUser;
 
  // simplified uncorrelation regions
  TH2F* m_UncorrRegions;
  int m_nSimpleUncorrSyst;
 
  // Caching of variations we know after initialize
  std::string m_toysBasename;
  std::vector<CP::SystematicVariation> m_corrVarUp;
  std::vector<CP::SystematicVariation> m_corrVarDown;
  std::vector<CP::SystematicVariation> m_uncorrVarUp;
  std::vector<CP::SystematicVariation> m_uncorrVarDown;
 
public:
 
  struct Accessors : public columnar::ColumnarTool<>
  {
    Accessors(AsgElectronEfficiencyCorrectionTool& tool) : columnar::ColumnarTool<>(&tool) {}
 
    columnar::EventInfoAccessor<columnar::ObjectColumn> m_eventInfo {*this, "EventInfo", {.addMTDependency=true}};
    columnar::EventInfoAccessor<uint32_t> randomrunnumber;
  
    columnar::ElectronAccessor<columnar::ObjectColumn> m_electrons {*this, "Electrons"};
    columnar::ElectronAccessor<float> m_eta{*this,"eta"};
    columnar::ElectronAccessor<float> m_pt{*this,"pt"};
    columnar::ElectronAccessor<uint16_t> accAuthor{*this,"author"};
    columnar::ElectronDecorator<float> m_sfDec{*this,"sfOut"};
    columnar::ElectronDecorator<char> m_validDec{*this,"validOut"};
  
    columnar::ClusterAccessor<columnar::ObjectColumn> m_clusterHandle {*this, "egammaClusters"};
    columnar::ElectronAccessor<std::vector<columnar::OptClusterId>> caloClusterAcc {*this, "caloClusterLinks"};
    columnar::ClusterAccessor<float> clusterEAcc {*this, "calE"};
    columnar::ClusterAccessor<float> clusterEtaAcc {*this, "calEta"};
    columnar::ClusterHelpers::EtaBEAccessor<> clusterEtaBEAcc {*this};
  };
  std::unique_ptr<Accessors> m_accessors;
 
  void callSingleEvent (columnar::ElectronRange electrons, columnar::EventInfoId event) const;
  void callEvents (columnar::EventContextRange events) const override;
 
}; // End: class definition
 
} // namespace ADD_CMODE(CP)