PileupReweightingTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef PILEUPREWEIGHTING_PILEUPREWEIGHTINGTOOL_H
#define PILEUPREWEIGHTING_PILEUPREWEIGHTINGTOOL_H
 
// System include(s):
#include <memory>
 
// Framework include(s):
#include "AsgTools/AsgTool.h"
 
#include "AsgAnalysisInterfaces/IPileupReweightingTool.h"
 
// Local include(s):
 
#include "PileupReweighting/TPileupReweighting.h"
 
#include "AsgTools/ToolHandle.h"
#include "PATInterfaces/IWeightTool.h"
 
#include "TrigDecisionInterface/ITrigDecisionTool.h"
 
namespace CP {
 
 
   class PileupReweightingTool : 
                             public asg::AsgTool, protected virtual CP::TPileupReweighting,public virtual IPileupReweightingTool {
 
      ASG_TOOL_CLASS( PileupReweightingTool, CP::IPileupReweightingTool )
 
   public:
      using CP::TPileupReweighting::operator new; //must declare the new operator as public because everything else went protected
      using CP::TPileupReweighting::Merge;
      using CP::TPileupReweighting::operator delete;
      using CP::TPileupReweighting::operator delete[];
 
 
      virtual UInt_t GetRandomLumiBlockNumber(UInt_t runNumber) { return m_activeTool->GetRandomLumiBlockNumber(runNumber); }
      virtual Double_t GetIntegratedLumi(UInt_t start, UInt_t end)  { return m_activeTool->GetIntegratedLumi(start, end); }
      virtual Double_t GetIntegratedLumi(const TString& trigger)  { return m_activeTool->GetIntegratedLumi(trigger); }
      virtual Double_t GetIntegratedLumi(Int_t periodNumber, UInt_t start, UInt_t end)  { return m_activeTool->GetIntegratedLumi(periodNumber, start, end); }
      virtual Double_t GetIntegratedLumiFraction(Int_t periodNumber, UInt_t start, UInt_t end)  { return m_activeTool->GetIntegratedLumiFraction(periodNumber, start, end); }
      virtual Double_t GetIntegratedLumiFraction(Int_t periodNumber, Double_t mu, UInt_t start, UInt_t end) { return m_activeTool->GetIntegratedLumiFraction(periodNumber, mu, start, end); }
      virtual Int_t AddPeriod(Int_t periodNumber, UInt_t start, UInt_t end)  { return m_activeTool->AddPeriod(periodNumber, start, end); }
      virtual Int_t SetBinning(Int_t nbinsx, Double_t* xbins, Int_t nbinsy=0, Double_t* ybins=0)  { return m_activeTool->SetBinning(nbinsx, xbins, nbinsy, ybins); }
      virtual Int_t SetUniformBinning(Int_t nbinsx, Double_t xlow, Double_t xup, Int_t nbinsy=0, Double_t ylow=0, Double_t yup=0)  { return m_activeTool->SetUniformBinning(nbinsx, xlow, xup, nbinsy, ylow, yup); }
      virtual Int_t SetBinning(TH1* hist)  { return m_activeTool->SetBinning(hist); }
      virtual Double_t GetSumOfEventWeights(Int_t channel)  { return m_activeTool->GetSumOfEventWeights(channel); }
      virtual Double_t GetNumberOfEvents(Int_t channel)  { return m_activeTool->GetNumberOfEvents(channel) ; }
 
 
      PileupReweightingTool( const std::string& name );
 
      virtual StatusCode initialize();
 
      virtual StatusCode finalize();
 
      virtual StatusCode apply ( const xAOD::EventInfo& eventInfo, bool mu_dependent );
 
      virtual float getCombinedWeight( const xAOD::EventInfo& eventInfo, bool correctUnrepresented );
 
      virtual float getCombinedWeight( const xAOD::EventInfo& eventInfo,Double_t x, Double_t y, bool correctUnrepresented );
 
      virtual float getCombinedWeight( const xAOD::EventInfo& eventInfo , const TString& trigger, bool mu_dependent, bool correctUnrepresented );
 
      virtual ULong64_t getPRWHash( const xAOD::EventInfo& eventInfo );
 
      virtual float getCorrectedAverageInteractionsPerCrossing( const xAOD::EventInfo& eventInfo, bool includeDataScaleFactor );
      virtual float getCorrectedActualInteractionsPerCrossing( const xAOD::EventInfo& eventInfo, bool includeDataScaleFactor );
      
      virtual double getLumiBlockIntegratedLumi(const xAOD::EventInfo& eventInfo);
 
      virtual float getUnrepresentedDataWeight( const xAOD::EventInfo& eventInfo );
   
      virtual float getDataWeight( const xAOD::EventInfo& eventInfo, const TString& trigger, bool mu_dependent );
   
      virtual float getPrescaleWeight( const xAOD::EventInfo& eventInfo , const TString& trigger, bool mu_dependent );
 
      virtual int getRandomRunNumber( const xAOD::EventInfo& eventInfo , bool mu_dependent );
   
      virtual int fill( const xAOD::EventInfo& eventInfo );
   
      virtual int fill( const xAOD::EventInfo& eventInfo, Double_t x, Double_t y);
 
      virtual CP::TPileupReweighting* expert() { return m_activeTool; }
 
 
 
      bool isAffectedBySystematic( const CP::SystematicVariation& systematic ) const;
      CP::SystematicSet affectingSystematics() const;
      CP::SystematicSet recommendedSystematics() const;
      StatusCode applySystematicVariation( const CP::SystematicSet& systConfig );
 
#ifndef XAOD_STANDALONE
     void updateHandler(Gaudi::Details::PropertyBase& /*p*/);
#endif
 
   protected:
      virtual bool runLbnOK(Int_t runNbr, Int_t lbn);
      virtual bool passTriggerBeforePrescale(const TString& trigger) const;
 
   private:
      std::string m_configStream;
      bool m_inConfigMode;
 
      // Systematic variation instances for the reweighting
      std::unique_ptr< CP::TPileupReweighting > m_upTool;
      std::unique_ptr< CP::TPileupReweighting > m_downTool;
 
      double m_upVariation; double m_downVariation;
      CP::SystematicVariation m_systUp, m_systDown;
      CP::TPileupReweighting* m_activeTool; //defaults to this
 
      std::vector<std::string> m_prwFiles;
      std::vector<std::string> m_toolLumicalcFiles;
 
      std::string m_prefix;
 
      int m_defaultChannel;
      std::string m_usePeriodConfig;
      std::map<int, bool> m_doneConfigs;
 
      bool m_noWeightsMode;
      
      bool m_varyRunNumber;
      bool m_useRunDependentPrescaleWeight;
      
      std::vector<int> m_customPeriods;
 
      std::unique_ptr< IWeightTool > m_defaultWeightTool;
 
      ToolHandle<IWeightTool> m_weightTool;
      ToolHandle<IGoodRunsListSelectionTool> m_grlTool;
      ToolHandle<Trig::ITrigDecisionTool> m_tdt;
 
      // MN:  this prevents ROOT dict generator from complaining about lack of ClassDef()
      // Note: inheriting from TObject and not having ClassDef makes this class unsuitable for I/O
   public:
      static Version_t Class_Version() { return 0; }
 
   }; // class PileupReweightingTool
 
} // namespace CP
 
#endif //