BTaggingEfficiencyTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CPBTAGGINGEFFICIENCYTOOL_H
#define CPBTAGGINGEFFICIENCYTOOL_H
 
#include "FTagAnalysisInterfaces/IBTaggingEfficiencyTool.h"
#include "FTagAnalysisInterfaces/IBTaggingSelectionTool.h"
#include "PATInterfaces/ISystematicsTool.h"
 
#include "xAODBTagging/BTagging.h"
 
#include <fstream>
#include <string>
#include <set>
#include <vector>
#include <map>
//#include <memory>
 
#include "AsgTools/AsgTool.h"
#include "AsgTools/AnaToolHandle.h"
 
#include "CalibrationDataInterface/CalibrationDataVariables.h"
#include "CalibrationDataInterface/CalibrationDataInterfaceROOT.h"
 
// for the onnxtool
#include "xAODBTaggingEfficiency/OnnxUtil.h"
 
 
class BTaggingEfficiencyTool: public asg::AsgTool,
            public virtual IBTaggingEfficiencyTool
{
  //  typedef double (xAOD::BTagging::* tagWeight_member_t)() const;
 
  ASG_TOOL_CLASS3( BTaggingEfficiencyTool , IBTaggingEfficiencyTool, ISystematicsTool, CP::IReentrantSystematicsTool )
 
  public:
 
 
  BTaggingEfficiencyTool( const std::string& name );
 
  virtual ~BTaggingEfficiencyTool();
 
  // For now, disable the generation of a default copy constructor (since it would not be constructed correctly)
  // BTaggingEfficiencyTool(const BTaggingEfficiencyTool& other) = delete;
 
  // /// Silly copy constructor for the benefit of dictionary generation
  // BTaggingEfficiencyTool(const BTaggingEfficiencyTool& other);
 
 
  CP::CorrectionCode getScaleFactor( const xAOD::Jet & jet,
             float & sf);
 
  CP::CorrectionCode getEfficiency( const xAOD::Jet & jet,
                    float & eff);
 
  CP::CorrectionCode getInefficiency( const xAOD::Jet & jet,
              float & eff);
 
  CP::CorrectionCode getInefficiencyScaleFactor( const xAOD::Jet & jet,
             float & sf);
 
  CP::CorrectionCode getMCEfficiency( const xAOD::Jet & jet,
              float & eff);
 
 
  CP::CorrectionCode getScaleFactor( int flavour, const Analysis::CalibrationDataVariables& v,
             float & sf);
 
  CP::CorrectionCode getEfficiency( int flavour, const Analysis::CalibrationDataVariables& v,
            float & eff);
 
  CP::CorrectionCode getInefficiency( int flavour, const Analysis::CalibrationDataVariables& v,
              float & eff);
 
  CP::CorrectionCode getInefficiencyScaleFactor( int flavour, const Analysis::CalibrationDataVariables& v,
                         float & sf);
 
  CP::CorrectionCode getMCEfficiency( int flavour, const Analysis::CalibrationDataVariables& v,
              float & eff);
 
  CP::CorrectionCode getMCEfficiencyONNX( const std::vector<std::vector<float>>& node_feat, std::vector<float>& effAllJet);
    
  CP::CorrectionCode getMCEfficiencyONNX( const std::vector<std::vector<float>>& node_feat, std::vector<std::vector<float>>& effAllJetAllWp);
 
 
 
  StatusCode initialize();
 
  StatusCode applySystematicVariation(const CP::SystematicSet & set);
 
  CP::SystematicSet affectingSystematics() const;
 
  CP::SystematicSet recommendedSystematics() const;
 
  bool isAffectedBySystematic(const CP::SystematicVariation & systematic ) const;
 
  bool setMapIndex(const std::string& flavour, unsigned int index);
  bool setMapIndex(unsigned int dsid);
  // bool setMapIndex(const std::string& flavour, const std::string & type);
 
  const std::map<CP::SystematicVariation, std::vector<std::string> > listSystematics() const;
 
  std::string getTaggerName() const { return m_taggerName;}
 
  std::string getOperatingPoint() const { return m_OP;}
 
  std::string getJetAuthor() const { return m_jetAuthor;}
 
  // /// Returns false if the tool isn't initialised yet (it has to be initialised before processing jets)
  // bool isInitialized() const { return m_initialised;}
 
  bool applySystematics() const { return m_applySyst;}
 
  std::map<std::string, std::vector<std::string> > listScaleFactorSystematics(bool named = false) const;
 
  CP::CorrectionCode getEigenRecompositionCoefficientMap(const std::string &label, std::map<std::string, std::map<std::string, float>> & coefficientMap);
 
private:
 
  struct SystInfo {
    SystInfo() : uncType(Analysis::SFEigen), isUp(true) {;}
    std::map<unsigned int, unsigned int> indexMap;
    Analysis::Uncertainty uncType;
    // bool isNamed;
    bool isUp;
    bool getIndex( unsigned int flavourID, unsigned int & index) const;
  };
 
  bool addSystematics(const std::vector<std::string> & systematicNames,unsigned int flavourID, Analysis::Uncertainty uncType);
 
  std::vector<std::string> makeEigenSyst(const std::string & flav, int number, const std::string& suffix);
 
  bool getIndices(unsigned int flavour, unsigned int & sf, unsigned int & ef) const;
 
  std::string getLabel(int flavourID) const {
    switch(flavourID) {
    case 5:
      return "B";
      break;
    case 4:
      return "C";
      break;
    case 15:
      return "T";
      break;
    case 6:
      return "Top_BX";
      break;
    case 21:
      return "QCD_BB";
      break;
    case 23:
      return "Z_BB";
      break;
    case 0:
      return "Light";
      break;
    default:
      return "Light";
    }
  }
 
  unsigned int getFlavourID(const std::string& label, bool conventional = true) const {
    // always default to "light" = 0
    if( label.size() <1)
      return 0;
    if (conventional){
      switch (label[0]) {
      case 'B':
        return 5; break;
      case 'C':
        return 4; break;
      case 'T':
        return 15; break;
      default:
        return 0;
      }
    } else {
      if(label == "Top_BX"){
        return 6;
      } else if (label == "QCD_BB"){
        return 21;
      } else if (label == "Z_BB"){
        return 23;
      } else {
        return 25;
      }
    }
  }
 
  bool fillVariables(const xAOD::Jet& jet, Analysis::CalibrationDataVariables& x) const;
 
  bool fillVariables(const double jetPt, const double jetEta, const double jetTagWeight, Analysis::CalibrationDataVariables& x) const;
 
  //Analysis::CalibrationDataInterfaceROOT*  m_CDI = nullptr;
   std::shared_ptr<Analysis::CalibrationDataInterfaceROOT> m_CDI;
  std::unique_ptr<OnnxUtil> m_onnxUtil;
 
 
  asg::AnaToolHandle<IBTaggingSelectionTool> m_selectionTool;
 
  std::string m_SFFile;
  std::string m_SFFileFull;
  std::string m_EffFile;
  std::string m_EffConfigFile;
  std::map<std::string, std::string> m_SFNames;
  std::map<std::string, std::string> m_EVReduction;
  std::map<std::string, std::string> m_EffNames;
  std::string m_excludeFromEV;
  std::map<std::string, std::string> m_excludeFlvFromEV;
  std::map<std::string, std::string> m_uncertaintySuffixes;
  
  bool m_using_conventional_labels; // flag for if the labels in the CDI configuration are "conventional", e.g. "B", "C", "Light", and "T"
  std::string m_SFName_flex; // remove label dependence - work from a string of semi-colon sep. to populate m_SFNames
  std::string m_EVReduction_flex; // remove label dependence - work from a string of semi-colon sep. to populate m_EVReduction
  std::string m_EffNames_flex; // remove label dependence - work from a string of semi-colon sep. to populate m_EffNames
  std::string m_uncertaintySuffixes_flex; // remove label dependence - work from a string of semi-colon sep. to populate m_uncertaintySuffixes
  std::string m_excludeFlvFromEV_flex; // remove label dependence - work from a string of semi-colon sep. to populate m_excludeFlvFromEV
 
  std::string m_taggerName;
  std::string m_OP;
  std::string m_jetAuthor;
  float m_minPt;
  std::string m_systStrategy;
  bool m_useDevFile;
  bool m_coneFlavourLabel;
  bool m_extFlavourLabel;
  bool m_oldConeFlavourLabel;
  // bool m_excludeJESFromEV;
  bool m_useRecommendedEVExclusions;
  bool m_ignoreOutOfValidityRange;
  bool m_useCTag = false;
  std::string m_pathToONNX;
 
  // if true, use the flexible configuration of the CDIReader
  bool m_useFlex = false;
  bool m_doXbbTagging = false;
  std::vector<std::string> m_flex_labels;
  std::vector<unsigned int> m_flex_label_integers;
 
 
  bool m_initialised;
 
 
  bool m_applySyst;
  SystInfo m_applyThisSyst;
 
  std::map<CP::SystematicVariation,SystInfo> m_systematicsInfo;
  // cached for affectedBySystematics
  CP::SystematicSet m_systematics;
  // specifically for continuous tagging
  bool m_isContinuous;
  // specifically for continuous 2D tagging
  bool m_isContinuous2D;
  // pointer to a member function of a b-tagger
  // tagWeight_member_t m_getTagWeight;
 
  // cache the mapIndex variables (one for each flavour)
  std::map<std::string, unsigned int> m_mapIndices;
 
  std::map<unsigned int, unsigned int> m_SFIndices; // <------------- maps flavourID to an index corresponding to the index at which the container used for SFs is stored in CDIROOT's 
  std::map<unsigned int, unsigned int> m_EffIndices;
 
  //cache for efficiency map config file that maps from a sample DSID to the correct efficiency map
  std::map<unsigned int, unsigned int> m_DSID_to_MapIndex;
 
};
 
#endif // CPBTAGGINGEFFICIENCYTOOL_H