BaseFakeBkgTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef BASE_FAKE_BKG_TOOL_H
#define BASE_FAKE_BKG_TOOL_H
 
#include "AsgAnalysisInterfaces/IFakeBkgTool.h"
#include "AsgAnalysisInterfaces/IFakeBkgSystDescriptor.h"
#include "AsgTools/AsgTool.h"
 
#include <string>
#include <map>
#include <unordered_map>
#include <set>
#include <vector>
#include <memory>
#include <functional>
 
namespace FakeBkgTools
{
  struct ParticleData;
  class FinalState;
  class Database;
  struct Efficiency;
  enum class Client;
}
 
namespace CP
{
 
  class ISelectionReadAccessor;
 
/* 
 * Base class of concrete tools implementations, providing common helper methods
 */
class BaseFakeBkgTool : virtual public CP::IFakeBkgTool, public CP::IFakeBkgSystDescriptor, public asg::AsgTool
#ifndef FAKEBKGTOOLS_ATLAS_ENVIRONMENT
  , public FakeBkgTools::PropertyManager<BaseFakeBkgTool>
#endif
{
  public:
 
    BaseFakeBkgTool(const std::string& toolname);
    virtual ~BaseFakeBkgTool();
  
    virtual StatusCode initialize() override;
 
    virtual StatusCode addEvent(const xAOD::IParticleContainer& particles, float extraWeight = 1.f) override final;
  
    virtual StatusCode register1DHistogram(TH1* h1, const float *val) override;
    virtual StatusCode register2DHistogram(TH2* h2, const float *xval, const float *yval) override;
    virtual StatusCode register3DHistogram(TH3* h3, const float *xval, const float *yval, const float *zval) override;
  
    virtual bool isAffectedBySystematic(const CP::SystematicVariation& systematic) const override;
    virtual CP::SystematicSet affectingSystematics() const override;
    virtual CP::SystematicSet recommendedSystematics() const override;
    virtual StatusCode applySystematicVariation(const CP::SystematicSet& systConfig) override;
  
    virtual CP::SystematicSet affectingSystematicsFor(const std::string& nuisanceParameter) const override;
    virtual std::string getUncertaintyDescription(const CP::SystematicVariation& systematic) const override final;
    virtual void printUncertaintyDescription(const CP::SystematicVariation& systematic) const override final;
    virtual bool isSystematicUncertainty(const CP::SystematicVariation& systematic) const override final;
    virtual bool isStatisticalUncertainty(const CP::SystematicVariation& systematic) const override final;
    virtual bool affectsElectrons(const CP::SystematicVariation& systematic) const override final;
    virtual bool affectsMuons(const CP::SystematicVariation& systematic) const override final;
    virtual bool affectsTaus(const CP::SystematicVariation& systematic) const override final;
    virtual bool affectsRealEfficiencies(const CP::SystematicVariation& systematic) const override final;
    virtual bool affectsFakeEfficiencies(const CP::SystematicVariation& systematic) const override final;
    virtual bool affectsFakeFactors(const CP::SystematicVariation& systematic) const override final;
    
    virtual const IFakeBkgSystDescriptor& getSystDescriptor() const override {return *this; }
  
  protected:
 
    bool m_initialized = false; 
    bool m_needEventInfo = true; 
    bool m_convertWhenMissing = false;
 
    virtual FakeBkgTools::Client clientForDB() = 0;
 
    std::vector<FakeBkgTools::ParticleData> m_particles; 
  
    virtual StatusCode addEventCustom() = 0;
    // overridden by derived classes (compute the event weights and update sum of weights/histograms for AM+FF, increment event counters+average efficiencies for LM)
  
  #ifndef __CLING__
    std::unique_ptr<FakeBkgTools::Database> m_database; 
  #else
    std::unique_ptr<int> m_database; 
  #endif
    float m_externalWeight; 
  
    std::hash<std::string> m_hasher; 
  #ifndef __CLING__
    std::set<FakeBkgTools::FinalState> m_cachedFinalStates; 
  #else
    std::set<int> m_cachedFinalStates; 
  #endif
    FakeBkgTools::FinalState getCachedFinalState(uint8_t nparticles, const std::string& strPID, const std::string& strProc, bool& success);
  
    std::string getListOfEfficienciesAffectedBy(uint16_t uid) const;   
  
    // maps to store relationships between histograms and variables
    std::map<TH1*, const float*> m_values_1dhisto_map; 
    std::map<TH2*, std::pair<const float*, const float*> >  m_values_2dhisto_map; 
    std::map<TH3*, std::tuple<const float*, const float*, const float*> >  m_values_3dhisto_map; 
 
    StatusCode CheckHistogramCompatibility(const TH1* lhs, const TH1* rhs);
 
    std::string m_selection = defaultSelection();
 
    std::string m_process = defaultProcess();
    
    std::string m_energyUnit;
  
    bool m_useDB = true; 
  
    std::vector<std::string> m_inputFiles;
 
    std::string m_tightDecoNameAndType;
 
    CP::ISelectionReadAccessor* m_tightAccessor = nullptr; 
 
    std::string m_progressFileName;
 
    std::string m_progressFileDirectory;
    
    struct UncertaintyList
    {
        uint16_t UID;
        float sigma;
        UncertaintyList(uint16_t first_UID, float first_sigma) : UID(first_UID), sigma(first_sigma) {}
        void extraVariation(uint16_t extra_UID, float extra_sigma)
        { 
            if(m_next) m_next->extraVariation(extra_UID, extra_sigma);
            else m_next.reset(new UncertaintyList(extra_UID, extra_sigma));
        }
        const UncertaintyList* next() const { return m_next.get(); }
    protected:
        std::unique_ptr<UncertaintyList> m_next;
    };
 
    UncertaintyList* m_selectedUncertainties = nullptr;
 
    std::unordered_map<CP::SystematicSet, UncertaintyList> m_systSetDict; 
 
    bool m_unlimitedSystematicVariations = true; 
 
    bool m_lockedSystematicVariations = false; 
 
  private:
 
    bool importEfficiencies(bool resetDB = false);
 
    std::pair<uint16_t, float> identifyCpSystematicVariation(const CP::SystematicVariation& systematic) const;
    
    friend struct FakeBkgTools::Efficiency;
};
 
}
 
#endif