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