AsgPhotonEfficiencyCorrectionTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
// Dear emacs, this is -*-c++-*-
 
#ifndef PHOTONEFFICIENCYCORRECTION_ASGPHOTONEFFICIENCYCORRECTIONTOOL
#define PHOTONEFFICIENCYCORRECTION_ASGPHOTONEFFICIENCYCORRECTIONTOOL

 
// STL includes
#include <vector>
#include <string>
#include <fstream>
#include <unordered_map>
 
//xAOD includes
#include "AsgTools/AsgTool.h"
#include "AsgTools/PropertyWrapper.h"
#include "PATInterfaces/ISystematicsTool.h"
#include "PATInterfaces/SystematicRegistry.h"
#include "PATInterfaces/CorrectionCode.h"
#include "ElectronEfficiencyCorrection/TElectronEfficiencyCorrectionTool.h"
#include "EgammaAnalysisInterfaces/IAsgPhotonEfficiencyCorrectionTool.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/EgammaHelpers.h>
 
class AsgPhotonEfficiencyCorrectionTool
  : virtual public IAsgPhotonEfficiencyCorrectionTool,
    virtual public CP::ISystematicsTool,
            public asg::AsgTool,
            public columnar::ColumnarTool<>
{
  ASG_TOOL_CLASS3(AsgPhotonEfficiencyCorrectionTool, IAsgPhotonEfficiencyCorrectionTool, CP::ISystematicsTool, CP::IReentrantSystematicsTool )
 
public:
  AsgPhotonEfficiencyCorrectionTool ( const std::string& myname );

  virtual ~AsgPhotonEfficiencyCorrectionTool();

  virtual StatusCode initialize() override;
 
 
public:
  virtual CP::CorrectionCode getEfficiencyScaleFactor(const xAOD::Egamma& inputObject, double& efficiencyScaleFactor) const override;
  CP::CorrectionCode getEfficiencyScaleFactor(columnar::EgammaId inputObject, columnar::EventInfoId eventInfo, double& efficiencyScaleFactor) const;
  virtual CP::CorrectionCode getEfficiencyScaleFactorError(const xAOD::Egamma& inputObject, double& efficiencyScaleFactorError) const override;
  CP::CorrectionCode getEfficiencyScaleFactorError(columnar::EgammaId inputObject, columnar::EventInfoId eventInfo, double& efficiencyScaleFactorError) const;
  virtual CP::CorrectionCode applyEfficiencyScaleFactor(xAOD::Egamma& inputObject) const override;


  virtual bool isAffectedBySystematic( const CP::SystematicVariation& systematic ) const override;
  
  virtual CP::SystematicSet affectingSystematics() const override;
  
  virtual CP::SystematicSet recommendedSystematics() const override;
  
  const CP::SystematicSet& appliedSystematics() const {
    assert (m_appliedSystematics != nullptr);
    return *m_appliedSystematics;
  }
  
  virtual StatusCode applySystematicVariation ( const CP::SystematicSet& systConfig ) override;
 
  StatusCode registerSystematics();
 
  // Private member variables
private:
  typedef Root::TElectronEfficiencyCorrectionTool::Result Result;
  CP::CorrectionCode calculate( columnar::EgammaId egam, columnar::EventInfoId eventInfo, Result& result ) const;

  Root::TElectronEfficiencyCorrectionTool* m_rootTool_unc;
  Root::TElectronEfficiencyCorrectionTool* m_rootTool_con;
  
  std::unordered_map<CP::SystematicSet, CP::SystematicSet> m_systFilter;
  
  CP::SystematicSet* m_appliedSystematics = nullptr;
  
  // The prefix for the systematic name
  std::string m_sysSubstring;
  
  // Get the correction filename from the map
  std::string getFileName(const std::string& isoWP, const std::string& trigWP, bool isConv);
  
  // Set prefix of the corresponding calibration filenames:
  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.";
  
  // Properties
  
  std::string m_corrFileNameConv;
  std::string m_corrFileNameUnconv;
 
  std::string m_resultPrefix;

  std::string m_resultName;

  int m_dataTypeOverwrite;
  
  std::string m_isoWP;
  
  std::string m_trigger;
  
  std::string m_mapFile;  
 
  // bin boundaries of correction files
  std::map<float, std::vector<float>> m_pteta_bins;
  
  //use RandomRun Number
  bool m_useRandomRunNumber;
  int m_defaultRandomRunNumber;
 
  // remove TRT converted photon for Run-3
  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." };
 
  // an accessor structure that hides the columnar accessors from the
  // root dictionaries that can't handle them.  these dictionaries are
  // used by some users to instantiate the tools (instead of using the
  // factory mechanism).
  struct Accessors : public columnar::ColumnarTool<>
  {
    Accessors(AsgPhotonEfficiencyCorrectionTool& tool) : columnar::ColumnarTool<>(&tool) {}
 
    columnar::EventInfoAccessor<columnar::ObjectColumn> eventInfoAcc {*this, "EventInfo", {.addMTDependency=true}};
    columnar::EgammaAccessor<columnar::ObjectColumn> photonsAcc {*this, "Photons"};
    columnar::ClusterAccessor<columnar::ObjectColumn> clusterAcc {*this, "egammaClusters"};
    columnar::VertexAccessor<columnar::ObjectColumn> verticesAcc {*this, "GSFConversionVertices"};
    columnar::TrackAccessor<columnar::ObjectColumn> tracksAcc {*this, "GSFTrackParticles"};
 
    columnar::EventInfoAccessor<uint32_t> randomRunNumberAcc {*this, "RandomRunNumber"};
  
    columnar::EgammaAccessor<float> etaAcc{*this,"eta"};
    columnar::EgammaHelpers::IsConvertedPhotonAccessor<> isConvertedPhotonAcc{*this};
    columnar::EgammaDecorator<float> sfDec{*this,"sfOut"};
    columnar::EgammaDecorator<char> validDec{*this,"validOut"};
  
    columnar::EgammaAccessor<std::vector<columnar::OptClusterId>> caloClusterAcc {*this, "caloClusterLinks"};
    columnar::ClusterAccessor<float> clusterEAcc {*this, "calE"};
    columnar::ClusterHelpers::EtaBEAccessor<> clusterEtaBEAcc {*this};
  };
  std::unique_ptr<Accessors> m_accessors {std::make_unique<Accessors>(*this)};
 
 
public:
 
  void callSingleEvent (columnar::EgammaRange photons, columnar::EventInfoId event) const;
  void callEvents (columnar::EventContextRange events) const override;
 
}; // End: class definition
 
 
#endif