AsgPhotonEfficiencyCorrectionTool.h File Reference

#include <vector>
#include <string>
#include <fstream>
#include <unordered_map>
#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>

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

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

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

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

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

returns: the currently applied systematics

Configure this tool for the given systematics

I think these calculate methods are only used internally

Pointer to the underlying ROOT based tool

Systematics filter map

Currently applied systematics

The list of input file names

The prefix string for the result

The string for the result

Force the data type to a given value

Isolation working point

Trigger name for trigger SF

map filename

Definition at line 1 of file AsgPhotonEfficiencyCorrectionTool.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
 
} // namespace ADD_CMODE(CP)