NGnTree.h

#ifndef Ndmspc_NGnTree_H
#define Ndmspc_NGnTree_H
#include <TObject.h>
#include <THnSparse.h>
#include <TH1.h>
#include <TH2.h>
#include <TH3.h>
#include <TObject.h>
#include <vector>
#include "NBinning.h"
#include "NParameters.h"
#include "NStorageTree.h"
// #include "NBinningPoint.h"
 
namespace Ndmspc {

using NHnSparseProcessFuncPtr = void (*)(Ndmspc::NBinningPoint *, TList *, TList *, int);

using NGnProcessFuncPtr = void (*)(Ndmspc::NBinningPoint *, TList *, TList *, int);

using NGnBeginFuncPtr = void (*)(Ndmspc::NBinningPoint *, int);

using NGnEndFuncPtr = void (*)(Ndmspc::NBinningPoint *, int);

class NGnNavigator;
class NGnTree : public TObject {
  public:
  NGnTree();

  NGnTree(std::vector<TAxis *> axes, std::string filename = "", std::string treename = "ngnt");

  NGnTree(TObjArray * axes, std::string filename = "", std::string treename = "ngnt");

  NGnTree(NGnTree * ngnt, std::string filename = "", std::string treename = "ngnt");

  NGnTree(NBinning * binning, NStorageTree * treeStorage);

  NGnTree(THnSparse * hns, std::string parameterAxis, const std::string & outFileName = "/tmp/ngnt_imported.root",
          json cfg = json::object());

  virtual ~NGnTree();

  virtual void Print(Option_t * option = "") const override;

  virtual void Draw(Option_t * option = "") override;

  void Play(int timeout = 0, std::string binning = "", std::vector<int> outputPointIds = {0},
            std::vector<std::vector<int>> ranges = {}, Option_t * option = "");

  NBinning * GetBinning() const { return fBinning; }

  void SetBinning(NBinning * binning) { fBinning = binning; }

  NStorageTree * GetStorageTree() const { return fTreeStorage; }

  std::map<std::string, TList *> GetOutputs() const { return fOutputs; }

  TList * GetOutput(std::string name = "");

  void SetOutputs(std::map<std::string, TList *> outputs) { fOutputs = outputs; }

  NGnTree * GetInput() const { return fInput; }

  void SetInput(NGnTree * input) { fInput = input; }

  NGnNavigator * GetNavigator() const { return fNavigator; }

  void SetNavigator(NGnNavigator * navigator);

  bool IsPureCopy() const { return fIsPureCopy; }

  void SetIsPureCopy(bool val) { fIsPureCopy = val; }

  Long64_t GetEntries() const { return fTreeStorage ? fTreeStorage->GetEntries() : 0; }

  Int_t GetEntry(Long64_t entry, bool checkBinningDef = true);

  Int_t GetEntry(std::vector<std::vector<int>> range, bool checkBinningDef = true);

  bool Close(bool write = false);

  bool Process(NGnProcessFuncPtr func, const json & cfg = json::object(), std::string binningName = "",
               NGnBeginFuncPtr beginFunc = nullptr, NGnEndFuncPtr endFunc = nullptr);

  bool Process(NGnProcessFuncPtr func, const std::vector<std::string> & defNames, const json & cfg = json::object(),
               NBinning * binningIn = nullptr, NGnBeginFuncPtr beginFunc = nullptr, NGnEndFuncPtr endFunc = nullptr);

  void SetWorkerMacro(const std::string & macroList) { fWorkerMacroList = macroList; }

  TList * Projection(const json & cfg, std::string binningName = "");
  NGnNavigator * Reshape(std::string binningName, std::vector<std::vector<int>> levels, int level = 0,
                         std::map<int, std::vector<int>> ranges = {}, std::map<int, std::vector<int>> rangesBase = {});
  NGnNavigator * GetResourceStatisticsNavigator(std::string binningName, std::vector<std::vector<int>> levels,
                                                int level = 0, std::map<int, std::vector<int>> ranges = {},
                                                std::map<int, std::vector<int>> rangesBase = {});
  NParameters * GetParameters() const { return fParameters; }

  bool InitParameters(const std::vector<std::string> & paramNames);

  static NGnTree * Open(const std::string & filename, const std::string & branches = "",
                        const std::string & treename = "ngnt");

  static NGnTree * Open(TTree * tree, const std::string & branches = "", TFile * file = nullptr);

  static NGnTree * Import(const std::string & findPath, const std::string & fileName,
                          const std::vector<std::string> & headers,
                          const std::string &              outFileName = "/tmp/ngnt_imported.root",bool close=true);

  static std::string BuildObjectPath(const json & cfg, const json & objCfg, const NBinningPoint * point);
 
  protected:
  NBinning *                     fBinning{nullptr};     
  NStorageTree *                 fTreeStorage{nullptr}; 
  std::map<std::string, TList *> fOutputs;              
  NGnTree *                      fInput{nullptr};       
  NGnNavigator *                 fNavigator{nullptr};   
  NParameters *                  fParameters{nullptr};  
  bool                           fOwnsBinning{true};    
  bool                           fOwnsTreeStorage{true};
  bool                           fIsPureCopy{false};    
  std::string                    fWorkerMacroList;      

  ClassDefOverride(NGnTree, 1);
};
} // namespace Ndmspc
#endif