NGnNavigator.h

#ifndef Ndmspc_NGnNavigator_H
#define Ndmspc_NGnNavigator_H
#include <TNamed.h>
#include <Buttons.h>
#include <TList.h>
#include <cstddef>
#include <vector>
#include "NBinningDef.h"
#include "NGnTree.h"
namespace Ndmspc {
 
class NGnNavigator : public TNamed {
  public:
  NGnNavigator(const char * name = "GnNavigator", const char * title = "Gn Navigator",
               std::vector<std::string> objectTypes = {"TH1"});
 
  virtual ~NGnNavigator();
 
  NGnNavigator * Reshape(std::string binningName, std::vector<std::vector<int>> levels, size_t level = 0,
                         std::map<int, std::vector<int>> ranges = {}, std::map<int, std::vector<int>> rangesBase = {});
 
  NGnNavigator * Reshape(NBinningDef * binningDef, std::vector<std::vector<int>> levels, size_t level = 0,
                         std::map<int, std::vector<int>> ranges = {}, std::map<int, std::vector<int>> rangesBase = {},
                         NGnNavigator * parent = nullptr);
 
  void Export(const std::string & filename, std::vector<std::string> objectNames, const std::string & wsUrl = "",
              int timeoutMs = 1000);
 
  void ExportToJson(json & j, NGnNavigator * obj, std::vector<std::string> objectNames);
 
  virtual void Print(Option_t * option = "") const override;
 
  virtual void Draw(Option_t * option = "") override;
 
  json GetInfoJson() const;
 
  virtual TList * DrawSpectra(std::string parameterName, std::vector<int> projIds, std::vector<double> minmax = {0.05},
                              const std::string& minmaxMode = "V", Option_t * option = "") const;
 
  virtual TList * DrawSpectraByName(std::string parameterName, std::vector<std::string> projAxes,
                                    std::vector<double> minmax = {0.05}, const std::string& minmaxMode = "V", Option_t * option = "") const;
 
  virtual TList * DrawSpectraAll(std::string parameterName, std::vector<double> minmax = {0.05},
                                 const std::string& minmaxMode = "V", Option_t * option = "") const;
 
  virtual void Paint(Option_t * option = "") override;
 
  Int_t DistancetoPrimitive(Int_t px, Int_t py) override;
 
  virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py) override;
 
  NGnTree * GetGnTree() const { return fGnTree; }
 
  void SetGnTree(NGnTree * tree) { fGnTree = tree; }
 
  std::vector<NGnNavigator *> GetChildren() const { return fChildren; }
 
  void SetChildrenSize(size_t n) { fChildren.resize(n); }
 
  NGnNavigator * GetChild(size_t index) const;
 
  NGnNavigator * GetChild(std::vector<std::vector<size_t>> coords) const;
 
  void SetChild(NGnNavigator * child, int index = -1);
 
  NGnNavigator * GetParent() const { return fParent; }
 
  NGnNavigator * GetRoot() const;
 
  void SetParent(NGnNavigator * parent) { fParent = parent; }
 
  std::map<std::string, std::vector<TObject *>> GetObjectContentMap() const { return fObjectContentMap; }
 
  void ResizeObjectContentMap(const std::string & name, size_t n) { fObjectContentMap[name].resize(n); };
 
  std::vector<TObject *> GetObjects(const std::string & name) const;
 
  TObject * GetObject(const std::string & name, int index = 0) const;
 
  void SetObject(const std::string & name, TObject * obj, int index = -1);
 
  void SetObjectTypes(const std::vector<std::string> & types) { fObjectTypes = types; }
 
  std::vector<std::string> GetObjectNames() const { return fObjectNames; }
 
  void SetObjectNames(const std::vector<std::string> & names) { fObjectNames = names; }
 
  std::map<std::string, std::vector<double>> GetParameterContentMap() const { return fParameterContentMap; }
 
  void ResizeParameterContentMap(const std::string & name, int n) { fParameterContentMap[name].resize(n); };
 
  std::vector<double> GetParameters(const std::string & name) const;
 
  double GetParameter(const std::string & name, int index = 0) const;
 
  void SetParameter(const std::string & name, double value, int index = -1);
 
  std::map<std::string, std::vector<double>> GetParameterErrorContentMap() const { return fParameterErrorContentMap; }
 
  void ResizeParameterErrorContentMap(const std::string & name, int n) { fParameterErrorContentMap[name].resize(n); };
 
  std::vector<double> GetParameterErrors(const std::string & name) const;
 
  double GetParameterError(const std::string & name, int index = 0) const;
 
  void SetParameterError(const std::string & name, double value, int index = -1);
  std::vector<std::string> GetParameterNames() const { return fParameterNames; }
 
  void SetParameterNames(const std::vector<std::string> & names) { fParameterNames = names; }
 
  TH1 * GetProjection() const { return fProjection; }
 
  void SetProjection(TH1 * h) { fProjection = h; }
 
  size_t GetNLevels() const { return fNLevels; }
 
  void SetNLevels(size_t n) { fNLevels = n; }
 
  size_t GetLevel() const { return fLevel; }
 
  void SetLevel(size_t l) { fLevel = l; }
 
  std::vector<std::vector<int>> GetLevels() const { return fLevels; }
 
  void SetLevels(const std::vector<std::vector<int>> & levels) { fLevels = levels; }
 
  size_t GetNCells() const { return fNCells; }
 
  void SetNCells(size_t n) { fNCells = n; }
 
  size_t GetLastIndexSelected() const { return fLastIndexSelected; }
 
  void SetLastIndexSelected(size_t idx) { fLastIndexSelected = idx; }
 
  size_t GetLastHoverBin() const { return fLastHoverBin; }
 
  void SetLastHoverBin(size_t b) { fLastHoverBin = b; }
 
  // /**
  //  * @brief Open navigator from file.
  //  * @param filename File name.
  //  * @param branches Branches to open.
  //  * @param treename Tree name (default: "ngnt").
  //  * @return Pointer to opened NGnNavigator.
  //  */
  // static NGnNavigator * Open(const std::string & filename, const std::string & branches = "",
  //                            const std::string & treename = "ngnt");
  //
  // /**
  //  * @brief Open navigator from TTree.
  //  * @param tree Pointer to TTree.
  //  * @param branches Branches to open.
  //  * @param file Pointer to TFile.
  //  * @return Pointer to opened NGnNavigator.
  //  */
  // static NGnNavigator * Open(TTree * tree, const std::string & branches = "", TFile * file = nullptr);
 
  private:
  NGnTree *                                     fGnTree{nullptr};            
  std::vector<std::string>                      fObjectNames{};              
  std::map<std::string, std::vector<TObject *>> fObjectContentMap{};         
  std::vector<std::string>                      fParameterNames{};           
  std::map<std::string, std::vector<double>>    fParameterContentMap{};      
  std::map<std::string, std::vector<double>>    fParameterErrorContentMap{}; 
  std::vector<std::string>                      fObjectTypes{"TH1"};         
 
  NGnNavigator *              fParent{nullptr}; 
  std::vector<NGnNavigator *> fChildren{};      
 
  TH1 *                         fProjection{nullptr};   
  size_t                        fNLevels{1};            
  size_t                        fLevel{0};              
  std::vector<std::vector<int>> fLevels{};              
  size_t                        fNCells{0};             
  size_t                        fLastHoverBin{0};       
  size_t                        fLastIndexSelected{0};  
  Int_t                         fTrigger{kButton1Down}; 
 
  ClassDefOverride(NGnNavigator, 2);
};
} // namespace Ndmspc
#endif