CaloLocalHadCoeff.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 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;

        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]; }
        const 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
    const 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