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