CalibrationDataContainer.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
// CalibrationDataContainer.h, (c) ATLAS Detector software
 
#ifndef ANALYSISCALIBRATIONDATACONTAINER_H
#define ANALYSISCALIBRATIONDATACONTAINER_H
 
#include <vector>
#include <map>
#include <string>
 
#include "TMap.h"
#include "THashList.h"
 
class TH1;
 
#include "CalibrationDataInterface/CalibrationDataVariables.h"
 
namespace Analysis {
 
  typedef std::pair<double, double> UncertaintyResult;
 
  const unsigned int MaxCalibrationVars = 10;
 
  class CalibrationDataContainer: public TMap {
  public:
    CalibrationDataContainer(const char* name = "default"); // default ctor needed for persistence
    virtual ~CalibrationDataContainer(); // virtual dtor needed for persistence
 
    enum CalibrationParametrization {
      kPt = 0,       // calibrated jet pt
      kEta = 1,      // jet eta
      kAbsEta = 2,   // jet |eta|
      kTagWeight = 3 // tagging output (relevant for "continuous" calibration)
    };
 
    std::vector<std::string> listUncertainties() const;
 
    CalibrationStatus getUncertainties(const CalibrationDataVariables& x,
                       std::map<std::string, Analysis::UncertaintyResult>& all);
 
    std::string getComment() const;
 
    std::string getHadronisation() const;
 
    std::string getExcludedUncertainties() const;
 
    virtual CalibrationStatus getResult(const CalibrationDataVariables& x,
                    double& result,
                    TObject* obj = 0, bool extrapolate = false) = 0;
 
    virtual CalibrationStatus getStatUncertainty(const CalibrationDataVariables& x,
                         double& result) = 0;
 
    CalibrationStatus         getSystUncertainty(const CalibrationDataVariables& x,
                         UncertaintyResult& result,
                         TObject* obj = 0);
 
    virtual CalibrationStatus getUncertainty(const std::string& unc,
                         const CalibrationDataVariables& x,
                         UncertaintyResult& result, TObject* obj = 0) = 0;
    
    void setResult(TObject* obj);
 
    void setComment(const std::string& text);
 
    void setHadronisation(const std::string& text);
 
    void setExcludedUncertainties(const std::string& text);
 
    void setUncertainty(const std::string& unc, TObject* obj);
 
    void restrictToRange(bool restrict) { m_restrict = restrict; }
 
    bool isRangeRestricted() const { return m_restrict; }
 
    double getLowerBound(unsigned int vartype, bool extrapolate = false) const;
 
    double getUpperBound(unsigned int vartype, bool extrapolate = false) const;
 
    std::vector<std::pair<double, double> > getBounds();
 
    std::vector<unsigned int> getVariableTypes();
 
    static bool isNearlyEqual (double a, double b);
 
  protected:
 
    int typeFromString(const std::string& key) const;
 
    // /** compute the variables to be used for the given 'uncertainty'
    //  @param  x user-supplied (kinematic or other) variables
    //  @param  unc given source of uncertainty (can also be the central value)
    //  @return false if the given variables are outside the parametrisation's validity range
    // */
    // bool computeVariables(const std::string& unc,
    //            const CalibrationDataVariables& x) const;
 
    CalibrationStatus computeVariables(const CalibrationDataVariables& x, bool extrapolate = false);
 
    virtual void computeVariableTypes() = 0;
 
    std::vector<double> m_lowerBounds;   // lower validity bounds
    std::vector<double> m_upperBounds;   // upper validity bounds
    // persistency not needed for the following (relevant for histogram uncertainties only and computed automatically)
    std::vector<double> m_lowerBoundsExtrapolated;   
    std::vector<double> m_upperBoundsExtrapolated;   
 
    TObject* m_objResult;                
    TObject* m_objSystematics;           
 
    double m_vars[MaxCalibrationVars];   
 
    std::vector<unsigned int> m_variables;  
    // mutable std::map<std::string, std::vector<unsigned int> > m_variables; //! persistency not needed for this variable
    // mutable std::vector<unsigned int>* m_variablesResult;                  //! persistency not needed for this variable
 
  private:
 
    bool m_restrict;
 
    ClassDef(CalibrationDataContainer, 1);  // base class for calibration data objects
 
  };
 
 
 
 
//__________________________________________________________________________________________
 
  class CalibrationDataHistogramContainer: public CalibrationDataContainer {
  public:
    CalibrationDataHistogramContainer(const char* name = "default"); // default ctor needed for persistence
    virtual ~CalibrationDataHistogramContainer();    // virtual dtor needed for persistence
    virtual CalibrationStatus getResult(const CalibrationDataVariables& x, double& result,
                    TObject* obj = 0, bool extrapolate = false);
    virtual CalibrationStatus getStatUncertainty(const CalibrationDataVariables& x, double& result);
    virtual CalibrationStatus getUncertainty(const std::string& unc, const CalibrationDataVariables& x,
                         UncertaintyResult& result, TObject* obj = 0);
 
    bool isBinCorrelated(const std::string& unc) const;
 
    void setUncorrelated(const std::string& unc);
 
    void setInterpolated(bool doInterpolate);
 
    virtual bool isInterpolated() const;
 
    virtual int getTagWeightAxis();
 
    virtual std::vector<double> getBinBoundaries(unsigned int vartype);
 
    virtual int getEigenvectorReduction(unsigned int choice) const;
    
  protected:
 
    std::map<unsigned int, std::vector<double> > m_binBoundaries; 
 
  private:
 
    THashList m_uncorrelatedSyst;
 
    bool m_interpolate;
 
    double getInterpolatedResult(TH1* hist) const;
 
    double getInterpolatedUncertainty(TH1* hist) const;
 
    void checkBounds();
 
    // /** utility for determining global bin number, subject to extrapolation constraints.
    //  @param  hist          pointer to histogram containing actual bin boundary information
    //  @param  doExtrapolate specifies whether or not an extrapolation uncertainty is being requested
    // */
    // Int_t findBin(const TH1* hist, bool doExtrapolate) const;
 
    virtual void computeVariableTypes();
 
    ClassDef(CalibrationDataHistogramContainer, 2);  // histogram based calibration data object
  };
 
//__________________________________________________________________________________________
 
  class CalibrationDataMappedHistogramContainer: public CalibrationDataHistogramContainer {
  public:
    CalibrationDataMappedHistogramContainer(const char* name = "default"); // default ctor needed for persistence
    virtual ~CalibrationDataMappedHistogramContainer();    // virtual dtor needed for persistence
    virtual CalibrationStatus getResult(const CalibrationDataVariables& x, double& result,
                    TObject* obj = 0, bool extrapolate = false);
    virtual CalibrationStatus getStatUncertainty(const CalibrationDataVariables& x, double& result);
    virtual CalibrationStatus getUncertainty(const std::string& unc, const CalibrationDataVariables& x,
                         UncertaintyResult& result, TObject* obj = 0);
 
    virtual bool isInterpolated() const { return false; }
 
    virtual int getTagWeightAxis();
 
    void setMappedVariables(const std::vector<std::string>& variables);
 
    const std::vector<std::string>& getMappedVariables() const;
 
    virtual std::vector<double> getBinBoundaries(unsigned int vartype);
 
    class Bin {
    public:
      Bin();                                                 // default constructor (for persistency)
      Bin(unsigned int dimension, const double* low, const double* up);
      Bin(const Bin& other);
      Bin& operator=(const Bin& other);
      ~Bin();
      // return the number of dimensions
      unsigned int getDimension() const { return m_dimension; }
      bool   contains(const double* x) const;
      double getUpperBound(unsigned int dim) const;
      double getLowerBound(unsigned int dim) const;
    private:
      unsigned int m_dimension;
      double*      m_low; //[m_dimension]
      double*      m_up;  //[m_dimension]
    };
 
    unsigned int addBin(const Bin& bin);
 
    unsigned int getNMappedBins() const;
 
  private:
 
    std::vector<std::string>  m_mapped;
 
    unsigned int m_beginMapped;                   
 
    std::vector<Bin> m_bins;
    // cache index to the last used bin
    unsigned int m_lastBin;                       
 
    Int_t findBin();
    Int_t findMappedBin(const double* x);
 
    void checkBounds();
 
    virtual void computeVariableTypes();
 
    ClassDef(CalibrationDataMappedHistogramContainer, 1);  // 'mapped' histogram based calibration data object
  };
 
 
//__________________________________________________________________________________________
 
  class CalibrationDataFunctionContainer: public CalibrationDataContainer {
  public:
    CalibrationDataFunctionContainer(const char* name = "default"); // default ctor needed for persistence
    virtual ~CalibrationDataFunctionContainer();   // virtual dtor needed for persistence
    virtual CalibrationStatus getResult(const CalibrationDataVariables& x, double& result,
                    TObject* obj = 0, bool /* extrapolate */ = false);
    virtual CalibrationStatus getStatUncertainty(const CalibrationDataVariables& x, double& result);
    virtual CalibrationStatus getUncertainty(const std::string& unc, const CalibrationDataVariables& x,
                         UncertaintyResult& result,  TObject* obj = 0);
 
    inline void setLowerBound(int vartype, double bound) {m_lowerBounds[vartype] = bound; }
    
    inline void setUpperBound(int vartype, double bound) {m_upperBounds[vartype] = bound; }
    
  private:
 
    TObject* m_objStatistics;      
 
    virtual void computeVariableTypes();
 
    ClassDef(CalibrationDataFunctionContainer, 1); // function based calibration data object
  };
 
} // end of namespace
 
#endif