AsgElectronEfficiencyCorrectionTool.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
 
#ifndef __ASGELECTRONEFFICIENCYCORRECTIONTOOL__
#define __ASGELECTRONEFFICIENCYCORRECTIONTOOL__
 
// Fwd Declarations
class TH2F;
#include "ElectronEfficiencyCorrection/TElectronEfficiencyCorrectionTool.h"
#include "xAODEgamma/ElectronFwd.h"
// Interface
#include "EgammaAnalysisInterfaces/IAsgElectronEfficiencyCorrectionTool.h"
// STL includes
#include <map>
#include <string>
#include <unordered_map>
#include <vector>
// PAT includes
#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>
 
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
  virtual 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"};
    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
 
#endif