EnhancedBiasWeighter.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ENHANCEDBIASWEIGHTER_ENHANCEDBIASWEIGHTER_H
#define ENHANCEDBIASWEIGHTER_ENHANCEDBIASWEIGHTER_H 1
 
#include "AsgTools/AsgTool.h"
#include "CxxUtils/checker_macros.h"
#include "GaudiKernel/ToolHandle.h"
#include "Gaudi/Accumulators.h"
 
#include "EnhancedBiasWeighter/IEnhancedBiasWeighter.h"
#include "EnhancedBiasWeighter/ReadLumiBlock.h"
 
#include "DerivationFrameworkInterfaces/IAugmentationTool.h"
#include "LumiBlockData/BunchCrossingCondData.h"
 
#include <unordered_map>
#include <mutex>
 
struct ChainDetail {
  std::string m_name;
  std::string m_lowerName;
  std::string m_comment;
  uint32_t m_counter;
  double m_prescale;
  double m_eventsPassed;
  double m_eventsPassedWeighted;
  double m_rate;
  double m_rateErr;
  double m_passthroughPrescale;
  double m_rerunPrescale;
  double m_expressPrescale;
  double m_efficiency;
  double m_efficiencyErr;
  double m_prescaledEfficiency;
  double m_prescaledEfficiencyErr;
};
 
class EnhancedBiasWeighter: public asg::AsgTool, public virtual IEnhancedBiasWeighter, public virtual DerivationFramework::IAugmentationTool { 
 public: 
   //constructor for athena can be created using special macro
   //Note: if you add a second interface to your tool, you must use: ASG_TOOL_CLASS2( ToolName, Interface1, Interface2) 
   ASG_TOOL_CLASS2( EnhancedBiasWeighter , IEnhancedBiasWeighter, DerivationFramework::IAugmentationTool)
   //add another constructor for non-athena use cases
   EnhancedBiasWeighter( const std::string& name );
 
   constexpr static double LHC_FREQUENCY = 11245.5; //<! LHC revolution frequency in Hz
   constexpr static uint32_t FULL_RING = 2738; 
 
   virtual StatusCode initialize() override; 
   virtual StatusCode finalize() override;
   // 
  
   virtual StatusCode addBranches() const override;
 
   virtual double getEBWeight(const xAOD::EventInfo* eventInfo) const override;
   virtual double getEBWeight(const EventContext& context) const override;
 
   virtual double getEBLiveTime(const xAOD::EventInfo* eventInfo) const override;
   virtual double getEBLiveTime(const EventContext& context) const override;
 
   virtual double getLBLength(const xAOD::EventInfo* eventInfo) const override;
   virtual double getLBLength(const EventContext& context) const override;
 
   virtual double getLBLumi(const xAOD::EventInfo* eventInfo) const override;
   virtual double getLBLumi(const EventContext& context) const override;
 
   virtual double getAverageLumi() const override;
 
   virtual double getAverageMu() const override;
  
   virtual double getDeadtime(const int lumiblock = -1) const override;
 
   virtual uint32_t getPairedBunches() const override;
 
   virtual StatusCode getDistanceIntoTrain(const xAOD::EventInfo* eventInfo, uint32_t& distance) const override;
 
   virtual uint32_t getRunNumber() const override;
 
   virtual bool isUnbiasedEvent(const xAOD::EventInfo* eventInfo) const override; 
 
   virtual bool isGoodLB(const xAOD::EventInfo* eventInfo) const override; 
   virtual bool isGoodLB(const EventContext& context) const override; 
 
   virtual bool isMC() const override;
 
   virtual std::unordered_map<std::string, ChainDetail> parsePrescaleXML(const std::string& prescaleXML) const override;
 
   virtual const std::vector<int32_t>& getBunchGroups() const override { return m_bunches; }
 
 private: 
    StatusCode loadWeights(); 
    StatusCode loadLumi(); 
    StatusCode trackAverages(const xAOD::EventInfo* eventInfo) const; 
    StatusCode trackAverages(const EventContext& context) const;
    int32_t getEventEBID(const xAOD::EventInfo* eventInfo) const; 
    int32_t getEventEBID(const EventContext& context) const; 
 
    std::string findLocalFile (const std::string& fileName) const;
 
    SG::ReadCondHandleKey<BunchCrossingCondData> m_bunchCrossingKey{this, "BunchCrossingKey", "BunchCrossingData", "Key BunchCrossing CDO" }; 
 
    Gaudi::Property<uint32_t> m_runNumber{this, "RunNumber", 0, "Run we're processing (if data), needed at initialize to locate and read in extra configuration."};
    Gaudi::Property<bool> m_errorOnMissingEBWeights{this, "ErrorOnMissingEBWeights", false, "If true, Throws error if EB weights are missing."};
    Gaudi::Property<bool> m_enforceEBGRL{this, "EnforceEBGRL", true, "Each Enhanced Bias run has a 'good run list' style veto on some LB. If this flag is true, events in these LB get weight 0"};
    Gaudi::Property<bool> m_useBunchCrossingData{this, "UseBunchCrossingData", true, "BunchCrossing data requires CONDBR2 access. Can be disabled here if this is a problem."};
    Gaudi::Property<bool> m_isMC{this, "IsMC", false,  "MC mode? If so we need a cross section and filter efficiency"};
    Gaudi::Property<double> m_mcCrossSection{this, "MCCrossSection", 0.0, "If running over MC. The process cross section in nb (AMI gives thins in nb)"};
    Gaudi::Property<double> m_mcFilterEfficiency{this, "MCFilterEfficiency", 1.0, "If running over MC. The process filter efficiency (0.0-1.0)"}; 
    Gaudi::Property<double> m_mcKFactor{this, "MCKFactor", 1.0, "If running over MC. The process filter efficiency (0.0-1.0)"}; 
    Gaudi::Property<bool> m_mcIgnoreGeneratorWeights{this, "MCIgnoreGeneratorWeights", false, "If running over MC. Flag to ignore the generator weight."}; 
    Gaudi::Property<double> m_inelasticCrossSection{this, "InelasticCrossSection", 8e-26, "Inelastic cross section in units cm^2. Default 80 mb at 13 TeV."};
    Gaudi::Property<std::string> m_weightsDirectory {this, "EBWeightsDirectory", "", "Path to directory with EB XML weights files, if empty they will be read from calibration area"};  
 
 
    double m_deadtime; 
    uint32_t m_pairedBunches; 
    double m_mcModifiedCrossSection; 
    std::unordered_map<uint64_t, int32_t> m_eventNumberToIdMap; 
 
    mutable std::unordered_map<uint32_t, float> m_eventLivetime ATLAS_THREAD_SAFE; 
    mutable std::mutex m_mutex; 
    mutable Gaudi::Accumulators::AveragingCounter<double> m_lumiAverage ATLAS_THREAD_SAFE; 
    mutable Gaudi::Accumulators::AveragingCounter<double> m_muAverage ATLAS_THREAD_SAFE; 
 
    std::unordered_map<int32_t, double>    m_idToWeightMap; 
    std::unordered_map<int32_t, uint8_t>   m_idToUnbiasedMap; 
    std::unordered_map<uint32_t, uint32_t> m_eventsPerLB; 
    std::unordered_map<uint32_t, double>   m_lumiPerLB; 
    std::unordered_map<uint32_t, uint8_t>  m_goodLB;  
    std::unordered_map<uint32_t, double>   m_deadtimePerLB; 
 
    std::vector<int32_t> m_bunches; 
 
    ReadLumiBlock m_readLumiBlock; 
}; 
 
#endif //> !ENHANCEDBIASWEIGHTER_ENHANCEDBIASWEIGHTER_H