CalibrationDataInterfaceROOT.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/

// CalibrationDataInterfaceROOT.h, (c) ATLAS Detector software
 
#ifndef ANALYSISCALIBRATIONDATAINTERFACEROOT_H
#define ANALYSISCALIBRATIONDATAINTERFACEROOT_H
 
 
#include "CalibrationDataInterface/CalibrationDataVariables.h"
#include "CalibrationDataInterface/CalibrationDataInterfaceBase.h"
 
//#include "Rtypes.h"
#include "TMatrixDSym.h"
#include "TH1.h"
#include <vector>
#include <string>
#include <map>
 
class TFile;
class TMap;
 
namespace Analysis 
{
  class CalibrationDataContainer;
 
  class CalibrationDataEigenVariations;
  

  enum Uncertainty { None, Total, Statistical, Systematic, Extrapolation, SFEigen, SFNamed, TauExtrapolation, SFGlobalEigen };

  enum EVReductionStrategy { Tight = 0, Medium = 1, Loose = 2};
  
  enum OutOfBoundsStrategy { Ignore, Flag, GiveUpExtrapolated, GiveUp };

  enum OutOfBoundsType { Main, Extrapolated, Eta, TagWeight };
 
  class CalibrationDataInterfaceROOT: public CalibrationDataInterfaceBase
    {
    public:
      CalibrationDataInterfaceROOT(const std::string& taggerName, const std::string& configname = "BTagCalibration.env", const std::string& pathname = "");

      CalibrationDataInterfaceROOT(const std::string& taggerName,
                   const char* fileSF, const char* fileEff,
                   const std::vector<std::string>& jetAliases,
                   const std::map<std::string, std::string>& SFNames,
                   const std::map<std::string, std::vector<std::string> >& EffNames,
                   const std::map<std::string, std::vector<std::string> >& excludeFromEV,
                   const std::map<std::string, Analysis::EVReductionStrategy>& EVReductions,
                   bool useEV = true, Uncertainty strat = SFEigen, bool useMCMCSF = true,
                   bool useTopologyRescaling = false, bool useRecommendedEVExclusions = false,
                   bool verbose = true, std::vector<std::string> flavours = {"B", "C", "Light", "T"}
           );

      CalibrationDataInterfaceROOT();

      CalibrationDataInterfaceROOT(const CalibrationDataInterfaceROOT& other);
      
      virtual ~CalibrationDataInterfaceROOT();
      
      // ------------------------------------------------------------------------------------------
 
      // Main jet-by-jet interface methods accessing the flavour tagging performance information.
      // Note that for both of the following, the label is assumed to adhere to the
      // TruthInfo conventions (see package PhysicsAnalysis/JetTagging/JetTagInfo).
 
      // THe following methods are one of three
      CalibResult getScaleFactor (const CalibrationDataVariables& variables,
                  const std::string& label, const std::string& OP,
                  Uncertainty unc, unsigned int numVariation = 0,
                  unsigned int mapIndex = 0);

      CalibResult getEfficiency (const CalibrationDataVariables& variables,
                 const std::string& label, const std::string& OP,
                 Uncertainty unc, const std::string& flavour, unsigned int numVariation = 0,
                 unsigned int mapIndex = 0);
      
      CalibResult getInefficiencyScaleFactor(const CalibrationDataVariables& variables,
                         const std::string& label, const std::string& OP,
                         Uncertainty unc, unsigned int numVariation = 0,
                         unsigned int mapIndex = 0);

      CalibResult getInefficiency (const CalibrationDataVariables& variables,
                   const std::string& label, const std::string& OP,
                   Uncertainty unc, unsigned int numVariation = 0,
                   unsigned int mapIndex = 0);

      CalibResult getMCEfficiency (const CalibrationDataVariables& variables, const std::string& label,
                       const std::string& OP, Uncertainty unc = None, unsigned int mapIndex = 0);
     
      CalibResult getMCInefficiency (const CalibrationDataVariables& variables, const std::string& label,
                         const std::string& OP, Uncertainty unc = None, unsigned int mapIndex = 0);
 

      std::vector<std::string> listScaleFactorUncertainties(const std::string& author, //<-------- One of two
                                const std::string& label,
                                const std::string& OP,
                                bool named = false);

      unsigned int getNumVariations(const std::string& author, const std::string& label, 
                    const std::string& OP, Uncertainty unc); 
 
      // ------------------------------------------------------------------------------------------
 
      // Main jet-by-jet interface methods accessing the flavour tagging performance information.
      // The difference with the previous set of methods is that no label and operating point are
      // passed; instead, it is assumed that the user has retrieved the (unsigned) integer index
      // corresponding to the label/OP/jet collection using the retrieveCalibrationIndex() method
      // below. The methods below are not protected against wrong usage of this index!

      bool retrieveCalibrationIndex (const std::string& label, const std::string& OP,
                     const std::string& author, bool isSF, unsigned int& index,
                     unsigned int mapIndex = 0);

      std::string nameFromIndex (unsigned int index) const;

      CalibResult getScaleFactor (const CalibrationDataVariables& variables,
                  unsigned int indexSF, unsigned int indexEff,
                  Uncertainty unc, const std::string& flavour, unsigned int numVariation = 0);

      CalibResult getEfficiency (const CalibrationDataVariables& variables,
                 unsigned int indexSF, unsigned int indexEff,
                 Uncertainty unc, const std::string& flavour, unsigned int numVariation = 0);
      
      CalibResult getInefficiencyScaleFactor(const CalibrationDataVariables& variables,
                         unsigned int indexSF, unsigned int indexEff,
                         Uncertainty unc, const std::string& flavour, unsigned int numVariation = 0);

      CalibResult getInefficiency (const CalibrationDataVariables& variables,
                   unsigned int indexSF, unsigned int indexEff,
              Uncertainty unc, const std::string& flavour, unsigned int numVariation = 0);

      CalibResult getMCEfficiency (const CalibrationDataVariables& variables, unsigned int index,
                       Uncertainty unc = None);
     
      CalibResult getMCInefficiency (const CalibrationDataVariables& variables, unsigned int index,
                         Uncertainty unc = None);

      double      getMCMCScaleFactor(const CalibrationDataVariables& variables,
                     unsigned indexSF, unsigned int indexEff) const;

      std::vector<std::string> listScaleFactorUncertainties(unsigned int index,
                               const std::string& flavour, bool named = false);

      unsigned int getNumVariations(unsigned int index, Uncertainty unc, const std::string& flavour); 

      std::string fullName(const std::string& author, const std::string& OP,
               const std::string& label, bool isSF, unsigned mapIndex = 0) const;
 
      // ------------------------------------------------------------------------------------------
 
      // Main jet-by-jet interface methods accessing the flavour tagging performance information.
      // The difference with the previous set of methods is in the signatures of the methods, where
      // the return value is a status code while the actual calibration result is to be passed as
      // one of the arguments. Other than this, the same comments hold as for the previous set of
      // methods.

      CalibrationStatus getScaleFactor (const CalibrationDataVariables& variables,
                    unsigned int indexSF, unsigned int indexEff,
                    Uncertainty unc, unsigned int numVariation,
                    CalibResult& result, const std::string& flavour);

      CalibrationStatus getEfficiency (const CalibrationDataVariables& variables,
                       unsigned int indexSF, unsigned int indexEff,
                       Uncertainty unc, unsigned int numVariation,
                       CalibResult& result, const std::string& flavour);
      
      CalibrationStatus getInefficiencyScaleFactor(const CalibrationDataVariables& variables,
                           unsigned int indexSF, unsigned int indexEff,
                           Uncertainty unc, unsigned int numVariation,
                           CalibResult& result, const std::string& flavour);

      CalibrationStatus getInefficiency (const CalibrationDataVariables& variables,
                     unsigned int indexSF, unsigned int indexEff,
                     Uncertainty unc, unsigned int numVariation,
                     CalibResult& result, const std::string& flavour);

      CalibrationStatus getMCEfficiency (const CalibrationDataVariables& variables,
                     unsigned int index, Uncertainty unc,
                     CalibResult& result);
     
      // ------------------------------------------------------------------------------------------
 
      // Main jet-by-jet interface methods accessing "pseudo-continuous" flavour tagging performance
      // information. This refers to data/MC scale factors in tag weight bins rather than scale factors
      // for jets to pass a fixed tag weight cut.
      // Both versions (one using names, one using integer indices) are available. As for the latter: like
      // for the regular (non-continuous) case, the method is not protected against wrong usage of this index!

      CalibResult getWeightScaleFactor (const CalibrationDataVariables& variables, const std::string& label, //<--------- One of three
                    Uncertainty unc, unsigned int numVariation = 0, unsigned int mapIndex = 0);

      CalibResult getWeightScaleFactor (const CalibrationDataVariables& variables,
                    unsigned int indexSF, unsigned int indexEff,
                    Uncertainty unc, unsigned int numVariation = 0);

      CalibrationStatus getWeightScaleFactor (const CalibrationDataVariables& variables,
                          unsigned int indexSF, unsigned int indexEff,
                          Uncertainty unc, unsigned int numVariation,
                          CalibResult& result);
 
      // ------------------------------------------------------------------------------------------

      CalibrationStatus runEigenVectorRecomposition(const std::string& author,
                            const std::string& label,
                            const std::string& OP,
                            unsigned int mapindex = 0);
      
      CalibrationStatus runEigenVectorRecomposition(const std::string& label,
                            unsigned int mapindex = 0);
      
      std::map<std::string, std::map<std::string, float>> getEigenVectorRecompositionCoefficientMap();
 
      // ------------------------------------------------------------------------------------------
 
      // Utilities

      const TObject* getMCEfficiencyObject (const std::string& author, const std::string& label,
                        const std::string& OP, unsigned int mapIndex = 0);

      const TH1* getBinnedScaleFactors (const std::string& author, const std::string& label,
                    const std::string& OP);

      const TH1* getShiftedScaleFactors (const std::string& author, const std::string& label,
                     const std::string& OP, const std::string& unc,
                     double sigmas);

      TMatrixDSym getScaleFactorCovarianceMatrix (const std::string& author, const std::string& label,
                          const std::string& OP, const std::string& unc = "all");
 
      // ------------------------------------------------------------------------------------------
 
      // Helper class dealing with the hadronisation reference information.
      // Rootcint requires this to be public.
 
      class HadronisationReferenceHelper {
        public:
          HadronisationReferenceHelper(TMap* mapSF, TMap* mapEff);
          // default constructor (for PROOF purposes)
          HadronisationReferenceHelper() {;}
          bool getReference(const std::string& spec, std::string& ref) const;
 
        private:
          std::map<std::string, std::string> m_refs;
      };
 
      // ------------------------------------------------------------------------------------------

      void initialize(const std::string& jetauthor, const std::string& OP, Uncertainty unc);

      // CalibrationDataContainer* retrieveContainer(const std::string& name, bool isSF);
      CalibrationDataContainer* retrieveContainer(const std::string& label, const std::string& OP, const std::string& author, const std::string& cntname, bool isSF, bool doPrint = true);
 
      // The above two methods need to be modified to handle the various EV techniques
      // 
    
    
    
    
    
    /* Private data members and methods */
    
    private:

      TFile* m_fileEff{}; 
      TFile* m_fileSF{}; 

      std::map<std::string, std::string> m_aliases;

      std::vector<CalibrationDataContainer*> m_objects;
      std::map<std::string, unsigned int>    m_objectIndices;

      std::string getAlias(const std::string& author) const;

      std::string m_filenameSF;
      std::string m_filenameEff;
      std::vector<std::string> m_flavours;
      
      // ------------------------------------------------------------------------------------------
 
      // Eigenvector variations functionality

      std::map<const CalibrationDataContainer*, std::shared_ptr<CalibrationDataEigenVariations> > m_eigenVariationsMap;
      
      bool m_runEigenVectorMethod{};
      Uncertainty m_EVStrategy{}; // <--- In addition, specify whether to use the global eigenvariations method

      std::map<std::string, Analysis::EVReductionStrategy> m_EVReductions;
      
      std::map<std::string, std::vector<std::string> > m_excludeFromCovMatrix;
      // <--------- The above maps the flavour of the jet to the string of uncertainties to exclude from EV on that jet flavour
 

      bool m_useRecommendedEVExclusions{};
      
      bool m_verbose{};
 
      // ------------------------------------------------------------------------------------------
 
      // MC/MC scale factors functionality

      bool m_useMCMCSF{};
      bool m_useTopologyRescaling{};

      std::map<std::string, HadronisationReferenceHelper*> m_refMap;
      std::vector<int>                                     m_hadronisationReference;
 
      // ------------------------------------------------------------------------------------------
 
      // map storing coefficient calculated by EigenRecomposition.
      std::map<std::string, std::map<std::string, float>> m_coefficientMap;
 
      // ------------------------------------------------------------------------------------------
 
      // Bounds checking functionality

      double               m_maxAbsEta{};
      OutOfBoundsStrategy  m_absEtaStrategy{};
      OutOfBoundsStrategy  m_otherStrategy{};
      
      [[nodiscard]] bool checkAbsEta(const CalibrationDataVariables& variables, unsigned int index);

      std::vector<unsigned int> m_etaCounters;
      std::vector<unsigned int> m_mainCounters;
      std::vector<unsigned int> m_extrapolatedCounters;
      // std::vector<unsigned int> m_tagWeightCounters;
      void increaseCounter(unsigned int index, OutOfBoundsType oob = Main);
 
      // for (one-time) checks of scale factors
      void checkWeightScaleFactors(unsigned int indexSF, unsigned int indexEff);
      std::vector<std::pair<unsigned int, unsigned int> > m_checkedWeightScaleFactors;
      double               m_maxTagWeight{};
 
      // make it possible to persistify this class (for PROOF purposes)
      ClassDef(CalibrationDataInterfaceROOT,1)   // platform-independent (main) interface for access to b-tagging information
    }; 
  
} // end of namespace
 
#endif // ANALYSISCALIBRATIONDATAINTERFACEROOT_H