NBinning.h

#ifndef Ndmspc_NBinning_H
#define Ndmspc_NBinning_H
#include <TObject.h>
#include <THnSparse.h>
#include <TAxis.h>
#include <cstddef>
#include <vector>
#include <map>
#include "TObjArray.h"
#include "NBinningDef.h"
#include "NBinningPoint.h"
 
namespace Ndmspc {
 
enum class Binning {
  kSingle    = 0, 
  kMultiple  = 1, 
  kUser      = 2, 
  kUndefined = 3  
};
 
enum class AxisType {
  kFixed     = 0, 
  kVariable  = 1, 
  kUndefined = 2, 
};
 
class NBinning : public TObject {
  public:
  NBinning();
 
  NBinning(TObjArray * axes);
 
  NBinning(std::vector<TAxis *> axes);
 
  virtual ~NBinning();
 
  void Initialize();
 
  void Reset();
 
  virtual void Print(Option_t * option = "") const;
 
  void PrintContent(Option_t * option = "") const;
 
  Long64_t FillAll(NBinningDef * def = nullptr);
 
  std::vector<std::vector<int>> GetCoordsRange(std::vector<int> c) const;
 
  std::vector<std::vector<int>> GetAxisRanges(std::vector<int> c) const;
 
  bool GetAxisRange(size_t axisId, double & min, double & max, std::vector<int> c) const;
 
  bool GetAxisRangeInBase(size_t axisId, int & min, int & max, std::vector<int> c) const;
 
  TObjArray * GenerateListOfAxes();
 
  std::vector<int> GetAxisBinning(size_t axisId, const std::vector<int> & c) const;
 
  std::vector<int> GetAxisIndexes(AxisType type) const;
 
  std::vector<int> GetAxisIndexesByNames(std::vector<std::string> axisNames) const;
 
  std::vector<std::string> GetAxisNamesByType(AxisType type) const;
 
  std::vector<std::string> GetAxisNamesByIndexes(std::vector<int> axisIds) const;
 
  bool AddBinning(size_t id, std::vector<int> binning, size_t n = 1);
 
  bool AddBinningVariable(size_t id, std::vector<int> mins);
 
  bool AddBinningViaBinWidths(size_t id, std::vector<std::vector<int>> widths);
 
  bool SetAxisType(size_t id, AxisType type);
 
  THnSparse * GetMap() const { return fMap; }
 
  THnSparse * GetContent() const { return fContent; }
 
  std::vector<TAxis *> GetAxes() const { return fAxes; }
 
  std::vector<TAxis *> GetAxesByType(AxisType type) const;
 
  Binning GetBinningType(size_t i) const;
 
  AxisType GetAxisType(size_t i) const;
 
  char GetAxisTypeChar(size_t i) const;
 
  NBinningDef * GetDefinition(const std::string & name = "");
 
  std::map<std::string, NBinningDef *> GetDefinitions() const { return fDefinitions; }
 
  std::vector<std::string> GetDefinitionNames() const { return fDefinitionNames; }
 
  std::string GetCurrentDefinitionName() const { return fCurrentDefinitionName; }
 
  void SetCurrentDefinitionName(const std::string & name);
 
  void AddBinningDefinition(std::string name, std::map<std::string, std::vector<std::vector<int>>> binning,
                            bool forceDefault = false);
 
  NBinningPoint * GetPoint();
 
  NBinningPoint * GetPoint(size_t id, const std::string binning = "");
 
  void SetPoint(NBinningPoint * point) { fPoint = point; }
 
  bool SetCfg(const json & cfg);
 
  private:
  THnSparse *                          fMap{nullptr};              
  THnSparse *                          fContent{nullptr};          
  std::vector<TAxis *>                 fAxes;                      
  std::vector<Binning>                 fBinningTypes;              
  std::vector<AxisType>                fAxisTypes;                 
  std::string                          fCurrentDefinitionName{""}; 
  std::map<std::string, NBinningDef *> fDefinitions;               
  std::vector<std::string>             fDefinitionNames;           
  NBinningPoint *                      fPoint{nullptr};            
 
  ClassDef(NBinning, 1);
};
} // namespace Ndmspc
#endif