/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/PileupReweighting/PileupReweighting/PileupReweightingTool.h

#ifndef PILEUPREWEIGHTING_PILEUPREWEIGHTINGTOOL_H
#define PILEUPREWEIGHTING_PILEUPREWEIGHTINGTOOL_H

// 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 );

      virtual float getCombinedWeight( const xAOD::EventInfo& eventInfo,Double_t x, Double_t y );

      virtual float getCombinedWeight( const xAOD::EventInfo& eventInfo , const TString& trigger, bool mu_dependent );

      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 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;
      CP::SystematicCode applySystematicVariation( const CP::SystematicSet& systConfig );

#ifndef XAOD_STANDALONE
      void updateHandler(Property& /*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;
      CP::TPileupReweighting *m_upTool, *m_downTool; //systematic variation instances for the reweighting

      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_lumicalcFiles;

      std::string m_prefix;

      int m_defaultChannel;
      std::string m_usePeriodConfig;
      std::map<int, bool> m_doneConfigs;

      bool m_noWeightsMode;

      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 // 

---