EMAPMatrix.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
 
 
#ifndef EMAPMATRIX_H
#define EMAPMATRIX_H
 
#include <iostream>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
#include "GaudiKernel/StatusCode.h"
 
// a helper class
class EMAPMatrixAxis 
{
public:
    
  EMAPMatrixAxis(std::string name, const std::vector <double> &bins): m_name(std::move(name)), m_vecBins(bins) {};
 
        
  ~EMAPMatrixAxis() {};  
        
  std::vector<double> getBinningInformation() const {return m_vecBins; };
 
  unsigned int getNumberOfBins() const;
        
  int getBinIndex(double x) const;
//   double getMeanOfBin(unsigned int i) const;         
//   /** returns width of bin at index i*/
//   double getWidthOfBin(unsigned int i) const;
        
  bool isInRange(double x) const;
 
//   /** set name of axis*/
//   void     setName(std::string name);
//   /** return name of axis*/
  std::string   getName() const {return m_name; };
    
private:
  std::string m_name;
  std::vector<double> m_vecBins;
};
 
 
template<class T>
class EMAPMatrix
{
public:
  // Constructors
        
  EMAPMatrix();
  EMAPMatrix(const std::vector<EMAPMatrixAxis>& axes, const std::string& textDescription);
  //        EMAPMatrix(std::vector<EMAPMatrixAxis> axes, T emptyObject);
 
  EMAPMatrix(const EMAPMatrix& ob) = default;
                
  ~EMAPMatrix();
        
  EMAPMatrix& operator = (const EMAPMatrix& ob) = default;
        
  // Constructor Methods
  StatusCode setupMatrix(std::vector<EMAPMatrixAxis> axes);
  //        /** Setup matrix with std::vector of axes to define dimensions and binnging of this matrix
  //            @param axes: std::vector of EMAPMatrixAxis objects
  //            @emptyObject: Standard object which is used to fill the matrix if it is supposed to be empty/cleaned*/
  //        void setupMatrix(std::vector<EMAPMatrixAxis> axes, T emptyObject);
        
  // Accessing the Matrix via Functions
  StatusCode setBinContent(double x, T value);
  StatusCode setBinContent(double x, double y, T value);
  StatusCode setBinContent(double x, double y, double z, T value);
  StatusCode setBinContent(double x, double y, double z, double u, T value);
  StatusCode setBinContent(double x, double y, double z, double u, double v, T value);
  StatusCode setBinContent(const std::vector<double>& x, T value);
 
  const T* getBinContent(double x) const;
  const T* getBinContent(double x, double y) const;
  const T* getBinContent(double x, double y, double z) const;
  const T* getBinContent(double x, double y, double z, double u) const;
  const T* getBinContent(double x, double y, double z, double u, double v) const;
  const T* getBinContent(const std::vector<double>& x) const;
 
  //        /** Add "T" to bin which corresponds to value std::vector x. Can only used for n-dimensional 
  //            matrix if the length of the std::vector x ind n.
  //            @param x: std::vector of length n which represents the values on all axes
  //            @param T: value which should be added*/
  //        bool    addBinContent(std::vector<double> x, T value);
        
  // Get StatusCode
  //        bool getStatusCode()            {   return m_StatusCode;}
  int  getDimensions() const        {   return m_dimensions;}
 
  // Get Axis Information
  EMAPMatrixAxis  getAxis(unsigned int i) const {   return m_axis[i];}
                
  std::vector<T> getValues() const  {   return m_matrix;}
 
        
  // Clearing functions
        
  void  clear();
  void  clearEntries();
 
  bool isInRange(const std::vector<double>& x) const;
        
  void setTextDescription(const std::string& text);
  std::string getTextDescription() const;
        
protected:  
 
  // T          *m_emptyObject;
  unsigned int      m_dimensions;
  //        bool            m_StatusCode;
  std::vector<EMAPMatrixAxis>   m_axis;
 
  std::vector< T >          m_matrix;   
  std::vector< unsigned int >   m_base;     
  std::string           m_textDescription;  
        
  //    private:
  //static const unsigned int   m_dimMax=5;
                
  StatusCode setupEntries();
        
  unsigned int              Index(const std::vector<unsigned int>& x) const;
  std::vector<unsigned int>         Index(unsigned int id);
  //        T&                  Access(std::vector<unsigned int> x);
};
 
#include "egammaConditions/EMAPMatrix.icc"
 
#endif