NBinningPoint.h

#ifndef Ndmspc_NBinningPoint_H
#define Ndmspc_NBinningPoint_H
#include <TObject.h>
#include "NLogger.h"
#include "NParameters.h"
 
namespace Ndmspc {
 
class NBinning;
class NStorageTree;
class NGnTree;
class NBinningPoint : public TObject {
  public:
  NBinningPoint(NBinning * b = nullptr);
 
  virtual ~NBinningPoint();
 
  virtual void Print(Option_t * option = "") const;
 
  virtual void Reset();
 
  Int_t GetNDimensionsContent() const { return fContentNDimensions; }
 
  Int_t * GetCoords() const { return fContentCoords; }
 
  Int_t GetNDimensions() const { return fNDimensions; }
 
  Int_t * GetStorageCoords() const { return fStorageCoords; }
 
  bool RecalculateStorageCoords(Long64_t entry = -1, bool useBinningDefCheck = false);
 
  bool SetPointContentFromLinearIndex(Long64_t linBin, bool checkBinningDef = false);
 
  NStorageTree * GetStorageTree() const { return fTreeStorage; }
 
  Long64_t Fill(bool ignoreFilledCheck = false);
 
  json & GetCfg() { return fCfg; }
 
  void SetCfg(json cfg) { fCfg = cfg; }
 
  std::map<int, std::vector<int>> GetBaseAxisRanges() const;
 
  std::string GetString(const std::string & prefix = "", bool all = false) const;
 
  std::vector<std::string> GetLabels() const { return fLabels; }
 
  Double_t * GetMins() const { return fMins; }
 
  Double_t * GetMaxs() const { return fMaxs; }
 
  Double_t GetBinMin(std::string axis) const;
 
  Double_t GetBinMax(std::string axis) const;
 
  Double_t GetBinCenter(std::string axis) const;
 
  std::string GetBinLabel(std::string axis) const;
 
  Int_t GetBin(std::string axis) const;
 
  NBinning * GetBinning() const { return fBinning; }
 
  void SetBinning(NBinning * b);
 
  NStorageTree * GetTreeStorage() const { return fTreeStorage; }
 
  void SetTreeStorage(NStorageTree * s) { fTreeStorage = s; }
 
  NGnTree * GetInput() const { return fInput; }
 
  void SetInput(NGnTree * input) { fInput = input; }
 
  void SetEntryNumber(Long64_t entry) { fEntryNumber = entry; }
 
  Long64_t GetEntryNumber() const { return fEntryNumber; }
 
  void SetParameters(NParameters * params) { fParameters = params; }
 
  NParameters * GetParameters() const { return fParameters; }
 
  TObject * GetTempObject(const std::string & name) const;
 
  void SetTempObject(const std::string & name, TObject * obj) { fTempObjects[name] = obj; }
 
  json & GetTempCfg() { return fTempCfg; }
 
  private:
  json                             fCfg{};                  
  NGnTree *                        fInput{nullptr};         
  NBinning *                       fBinning{nullptr};       
  NStorageTree *                   fTreeStorage{nullptr};   
  Int_t                            fContentNDimensions{1};  
  Int_t *                          fContentCoords{nullptr}; 
  Int_t                            fNDimensions{1};         
  Int_t *                          fStorageCoords{nullptr}; 
  Double_t *                       fMins{nullptr};          
  Double_t *                       fMaxs{nullptr};          
  Int_t *                          fBaseBinMin{nullptr};    
  Int_t *                          fBaseBinMax{nullptr};    
  std::vector<std::string>         fLabels{};               
  Long64_t                         fEntryNumber{-1};        
  NParameters *                    fParameters{nullptr};    
  std::map<std::string, TObject *> fTempObjects;            
  json                             fTempCfg{};              
 
  ClassDef(NBinningPoint, 1);
};
} // namespace Ndmspc
#endif