/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/CalibrationDataInterface/CalibrationDataInterface/CalibrationDataContainer.h

// 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) const;

    std::string getComment() const;

    std::string getHadronisation() const;

    virtual CalibrationStatus getResult(const CalibrationDataVariables& x,
                    double& result,
                    TObject* obj = 0, bool extrapolate = false) const = 0;

    virtual CalibrationStatus getStatUncertainty(const CalibrationDataVariables& x,
                         double& result) const = 0;

    CalibrationStatus         getSystUncertainty(const CalibrationDataVariables& x,
                         UncertaintyResult& result,
                         TObject* obj = 0) const;

    virtual CalibrationStatus getUncertainty(const std::string& unc,
                         const CalibrationDataVariables& x,
                         UncertaintyResult& result, TObject* obj = 0) const = 0;
    
    void setResult(TObject* obj);

    void setComment(const std::string& text);

    void setHadronisation(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() const;

    std::vector<unsigned int> getVariableTypes() const;

    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) const;

    virtual void computeVariableTypes() const = 0;

    mutable std::vector<double> m_lowerBounds;   // lower validity bounds
    mutable std::vector<double> m_upperBounds;   // upper validity bounds
    // persistency not needed for the following (relevant for histogram uncertainties only and computed automatically)
    mutable std::vector<double> m_lowerBoundsExtrapolated;   
    mutable std::vector<double> m_upperBoundsExtrapolated;   

    mutable TObject* m_objResult;                
    mutable TObject* m_objSystematics;           

    mutable double m_vars[MaxCalibrationVars];   

    mutable 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) const;
    virtual CalibrationStatus getStatUncertainty(const CalibrationDataVariables& x, double& result) const;
    virtual CalibrationStatus getUncertainty(const std::string& unc, const CalibrationDataVariables& x,
                         UncertaintyResult& result, TObject* obj = 0) const;

    bool isBinCorrelated(const std::string& unc) const;

    void setUncorrelated(const std::string& unc);

    void setInterpolated(bool doInterpolate);

    virtual bool isInterpolated() const;

    virtual int getTagWeightAxis() const;

    virtual std::vector<double> getBinBoundaries(unsigned int vartype) const;

    virtual int getEigenvectorReduction(unsigned int choice) const;
    
  protected:

    mutable 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() const;

    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) const;
    virtual CalibrationStatus getStatUncertainty(const CalibrationDataVariables& x, double& result) const;
    virtual CalibrationStatus getUncertainty(const std::string& unc, const CalibrationDataVariables& x,
                         UncertaintyResult& result, TObject* obj = 0) const;

    virtual bool isInterpolated() const { return false; }

    virtual int getTagWeightAxis() const;

    void setMappedVariables(const std::vector<std::string>& variables);

    std::vector<std::string> getMappedVariables() const;

    virtual std::vector<double> getBinBoundaries(unsigned int vartype) const;

    class Bin {
    public:
      Bin();                                                 // default constructor (for persistency)
      Bin(unsigned int dimension, double* low, double* up);
      Bin(const Bin& other);
      ~Bin();
      // return the number of dimensions
      unsigned int getDimension() const { return m_dimension; }
      bool   contains(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;

    mutable unsigned int m_beginMapped;                   

    std::vector<Bin> m_bins;
    // cache index to the last used bin
    mutable unsigned int m_lastBin;                       

    Int_t findBin() const;
    Int_t findMappedBin(double* x) const;

    void checkBounds();

    virtual void computeVariableTypes() const;

    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) const;
    virtual CalibrationStatus getStatUncertainty(const CalibrationDataVariables& x, double& result) const;
    virtual CalibrationStatus getUncertainty(const std::string& unc, const CalibrationDataVariables& x,
                         UncertaintyResult& result,  TObject* obj = 0) const;

    inline void setLowerBound(int vartype, double bound) {m_lowerBounds[vartype] = bound; }
    
    inline void setUpperBound(int vartype, double bound) {m_upperBounds[vartype] = bound; }
    
  private:

    mutable TObject* m_objStatistics;      

    virtual void computeVariableTypes() const;

    ClassDef(CalibrationDataFunctionContainer, 1); // function based calibration data object
  };

} // end of namespace

#endif 

---