NUtils.h

#ifndef NdmspcCoreNUtils_H
#define NdmspcCoreNUtils_H
 
#include <set>
#include <vector>
#include <TFile.h>
#include <TCanvas.h>
#include <TAxis.h>
#include <TMacro.h>
#include <TH2.h>
#include <TH3.h>
#include <THnSparse.h>
#include <TBufferJSON.h>
#include <TString.h>
#include "NLogger.h"
 
namespace Ndmspc {
class NUtils : TObject {
 
  NUtils() {};
  virtual ~NUtils() {};
 
  public:
  static bool EnableMT(Int_t numthreads = -1);
 
  static bool AccessPathName(std::string path);
 
  static bool IsFileSupported(std::string filename);
 
  static int Cp(std::string source, std::string destination,Bool_t progressbar = kTRUE);
  static bool CreateDirectory(const std::string & path);
 
  static TFile * OpenFile(std::string filename, std::string mode = "READ", bool createLocalDir = true);
 
  static std::string OpenRawFile(std::string filename);
 
  static bool SaveRawFile(std::string filename, std::string content);
 
  static TMacro * OpenMacro(std::string filename);
 
  static bool LoadJsonFile(json & cfg, std::string filename);
 
  using RawJsonInjections = std::vector<std::pair<std::vector<std::string>, std::string>>;
 
  static std::string InjectRawJson(json & j, const RawJsonInjections & injections);
 
  static void AddRawJsonInjection(json & j, const std::vector<std::string> & path, const std::string & rawJson,
                                  const std::string & injectionsKey = "__raw_json_injections");
 
  static bool CollectRawJsonInjections(const json & j, RawJsonInjections & injections,
                                       const std::string & injectionsKey = "__raw_json_injections");
 
  static std::string MergeRawJsonWithMetadata(const std::string & rawJson, const json & metadata);
 
  static TH1 * ProjectTHnSparse(THnSparse * hns, const std::vector<int> & axes, Option_t * option = "");
 
  static bool SetAxisRanges(THnSparse * sparse, std::vector<std::vector<int>> ranges = {}, bool withOverflow = false,
                            bool modifyTitle = false, bool reset = true);
 
  static bool SetAxisRanges(THnSparse * sparse, std::map<int, std::vector<int>> ranges, bool withOverflow = false,
                            bool modifyTitle = false, bool reset = true);
 
  static bool GetAxisRangeInBase(TAxis * a, int rebin, int rebin_start, int bin, int & min, int & max);
 
  static bool GetAxisRangeInBase(TAxis * a, int min, int max, TAxis * base, int & minBase, int & maxBase);
 
  static TAxis * CreateAxisFromLabels(const std::string & name, const std::string & title,
                                      const std::vector<std::string> & labels);
 
  static TAxis * CreateAxisFromLabelsSet(const std::string & name, const std::string & title,
                                         const std::set<std::string> & labels);
 
  static THnSparse * Convert(TH1 * h1, std::vector<std::string> names = {}, std::vector<std::string> titles = {});
 
  static THnSparse * Convert(TH2 * h2, std::vector<std::string> names = {}, std::vector<std::string> titles = {});
 
  static THnSparse * Convert(TH3 * h3, std::vector<std::string> names = {}, std::vector<std::string> titles = {});
 
  static THnSparse * ReshapeSparseAxes(THnSparse * hns, std::vector<int> order, std::vector<TAxis *> newAxes = {},
                                       std::vector<int> newPoint = {}, Option_t * option = "E");
 
  static void GetTrueHistogramMinMax(const TH1 * h, double & min_val, double & max_val,
                                     bool include_overflow_underflow = false);
 
  static TObjArray * AxesFromDirectory(const std::vector<std::string> paths, const std::string & findPath,
                                       const std::string & fileName, const std::vector<std::string> & axesNames);
 
  static std::vector<std::string> Tokenize(std::string_view input, const char delim);
 
  static std::vector<int> TokenizeInt(std::string_view input, const char delim);
 
  static std::string Join(const std::vector<std::string> & values, const char delim = ',');
 
  static std::string Join(const std::vector<int> & values, const char delim = ',');
 
  static std::vector<std::string> Find(std::string path, std::string filename = "");
 
  static std::vector<std::string> FindLocal(std::string path, std::string filename = "");
 
  static std::vector<std::string> FindEos(std::string path, std::string filename = "");
 
  static std::set<std::string> Unique(std::vector<std::string> & paths, int axis, std::string path, char token = '/');
 
  static std::vector<std::string> Truncate(std::vector<std::string> values, std::string value);
 
  static std::vector<int> ArrayToVector(Int_t * v1, int size);
 
  static void VectorToArray(std::vector<int> v1, Int_t * v2);
 
  static std::string GetCoordsString(const std::vector<int> & coords, int index = -1, int width = 0);
 
  static std::string GetCoordsString(const std::vector<size_t> & coords, int index = -1, int width = 0);
 
  static std::string GetCoordsString(const std::vector<Long64_t> & coords, int index = -1, int width = 0);
 
  static std::string GetCoordsString(const std::vector<std::string> & coords, int index = -1, int width = 0);
 
  static void PrintPointSafe(const std::vector<int> & coords, int index = -1);
 
  static std::vector<std::vector<int>> Permutations(const std::vector<int> & v);
 
  static std::string GetJsonString(json j);
 
  static int GetJsonInt(json j);
 
  static double GetJsonDouble(json j);
 
  static json GetSystemStats();
 
  static json GetTFileIOStats();
 
  static json GetNetDevStats();
 
  static bool GetJsonBool(json j);
 
  static std::vector<std::string> GetJsonStringArray(json j);
 
  static std::string FormatTime(long long seconds);
 
  static void ProgressBar(int current, int total, std::string prefix = "", std::string suffix = "", int barWidth = 50);
 
  static void ProgressBar(int current, int total, std::chrono::high_resolution_clock::time_point startTime,
                          std::string prefix = "", std::string suffix = "", int barWidth = 50);
 
  static TCanvas * CreateCanvas(const std::string & name, const std::string & title, int width = 800, int height = 600);
 
  static void SafeDeleteObjects(std::vector<TObject *> & objects);
 
  static void SafeDeleteTList(TList *& lst);
 
  static void SafeDeleteObject(TObject *& obj);
 
  static THnSparse * CreateSparseFromParquetTaxi(const std::string & filename, THnSparse * hns = nullptr,
                                                 Int_t nMaxRows = -1);
 
  ClassDef(NUtils, 0);
 
}; // namespace NUtils
} // namespace Ndmspc
#endif