HistogramUtils.h

Go to the documentation of this file.

#pragma once
 
// MaCh3 includes
#include "Samples/SampleStructs.h"
#include "Parameters/ParameterStructs.h"
 
_MaCh3_Safe_Include_Start_ //{
// ROOT include
#include "TGraphAsymmErrors.h"
#include "TObjString.h"
#include "TRandom3.h"
_MaCh3_Safe_Include_End_ //}
 
 
double OverflowIntegral(TH2Poly* poly);
 
double NoOverflowIntegral(TH2Poly* poly);
 
TH1D* PolyProjectionX(TObject* poly, std::string TempName, const std::vector<double>& xbins, const bool computeErrors = false);
TH1D* PolyProjectionY(TObject* poly, std::string TempName, const std::vector<double>& ybins, const bool computeErrors = false);
 
TH2D* ConvertTH2PolyToTH2D(TH2Poly *poly, TH2D *TH2Dhist);
TH2Poly* ConvertTH2DtoTH2Poly(TH2D *TH2Dhist);
 
TH2Poly* NormalisePoly(TH2Poly* Histogram);
 
void NormaliseTH2Poly(TH2Poly* Histogram);
 
TH2Poly* PolyScaleWidth(TH2Poly *Histogram, double scale);
 
double PolyIntegralWidth(TH2Poly *Histogram);
 
template<class HistType> HistType* RatioHists(HistType* NumHist, HistType* DenomHist);
 
TH2Poly* RatioPolys(TH2Poly* NumPoly, TH2Poly* DenomPoly);
 
TH2Poly* MakePolyHist(const std::string& name, const std::vector<double>& BinArray_x, const std::vector<double>& BinArray_y);
 
void CheckTH2PolyFileVersion(TFile *file);
 
void RemoveFitter(TH1D* hist, const std::string& name);
 
void MakeFluctuatedHistogramStandard(TH1D *FluctHist, TH1D* PolyHist, TRandom3* rand);
void MakeFluctuatedHistogramAlternative(TH1D *FluctHist, TH1D* PolyHist, TRandom3* rand);
 
void MakeFluctuatedHistogramAlternative(TH2D *FluctHist, TH2D* PolyHist, TRandom3* rand);
 
void MakeFluctuatedHistogramStandard(TH2Poly *FluctHist, TH2Poly* PolyHist, TRandom3* rand);
void MakeFluctuatedHistogramAlternative(TH2Poly *FluctHist, TH2Poly* PolyHist, TRandom3* rand);
 
int GetRandomPoly2(const TH2Poly* PolyHist, TRandom3* rand);
 
std::unique_ptr<TGraphAsymmErrors> MakeAsymGraph(TH1* sigmaArrayLeft, TH1* sigmaArrayCentr, TH1* sigmaArrayRight, const std::string& title);
 
void FastViolinFill(TH2D* violin, TH1D* hist_1d);
 
template <typename Derived, typename Base>
std::vector<Base*> CastVector(const std::vector<Derived*>& inputVec) {
  std::vector<Base*> outputVec;
  // Reserve space for efficiency
  outputVec.reserve(inputVec.size());
  for (auto* ptr : inputVec) {
    outputVec.push_back(static_cast<Base*>(ptr));
  }
  return outputVec;
}
 
inline std::string file_exists(std::string filename) {
  std::ifstream infile(filename.c_str());
  if (!infile.good()) {
    MACH3LOG_ERROR("*** ERROR ***");
    MACH3LOG_ERROR("File {} does not exist", filename);
    MACH3LOG_ERROR("Please try again");
    MACH3LOG_ERROR("*************");
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
  return filename;
}
 
double returnCherenkovThresholdMomentum(const int PDG);
 
double CalculateQ2(double PLep, double PUpd, double EnuTrue, double InitialQ2 = 0.0);
 
double CalculateEnu(double PLep, double cosTheta, double EB, bool neutrino);
 
namespace M3 {
template <typename ObjectType>
std::unique_ptr<ObjectType> Clone(const ObjectType* obj, const std::string& name = "") {
  std::string cloneName = name.empty() ? obj->GetName() : name;
 
  std::unique_ptr<ObjectType> Hist(static_cast<ObjectType*>(obj->Clone(cloneName.c_str())));
  // Disable ROOT memory management because it causes lot of headache especially as smart pointers are much smarter
  Hist->SetDirectory(nullptr);
 
  return Hist;
}
 
 
TFile* Open(const std::string& Name, const std::string& Type, const std::string& File, const int Line);
 
void ScaleHistogram(TH1* Sample_Hist, const double scale);
 
} //end M3