CaloLocalHadCoeff.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef CALOCONDITIONS_CALOLOCALHADCOEFF_H
#define CALOCONDITIONS_CALOLOCALHADCOEFF_H
 
#include "AthenaKernel/CLASS_DEF.h"
#include <vector>
#include <string>
#include <fstream>
 
class CaloLocalHadCoeff {
  public:
 
    class LocalHadDimension {
      public:
        LocalHadDimension() : m_type(0), m_nbins(0), m_xmin(0.0), m_xmax(0.0), m_dx(0.0) {};
 
        LocalHadDimension(const char *title, unsigned int typ, int nbins, float xmin, float xmax) :
          m_title(title), m_type(typ), m_nbins(nbins), m_xmin(xmin), m_xmax(xmax)
          {
            m_xbins.resize(0);
            m_dx = (m_xmax-m_xmin)/float(m_nbins);
          }
 
        LocalHadDimension(const char *title, unsigned int typ, std::vector<float > &xbins) :
          m_title(title), m_type(typ),
          m_nbins (xbins.size() - 1),
          m_xmin (xbins.front()),
          m_xmax (xbins.back()),
          m_dx(0.0),
          m_xbins (xbins)
          {
          }
        LocalHadDimension(const LocalHadDimension &other) = default;
        LocalHadDimension& operator= (const LocalHadDimension &other) = default;
        LocalHadDimension( LocalHadDimension &&) noexcept = default;
        LocalHadDimension& operator= ( LocalHadDimension &&)  noexcept = default;
        // access methods
 
        inline unsigned int getType() const {return m_type;}
 
        inline int getNbins() const {return m_nbins;}
 
        inline float getXmin() const {return m_xmin;}
 
        inline float getXmax() const {return m_xmax;}
 
        inline float getDx() const {return m_dx;}
 
        int getBin(float &x) const;
 
        int getBinAdjusted(float &x, float &xadj) const;
 
        std::string getTitle() const {return m_title;}
 
      private:
        std::string m_title;
 
        unsigned int m_type;
 
        int m_nbins;
 
        float m_xmin;
 
        float m_xmax;
 
        float m_dx;
 
        std::vector<float > m_xbins;
    };
 
    class LocalHadArea {
      public:
        LocalHadArea() : m_type(0), m_npars(0), m_offset(0), m_length(0) {};
        LocalHadArea(const char *title, int typ, int npars) : m_title(title), m_type(typ), m_npars(npars), m_offset(0), m_length(0) 
        {
          m_dims.resize(0);
          m_dims_loc.resize(0);
        };
        LocalHadArea(const LocalHadArea &other) = default;
        LocalHadArea& operator= (const LocalHadArea &other) = default;
        LocalHadArea( LocalHadArea &&other) noexcept = default;
        LocalHadArea& operator= ( LocalHadArea &&other) noexcept = default;
 
        inline unsigned int getType() const { return m_type; }
        inline int getNpars() const { return m_npars; }
        inline int getOffset() const { return m_offset; }
        inline int getLength() const { return m_length; }
        inline int getNdim() const { return (int) m_dims.size(); }
        inline int getDimLoc(int i_dim) const { return m_dims_loc[i_dim]; }
        std::string getTitle() const {return m_title;}
 
        void setOffset(int offset) { m_offset = offset; }
        void setLength(int length) { m_length = length; }
        void addDimension(LocalHadDimension &dim);
        const CaloLocalHadCoeff::LocalHadDimension *getDimension(int n_dim) const { return &(m_dims[n_dim]); }
 
      private:
        std::string m_title;
 
        unsigned int m_type;
 
        int m_npars;
 
        int m_offset;
 
        int m_length;
 
        std::vector<LocalHadDimension > m_dims;
 
        std::vector<int > m_dims_loc;
    };
 
    typedef std::vector<float> LocalHadCoeff;
 
    CaloLocalHadCoeff();
 
    CaloLocalHadCoeff(const CaloLocalHadCoeff &other) = default;
    CaloLocalHadCoeff& operator= (const CaloLocalHadCoeff &other) = default;
    //Move operators
    CaloLocalHadCoeff(CaloLocalHadCoeff &&) noexcept = default;
    CaloLocalHadCoeff& operator= (CaloLocalHadCoeff &&) noexcept = default;
 
    //
    // general access methods
    std::string getTitle() const {return m_title;}
 
    void setTitle(const std::string &title) {m_title = title; }
 
    //
    // access methods for areas
 
    inline int getSizeAreaSet() const { return (int)m_AreaSet.size(); }
 
    void addArea(LocalHadArea & theArea);
 
    void setArea(const int n_area, const LocalHadArea & theArea);
 
    const LocalHadArea *getArea(int n_area) const;
 
    const LocalHadArea *getAreaFromBin(int iBin) const;
 
    const LocalHadArea *getAreaFromBin(int iBin, int &i_area) const;
 
    //
    // access methods for parameters
 
    inline int getSizeCoeffSet() const { return (int)m_CoeffSet.size(); }
 
    void setCoeff(const int iBin, const LocalHadCoeff & theCoeff);
 
    const LocalHadCoeff * getCoeff(const int & iBin) const;
 
    const LocalHadCoeff * getCoeff(const int & n_area, std::vector<float> &vars) const;
 
    //
    // access method for bins
 
    int getBin(const int n_area, std::vector<float> &vars) const;
 
    int getBin(const int n_area, std::vector<int> &v_indexes) const;
 
    int bin2indexes(const int iBin, std::vector<int> &v_dim_indx) const;
 
    bool isNeighbour(const int iBinx, std::vector<int> &v_indx) const;
 
    bool isFilled(const int iBin) const;
 
    bool getInterpArrays(const int n_area, const std::vector<int> &dim, std::vector<float> &x,
                         std::vector<double> &xadj, std::vector<unsigned int> &gbin) const; 
 
  private:
 
    std::string m_title;
 
    std::vector<LocalHadCoeff> m_CoeffSet;
 
    std::vector<LocalHadArea> m_AreaSet;
};
//Class Identifier obtained by 'clid CaloLocalHadCoeff'
CLASS_DEF(CaloLocalHadCoeff, 29079131, 1)
 
#include "AthenaKernel/CondCont.h"
CONDCONT_DEF( CaloLocalHadCoeff, 82862607 );
 
#endif