Analysis::HistoHelperRoot Class Reference

Helper class for histograming. More...

#include <HistoHelperRoot.h>

Collaboration diagram for Analysis::HistoHelperRoot:

Public Member Functions
	HistoHelperRoot (ITHistSvc *)
	Constructor with histoSvc only.
	~HistoHelperRoot ()
std::string	baseName (const std::string &fullHistoName)
void	bookHisto (const std::string &histoName, const std::string &histoTitle, unsigned int bins, double minx, double maxx)
void	bookHisto (const std::string &histoName, const std::string &histoTitle, unsigned int bins, double *edge)
void	bookHisto (const std::string &histoName, const std::string &histoTitle, unsigned int binsx, double minx, double maxx, unsigned int binsy, double miny, double maxy)
void	bookHisto (const std::string &histoName, const std::string &histoTitle, unsigned int binsx, double *edgex, unsigned int binsy, double *edgey)
void	bookHisto (const std::string &histoName, const std::string &histoTitle, unsigned int binsx, double minx, double maxx, unsigned int binsy, double miny, double maxy, unsigned int binsz, double minz, double maxz)
void	fillHisto (const std::string &histoName, double) const
void	fillHistoWithWeight (const std::string &histoName, double, double) const
void	fillHisto (const std::string &histoName, double, double) const
void	fillHisto (const std::string &histoName, double, double, double) const
void	setCheckOverflows (bool b)
void	print ()
TH1 *getHisto1D	ATLAS_NOT_THREAD_SAFE (const std::string &histoName)
	Histogram accessors (not thread-safe because exposed bare pointer)
TH2 *getHisto2D	ATLAS_NOT_THREAD_SAFE (const std::string &histoName)
TH3 *getHisto3D	ATLAS_NOT_THREAD_SAFE (const std::string &histoName)

Static Public Member Functions
static double	Interpol1d (double, TH1 *)
static double	Interpol2d (double, double, TH2 *)
static double	Interpol3d (double, double, double, TH3 *)
static void	smoothASH2D (TH2 *, int m1=3, int m2=3, bool debug=false)
static void	smoothASH3D (TH3 *, int m1=3, int m2=3, int m3=2, bool debug=false)

Private Attributes
ITHistSvc *	m_histoSvc
std::map< std::string, LockedHandle< TH1 > >	m_histoMap1D
std::map< std::string, LockedHandle< TH2 > >	m_histoMap2D
std::map< std::string, LockedHandle< TH3 > >	m_histoMap3D
std::map< std::string, HistoLimits >	m_histoLimitsMap1D
std::map< std::string, HistoLimits >	m_histoLimitsMap2D
std::map< std::string, HistoLimits >	m_histoLimitsMap3D
bool	m_checkOverflows

Detailed Description

Helper class for histograming.

The class is made thread-safe through the use of LockedHandle for histogram filling.

Definition at line 35 of file HistoHelperRoot.h.

Constructor & Destructor Documentation

HistoHelperRoot()

Analysis::HistoHelperRoot::HistoHelperRoot

(

ITHistSvc *

histoSvc

)

Constructor with histoSvc only.

Definition at line 28 of file HistoHelperRoot.cxx.

                                                    :
  m_histoSvc(histoSvc),
  m_checkOverflows(true)
  {}

~HistoHelperRoot()

Analysis::HistoHelperRoot::~HistoHelperRoot

(

)

Definition at line 34 of file HistoHelperRoot.cxx.

{}

Member Function Documentation

ATLAS_NOT_THREAD_SAFE() [1/3]

TH1 *getHisto1D Analysis::HistoHelperRoot::ATLAS_NOT_THREAD_SAFE

(

const std::string &

histoName

)

Histogram accessors (not thread-safe because exposed bare pointer)

ATLAS_NOT_THREAD_SAFE() [2/3]

TH2 *getHisto2D Analysis::HistoHelperRoot::ATLAS_NOT_THREAD_SAFE

(

const std::string &

histoName

)

ATLAS_NOT_THREAD_SAFE() [3/3]

TH3 *getHisto3D Analysis::HistoHelperRoot::ATLAS_NOT_THREAD_SAFE

(

const std::string &

histoName

)

baseName()

std::string Analysis::HistoHelperRoot::baseName

(

const std::string &

fullHistoName

)

Definition at line 36 of file HistoHelperRoot.cxx.

                                                                  {
    const std::string delim("/");
    std::vector<std::string> words;
    std::string::size_type sPos, sEnd, sLen;
    sPos = fullHistoName.find_first_not_of(delim);
    while ( sPos != std::string::npos ) {
    sEnd = fullHistoName.find_first_of(delim, sPos);
    if(sEnd==std::string::npos) sEnd = fullHistoName.length();
    sLen = sEnd - sPos;
    words.emplace_back(fullHistoName.substr(sPos,sLen));
    sPos = fullHistoName.find_first_not_of(delim, sEnd);
    }
    std::string base = "";
    if(words.size()>0) base = words[words.size()-1];
    return base;
}

bookHisto() [1/5]

void Analysis::HistoHelperRoot::bookHisto	(	const std::string &	histoName,
		const std::string &	histoTitle,
		unsigned int	bins,
		double *	edge )

Definition at line 63 of file HistoHelperRoot.cxx.

{
    auto h = std::make_unique<TH1F>(this->baseName(histoName).c_str(),histoTitle.c_str(),bins,edge);
    if (!m_histoSvc->regShared(histoName, std::move(h), m_histoMap1D[histoName]).isSuccess()) {
      std::cout <<"Cannot book histo " << histoName << " with Title " << histoTitle <<std::endl;
    }
    m_histoLimitsMap1D[histoName] = HistoLimits(bins, edge[0], edge[bins]);
}

bookHisto() [2/5]

void Analysis::HistoHelperRoot::bookHisto	(	const std::string &	histoName,
		const std::string &	histoTitle,
		unsigned int	bins,
		double	minx,
		double	maxx )

Definition at line 53 of file HistoHelperRoot.cxx.

{
    auto h = std::make_unique<TH1F>(this->baseName(histoName).c_str(),histoTitle.c_str(),bins,minx,maxx);
    //std::cout<<"HistoHelperRoot: booking 1D "<<histoName<<std::endl;
    if (!m_histoSvc->regShared(histoName, std::move(h), m_histoMap1D[histoName]).isSuccess()) {
      std::cout <<"Cannot book histo " << histoName << " with Title " << histoTitle <<std::endl;
    }
    m_histoLimitsMap1D[histoName] = HistoLimits(bins, minx, maxx);
}

bookHisto() [3/5]

void Analysis::HistoHelperRoot::bookHisto	(	const std::string &	histoName,
		const std::string &	histoTitle,
		unsigned int	binsx,
		double *	edgex,
		unsigned int	binsy,
		double *	edgey )

Definition at line 81 of file HistoHelperRoot.cxx.

{
    auto h = std::make_unique<TH2F>(this->baseName(histoName).c_str(),histoTitle.c_str(),binsx,edgex,binsy,edgey);
    if (!m_histoSvc->regShared(histoName, std::move(h), m_histoMap2D[histoName]).isSuccess()) {
      std::cout <<"Cannot book histo " << histoName << " with Title " << histoTitle <<std::endl;
    }
    m_histoLimitsMap2D[histoName] = HistoLimits(binsx, edgex[0], edgex[binsx], binsy, edgey[0], edgey[binsy]);
}

bookHisto() [4/5]

void Analysis::HistoHelperRoot::bookHisto	(	const std::string &	histoName,
		const std::string &	histoTitle,
		unsigned int	binsx,
		double	minx,
		double	maxx,
		unsigned int	binsy,
		double	miny,
		double	maxy )

Definition at line 72 of file HistoHelperRoot.cxx.

{
    auto h = std::make_unique<TH2F>(this->baseName(histoName).c_str(),histoTitle.c_str(),binsx,minx,maxx,binsy,miny,maxy);
    if (!m_histoSvc->regShared(histoName, std::move(h), m_histoMap2D[histoName]).isSuccess()) {
      std::cout <<"Cannot book histo " << histoName << " with Title " << histoTitle <<std::endl;
    }
    m_histoLimitsMap2D[histoName] = HistoLimits(binsx, minx, maxx, binsy, miny, maxy);
}

bookHisto() [5/5]

void Analysis::HistoHelperRoot::bookHisto	(	const std::string &	histoName,
		const std::string &	histoTitle,
		unsigned int	binsx,
		double	minx,
		double	maxx,
		unsigned int	binsy,
		double	miny,
		double	maxy,
		unsigned int	binsz,
		double	minz,
		double	maxz )

Definition at line 90 of file HistoHelperRoot.cxx.

{
    auto h = std::make_unique<TH3F>(this->baseName(histoName).c_str(),histoTitle.c_str(),binsx,minx,maxx,binsy,miny,maxy,binsz,minz,maxz);
    if (!m_histoSvc->regShared(histoName, std::move(h), m_histoMap3D[histoName]).isSuccess()) {
      std::cout <<"Cannot book histo " << histoName << " with Title " << histoTitle <<std::endl;
    }
    m_histoLimitsMap3D[histoName] = HistoLimits(binsx, minx, maxx, binsy, miny, maxy, binsz, minz, maxz);
}

fillHisto() [1/3]

void Analysis::HistoHelperRoot::fillHisto	(	const std::string &	histoName,
		double	value ) const

make sure that underflow/overflow is filled in 1st/last bin and not in 1st-1 and last+1 bin

Definition at line 101 of file HistoHelperRoot.cxx.

{
  if (m_checkOverflows) {
    const HistoLimits& l = (*(m_histoLimitsMap1D.find(histoName))).second;
    if ( value < l.xmin ) value = l.xmin+0.0001;
    else if ( value > l.xmax ) value = l.xmax-0.0001;
  }
  // Thread-safe because handle uses internal lock
  auto locked_handle ATLAS_THREAD_SAFE = const_cast<LockedHandle<TH1>&>(m_histoMap1D.at(histoName));
  locked_handle->Fill(value);
}

fillHisto() [2/3]

void Analysis::HistoHelperRoot::fillHisto	(	const std::string &	histoName,
		double	valuex,
		double	valuey ) const

make sure that underflow/overflow is filled in 1st/last bin and not in 1st-1 and last+1 bin

Definition at line 129 of file HistoHelperRoot.cxx.

{
  if (m_checkOverflows) {
    const HistoLimits& l = (*(m_histoLimitsMap2D.find(histoName))).second;
    if ( valuex < l.xmin ) valuex = l.xmin+0.0001;
    else if ( valuex > l.xmax ) valuex = l.xmax-0.0001;
    if ( valuey < l.ymin ) valuey = l.ymin+0.0001;
    else if ( valuey > l.ymax ) valuey = l.ymax-0.0001;
  }
  // Thread-safe because handle uses internal lock
  auto locked_handle ATLAS_THREAD_SAFE = const_cast<LockedHandle<TH2>&>(m_histoMap2D.at(histoName));
  locked_handle->Fill(valuex,valuey);
}

fillHisto() [3/3]

void Analysis::HistoHelperRoot::fillHisto	(	const std::string &	histoName,
		double	valuex,
		double	valuey,
		double	valuez ) const

make sure that underflow/overflow is filled in 1st/last bin and not in 1st-1 and last+1 bin

Definition at line 145 of file HistoHelperRoot.cxx.

{
  if (m_checkOverflows) {
    const HistoLimits& l = (*(m_histoLimitsMap3D.find(histoName))).second;
    if ( valuex < l.xmin ) valuex = l.xmin+0.0001;
    else if ( valuex > l.xmax ) valuex = l.xmax-0.0001;
    if ( valuey < l.ymin ) valuey = l.ymin+0.0001;
    else if ( valuey > l.ymax ) valuey = l.ymax-0.0001;
    if ( valuez < l.zmin ) valuez = l.zmin+0.0001;
    else if ( valuez > l.zmax ) valuez = l.zmax-0.0001;
  }
  // Thread-safe because handle uses internal lock
  auto locked_handle ATLAS_THREAD_SAFE = const_cast<LockedHandle<TH3>&>(m_histoMap3D.at(histoName));
  locked_handle->Fill(valuex,valuey,valuez);
}

fillHistoWithWeight()

void Analysis::HistoHelperRoot::fillHistoWithWeight	(	const std::string &	histoName,
		double	value,
		double	weight ) const

make sure that underflow/overflow is filled in 1st/last bin and not in 1st-1 and last+1 bin

Definition at line 115 of file HistoHelperRoot.cxx.

{
  if (m_checkOverflows) {
    const HistoLimits& l = (*(m_histoLimitsMap1D.find(histoName))).second;
    if ( value < l.xmin ) value = l.xmin+0.0001;
    else if ( value > l.xmax ) value = l.xmax-0.0001;
  }
  // Thread-safe because handle uses internal lock
  auto locked_handle ATLAS_THREAD_SAFE = const_cast<LockedHandle<TH1>&>(m_histoMap1D.at(histoName));
  locked_handle->Fill(value, weight);
}

Interpol1d()

double Analysis::HistoHelperRoot::Interpol1d ( double x, TH1 * h )

static

Definition at line 578 of file HistoHelperRoot.cxx.

{
  int bin((h->GetXaxis())->FindBin(x));
  double bincenter(h->GetBinCenter(bin));
  double nextbincenter(bincenter);
  double nextbincontent(0);
  if(x>bincenter && bin < h->GetNbinsX())
    {
      nextbincenter   = h->GetBinCenter(bin+1);
      nextbincontent  = h->GetBinContent(bin+1);
    }
  else if(x<bincenter && bin > 1)
    {
      nextbincenter   = h->GetBinCenter(bin-1);
      nextbincontent  = h->GetBinContent(bin-1);
    }
  double tmp(h->GetBinContent(bin));
  if(nextbincenter != bincenter) tmp = ( nextbincontent*(x-bincenter) + tmp*(nextbincenter-x) ) / (nextbincenter - bincenter);
  return tmp;
}

Interpol2d()

double Analysis::HistoHelperRoot::Interpol2d ( double x, double y, TH2 * h )

static

Definition at line 602 of file HistoHelperRoot.cxx.

{
  int nx  = h->GetNbinsX(), ny = h->GetNbinsY();
  int ibx = h->GetXaxis()->FindBin(x), iby = h->GetYaxis()->FindBin(y);
  int ibx2,iby2;
  double z00,z11,z01,z10,xc,yc,xc2,yc2,u,t,r;
  if (ibx > nx) ibx = nx;
  if (iby > ny) iby = ny;
  xc  = h->GetXaxis()->GetBinCenter(ibx);
  yc  = h->GetYaxis()->GetBinCenter(iby);
  z11 = h->GetBinContent(ibx,iby);
  if ( (ibx > 1  || (ibx == 1  && x > xc) ) &&
       (ibx < nx || (ibx == nx && x < xc) ) ) {
    if (x > xc) {ibx2 = ibx + 1;} else {ibx2 = ibx - 1;}
    xc2 = h->GetXaxis()->GetBinCenter(ibx2);
    if ( (iby > 1  || (iby == 1  && y > yc) ) &&
         (iby < ny || (iby == ny && y < yc) ) ) {
      if (y > yc) {iby2 = iby + 1;} else {iby2 = iby - 1;}
      yc2 = h->GetYaxis()->GetBinCenter(iby2);
      z00 = h->GetBinContent(ibx2,iby2);
      z10 = h->GetBinContent(ibx,iby2);
      z01 = h->GetBinContent(ibx2,iby);
      t   = (x - xc2)/(xc-xc2);
      u   = (y - yc2)/(yc-yc2);
      r   = z11*t*u+z00*(1.-t)*(1.-u)+z01*(1.-t)*u+z10*t*(1.-u);
    } else {
      z01 = h->GetBinContent(ibx2,iby);
      t   = (x - xc2)/(xc-xc2);
      r   = z11*t + z01*(1.-t);
    }
  } else if ((iby > 1  || (iby == 1  && y > yc) ) &&
       (iby < ny || (iby == ny && y < yc) ) ) {
    if (y > yc) {iby2 = iby + 1;} else {iby2 = iby - 1;}
    z10 = h->GetBinContent(ibx,iby2);
    yc2 = h->GetYaxis()->GetBinCenter(iby2);
    u   = (y - yc2)/(yc-yc2);
    r   = z11*u + z10*(1.-u);
  } else {
    r = z11;
  }
  return r;
}

Interpol3d()

double Analysis::HistoHelperRoot::Interpol3d ( double x, double y, double z, TH3 * h )

static

Definition at line 648 of file HistoHelperRoot.cxx.

{
  int nx  = h->GetNbinsX(), ny = h->GetNbinsY(), nz = h->GetNbinsZ();
  int ibx = h->GetXaxis()->FindBin(x), iby = h->GetYaxis()->FindBin(y), ibz = h->GetZaxis()->FindBin(z);
  int ibx2,iby2,ibz2;
  double z000,z010,z110,z100,z001,z011,z111,z101,xc,yc,zc,xc2,yc2,zc2,u,t,v,r;
  if (ibx > nx) ibx = nx;
  if (iby > ny) iby = ny;
  if (ibz > nz) ibz = nz;
  xc  = h->GetXaxis()->GetBinCenter(ibx);
  yc  = h->GetYaxis()->GetBinCenter(iby);
  zc  = h->GetZaxis()->GetBinCenter(ibz);
  //
  z111 = h->GetBinContent(ibx,iby,ibz);
  if ( (ibx > 1  || (ibx == 1  && x > xc) ) &&
       (ibx < nx || (ibx == nx && x < xc) ) ) {
    if (x > xc) {ibx2 = ibx + 1;} else {ibx2 = ibx - 1;}
    xc2 = h->GetXaxis()->GetBinCenter(ibx2);
    if ( (iby > 1  || (iby == 1  && y > yc) ) &&
         (iby < ny || (iby == ny && y < yc) ) ) {
      if (y > yc) {iby2 = iby + 1;} else {iby2 = iby - 1;}
      yc2 = h->GetYaxis()->GetBinCenter(iby2);
      if ( (ibz > 1  || (ibz == 1  && z > zc) ) &&
     (ibz < nz || (ibz == nz && z < zc) ) ) {
  if (z > zc) {ibz2 = ibz + 1;} else {ibz2 = ibz - 1;}
  zc2 = h->GetZaxis()->GetBinCenter(ibz2);
  //
  z000 = h->GetBinContent(ibx2,iby2,ibz2);
  z100 = h->GetBinContent(ibx,iby2,ibz2);
  z010 = h->GetBinContent(ibx2,iby,ibz2);
  z110 = h->GetBinContent(ibx,iby,ibz2);
  z001 = h->GetBinContent(ibx2,iby2,ibz);
  z101 = h->GetBinContent(ibx,iby2,ibz);
  z011 = h->GetBinContent(ibx2,iby,ibz);
  t   = (x - xc2)/(xc-xc2);
  u   = (y - yc2)/(yc-yc2);
  v   = (z - zc2)/(zc-zc2);
  r   = z111*t*u*v           + z001*(1.-t)*(1.-u)*v
      + z011*(1.-t)*u*v      + z101*t*(1.-u)*v
      + z110*t*u*(1.-v)      + z000*(1.-t)*(1.-u)*(1.-v)
      + z010*(1.-t)*u*(1.-v) + z100*t*(1.-u)*(1.-v);
      } else {
  z011 = h->GetBinContent(ibx2,iby,ibz);
  z001 = h->GetBinContent(ibx2,iby2,ibz);
  z101 = h->GetBinContent(ibx,iby2,ibz);
  t   = (x - xc2)/(xc-xc2);
  u   = (y - yc2)/(yc-yc2);
  r   = z111*t*u + z011*(1.-t)*u + z101*t*(1.-u) + z001*(1.-t)*(1.-u) ;
      }
    } else if ((ibz > 1  || (ibz == 1  && z > zc) ) &&
         (ibz < nz || (ibz == nz && z < zc) ) ) {
      if (z > zc) {ibz2 = ibz + 1;} else {ibz2 = ibz - 1;}
      z110 = h->GetBinContent(ibx,iby,ibz2);
      z010 = h->GetBinContent(ibx2,iby,ibz2);
      z011 = h->GetBinContent(ibx2,iby,ibz);
      zc2 = h->GetYaxis()->GetBinCenter(ibz2);
      t   = (x - xc2)/(xc-xc2);
      v   = (z - zc2)/(zc-zc2);
      r   = z111*t*v + z011*(1.-t)*v + z110*t*(1.-v) +z010*(1.-t)*(1.-v);
    } else {
      z011 = h->GetBinContent(ibx2,iby,ibz);
      t   = (x - xc2)/(xc-xc2);
      r   = z111*t + z011*(1.-t);
    }
  } else {
    if ( (iby > 1  || (iby == 1  && y > yc) ) &&
         (iby < ny || (iby == ny && y < yc) ) ) {
      if (y > yc) {iby2 = iby + 1;} else {iby2 = iby - 1;}
      yc2 = h->GetYaxis()->GetBinCenter(iby2);
      if ( (ibz > 1  || (ibz == 1  && z > zc) ) &&
     (ibz < nz || (ibz == nz && z < zc) ) ) {
  if (z > zc) {ibz2 = ibz + 1;} else {ibz2 = ibz - 1;}
  zc2 = h->GetZaxis()->GetBinCenter(ibz2);
  //
  z100 = h->GetBinContent(ibx,iby2,ibz2);
  z110 = h->GetBinContent(ibx,iby,ibz2);
  z101 = h->GetBinContent(ibx,iby2,ibz);
  u   = (y - yc2)/(yc-yc2);
  v   = (z - zc2)/(zc-zc2);
  r   = z111*u*v      + z101*(1.-u)*v
      + z110*u*(1.-v) + z100*(1.-u)*(1.-v);
      } else {
  z101 = h->GetBinContent(ibx,iby2,ibz);
  u   = (y - yc2)/(yc-yc2);
  r   = z111*u + z101*(1.-u);
      }
    } else if ((ibz > 1  || (ibz == 1  && z > zc) ) &&
         (ibz < nz || (ibz == nz && z < zc) ) ) {
      if (z > zc) {ibz2 = ibz + 1;} else {ibz2 = ibz - 1;}
      z110 = h->GetBinContent(ibx,iby,ibz2);
      zc2 = h->GetYaxis()->GetBinCenter(ibz2);
      v   = (z - zc2)/(zc-zc2);
      r   = z111*v + z110*(1.-v);
    } else {
      r = z111;
    }
  }
  return r;
}

print()

void Analysis::HistoHelperRoot::print

(

)

Definition at line 176 of file HistoHelperRoot.cxx.

                            {
  for (const auto& [name, h] : m_histoMap1D) {
    std::cout <<"The name of the 1D Histo " << name << std::endl;
  }
  for (const auto& [name, h] : m_histoMap2D) {
    std::cout <<"The name of the 2D Histo " << name << std::endl;
  }
  for (const auto& [name, h] : m_histoMap3D) {
    std::cout <<"The name of the 3D Histo " << name << std::endl;
  }
}

setCheckOverflows()

void Analysis::HistoHelperRoot::setCheckOverflows ( bool b )

inline

Definition at line 71 of file HistoHelperRoot.h.

{m_checkOverflows = b;};

smoothASH2D()

void Analysis::HistoHelperRoot::smoothASH2D ( TH2 * input2D, int m1 = 3, int m2 = 3, bool debug = false )

static

Definition at line 188 of file HistoHelperRoot.cxx.

                                                                          {
  if(debug) {
    std::cout << "Smoothing a two dimensional histogram "<< input2D->GetName()
              << " " << m1 << " " << m2 << std::endl;
    std::cout << "First (1-3, 1-3) 3x3 bins before smoothing: " << std::endl;
    for(int i=1;i<4;i++) {
      for(int j=1;j<4;j++) {
        std::cout<<i<<" "<<j<<" : "<<input2D->GetBinContent(i,j)<< " / " ;
      }
    }
    std::cout << std::endl;
    int ioffset = input2D->GetNbinsX() / 2 ;
    int joffset = input2D->GetNbinsY() / 2 ;
    std::cout << "Middle (" << ioffset+1 << "-" << ioffset+4 << ", ("
              << joffset+1 << "-" << joffset+4 << ") 3x3 bins before smoothing: " << std::endl;
    for(int i=1;i<4;i++) {
      for(int j=1;j<4;j++) {
        std::cout<<i<<" "<<j<<" : "<<input2D->GetBinContent(i+ioffset,j+joffset)<< " / " ;
      }
    }
    std::cout << std::endl;
  }
  //
  const int lsup = 20;
  if (m1 > lsup || m2 > lsup) {
    std::cout <<"HistoHelperRoot::smoothASH2D: m1 or m2 too big !"<<std::endl;
    return;
  } else {
    int nx = input2D->GetNbinsX()+1;
    int ny = input2D->GetNbinsY()+1;
    float **h, **res;
    h   = new float*[nx-1];
    res = new float*[nx-1];
    for (int i = 0;i < nx-1;i++) {
      h[i]   = new float[ny-1];
      res[i] = new float[ny-1];
    }
    for (int iy = 1;iy<ny;iy++) {
      for (int ix = 1;ix<nx;ix++) {
        h[ix-1][iy-1] = (float) input2D->GetBinContent(ix,iy);
      }
    }
    //
    int i,j,k,l;
    float wk1[41],wk2[41];
    //avoid large stack use
    std::vector<std::vector<float>> wgt(100, std::vector<float>(100));
    std::vector<std::vector<float>> wk(41, std::vector<float>(41));
    double wks = 0.;
    float ai,am1 = float(m1), am2 = float(m2);
    const float am12 = am1*am1, am22 = am2*am2;
    const float inv_am1_am2 = 1. / (am1 * am2);
    const float inv_am12 = 1. / am12;
    const float inv_am22 = 1. / am22;
    // Initialisation
    for (k = 0;k<nx-1;k++) {
      for (l = 0;l<ny-1;l++) {
        res[k][l] = 0.; wgt[k][l] = 0.;
      }
    }
    // Weights
    for (i = lsup+1-m1;i<lsup+m1;i++) {
      ai = float(i-lsup)*float(i-lsup);
      wk1[i] = 15./16.*(1.-ai*inv_am12)*(1.-ai*inv_am12);
      wks = wks + wk1[i];
    }
    if (wks == 0)[[unlikely]]{
      std::cout <<"HistoHelperRoot::smoothASH2D: wks is zero! "<<std::endl;
      for (int i = 0; i < nx-1; ++i) {
        delete[] h[i];
        delete[] res[i];
      }
 
      delete[] h;
      delete[] res;
      return;
    }
    const double fac1 = am1 / wks;
    for (i = lsup+1-m1;i<lsup+m1;i++) {
      wk1[i] =  wk1[i]*fac1;
    }
    wks = 0.;
    for (i = lsup+1-m2;i<lsup+m2;i++) {
      ai = float(i-lsup)*float(i-lsup);
      wk2[i] = 15./16.*(1.-ai*inv_am22)*(1.-ai*inv_am22);
      wks = wks + wk2[i];
    }
    if (wks == 0)[[unlikely]]{
      std::cout <<"HistoHelperRoot::smoothASH2D: wks is zero! "<<std::endl;
      for (int i = 0; i < nx-1; ++i) {
        delete[] h[i];
        delete[] res[i];
      }
      delete[] h;
      delete[] res;
 
      return;
    }
    const double fac2 = am2 / wks;
    for (i = lsup+1-m2;i<lsup+m2;i++) {
      wk2[i] =  wk2[i]*fac2;
    }
    for (i = lsup+1-m1;i<lsup+m1;i++) {
      for (j = lsup+1-m2;j<lsup+m2;j++) {
        wk[i][j] = wk1[i]*wk2[j];
      }
    }
    //
    for (k = 0;k<nx-1;k++) {
      for (l = 0;l<ny-1;l++) {
        for (i = std::max(0,k-m1+1);i<std::min(nx-1,k+m1);i++) {
          for (j = std::max(0,l-m2+1);j<std::min(ny-1,l+m2);j++) {
            res[i][j] = res[i][j] + wk[lsup+i-k][lsup+j-l]*h[k][l];
            wgt[i][j] = wgt[i][j] + wk[lsup+i-k][lsup+j-l];
          }
        }
      }
    }
    for (k = 0;k<nx-1;k++) {
      for (l = 0;l<ny-1;l++) {
        res[k][l] = res[k][l]*inv_am1_am2;
        if (wgt[k][l] != 0.) {res[k][l] = res[k][l]/wgt[k][l];}
      }
    }
    // replace the histo content with the result of smoothing:
    input2D->Reset();
    for (int iy = 1;iy<ny;iy++) {
      for (int ix = 1;ix<nx;ix++) {
        input2D->SetBinContent(ix,iy,res[ix-1][iy-1]);
      }
    }
    for (i = 0; i < nx-1; i++){
      delete[] h[i];
      delete[] res[i];
    }
    delete[] h;
    delete[] res;
  }
  if(debug) {
    std::cout << "First (1-3, 1-3) 3x3 bins after smoothing: " << std::endl;
    for(int i=1;i<4;i++) {
      for(int j=1;j<4;j++) {
        std::cout<<i<<" "<<j<<" : "<<input2D->GetBinContent(i,j)<< " / " ;
      }
    }
    std::cout << std::endl;
    int ioffset = input2D->GetNbinsX() / 2 ;
    int joffset = input2D->GetNbinsY() / 2 ;
    std::cout << "Middle (" << ioffset+1 << "-" << ioffset+4 << ", ("
              << joffset+1 << "-" << joffset+4 << ") 3x3 bins after smoothing: " << std::endl;
    for(int i=1;i<4;i++) {
      for(int j=1;j<4;j++) {
        std::cout<<i<<" "<<j<<" : "<<input2D->GetBinContent(i+ioffset,j+joffset)<< " / " ;
      }
    }
    std::cout << std::endl;
  }
}

smoothASH3D()

void Analysis::HistoHelperRoot::smoothASH3D ( TH3 * input3D, int m1 = 3, int m2 = 3, int m3 = 2, bool debug = false )

static

Definition at line 347 of file HistoHelperRoot.cxx.

                                                                                  {
  if(debug) {
    std::cout << "Smoothing a three dimensional histogram "<<  input3D->GetName()
              << " " << m1 << " " << m2 << " " << m3 << std::endl;
    std::cout << "First 2x2x2 bins before smoothing: " << std::endl;
    for(int i=1;i<3;i++) {
      for(int j=1;j<3;j++) {
        for(int k=1;k<3;k++) {
          std::cout<<i<<" "<<j<<" "<<k<<" : "<<input3D->GetBinContent(i,j,k)<< " / " ;
    }
      }
    }
    std::cout << std::endl;
    int ioffset = input3D->GetNbinsX() / 2 ;
    int joffset = input3D->GetNbinsY() / 2 ;
    int koffset = input3D->GetNbinsZ() / 2 ;
    std::cout << "Middle (" << ioffset+1 << "-" << ioffset+3 << ", "
              << joffset+1 << "-" << joffset+3 << ", "
              << koffset+1 << "-" << koffset+3 << ") 2x2 bins before smoothing: " << std::endl;
    for(int i=1;i<3;i++) {
      for(int j=1;j<3;j++) {
        for(int k=1;k<3;k++) {
          std::cout<<i<<" "<<j<<" "<<k<<" : "<<input3D->GetBinContent(i+ioffset,j+joffset,k+koffset)<< " / " ;
    }
      }
    }
    std::cout << std::endl;
  }
  //
  const int lsup = 20;
  if (m1 > lsup || m2 > lsup || m3 > lsup) {
    std::cout <<"HistoHelperRoot::smoothASH3D: m1, m2 or m3 too big !"<<std::endl;
    return;
  } else {
    int nx = input3D->GetNbinsX()+1;
    int ny = input3D->GetNbinsY()+1;
    int nz = input3D->GetNbinsZ()+1;
    float ***h, ***res;
    h   = new float**[nx-1];
    res = new float**[nx-1];
    for (int i = 0;i < nx-1; i++) {
      h[i]   = new float*[ny-1];
      res[i] = new float*[ny-1];
      for (int j = 0; j < ny-1; j++) {
        h[i][j]   = new float[nz-1];
        res[i][j] = new float[nz-1];
      }
    }
    for (int iz = 1;iz<nz;iz++) {
      for (int iy = 1;iy<ny;iy++) {
        for (int ix = 1;ix<nx;ix++) {
          h[ix-1][iy-1][iz-1] = (float) input3D->GetBinContent(ix,iy,iz);
        }
      }
    }
    //
    int i,j,k,l,m,n;
    float wk1[41],wk2[41],wk3[41];
    //float wgt[100][100][100]; // Trop gros pour certaines machines !!??
    //avoid large stack use
    auto wk = std::vector(41,std::vector(41,std::vector<float>(41)));
    double wks = 0.;
    float ai,am1 = float(m1), am2 = float(m2), am3 = float(m3);
    const float am12 = am1*am1, am22 = am2*am2, am32 = am3*am3;
    const float inv_am1_am2 = 1. / (am1*am2);
    const float inv_am12 = 1. / am12;
    const float inv_am22 = 1. / am22;
    const float inv_am32 = 1. / am32;
    
    // Initialisation
    for (k = 0;k<nx-1;k++) {
      for (l = 0;l<ny-1;l++) {
        for (m = 0;m<nz-1;m++) {
          res[k][l][m] = 0.; 
      //wgt[k][l][m] = 0.;
        }
      }
    }
    //
    // Bidouille car selon la machine un tableau wgt[100][100][100] peut poser probleme !
    //
    float ***wgt;
    int dimension = 100;  int x, y, z = 0;
    wgt = new float**[dimension];
    if (!wgt) {
      std::cout <<"HistoHelperRoot::smoothASH3D: problem to allocate memory, exiting"<<std::endl;
      std::abort();
    }
    for(x = 0; x < dimension; x++) {
      wgt[x] = new float*[dimension];
      if (!wgt) {
        std::cout <<"HistoHelperRoot::smoothASH3D: problem to allocate memory, exiting"<<std::endl;
        std::abort();
      }
      for(y = 0; y < dimension; y++) {
    wgt[x][y] = new float[dimension];
    if (!wgt) {
          std::cout <<"HistoHelperRoot::smoothASH3D: problem to allocate memory, exiting"<<std::endl;
          std::abort();
    }
    for(z = 0; z < dimension; z++)
      wgt[x][y][z] = 0;
      }
    }
    // Weights
    for (i = lsup+1-m1;i<lsup+m1;i++) {
      ai = float(i-lsup)*float(i-lsup);
      wk1[i] = 15./16.*(1.-ai*inv_am12)*(1.-ai*inv_am12);
      wks = wks + wk1[i];
    }
    const double fac1 = am1 / wks;
    for (i = lsup+1-m1;i<lsup+m1;i++) {
      wk1[i] =  wk1[i]*fac1;
    }
    wks = 0.;
    for (i = lsup+1-m2;i<lsup+m2;i++) {
      ai = float(i-lsup)*float(i-lsup);
      wk2[i] = 15./16.*(1.-ai*inv_am22)*(1.-ai*inv_am22);
      wks = wks + wk2[i];
    }
    if (wks == 0){
      std::cout <<"HistoHelperRoot::smoothASH3D: wks is zero! "<<std::endl;
      return;
    }
    const double fac2 = am2 / wks;
    for (i = lsup+1-m2;i<lsup+m2;i++) {
      wk2[i] =  wk2[i]*fac2;
    }
    wks = 0.;
    for (i = lsup+1-m3;i<lsup+m3;i++) {
      ai = float(i-lsup)*float(i-lsup);
      wk3[i] = 15./16.*(1.-ai*inv_am32)*(1.-ai*inv_am32);
      wks = wks + wk3[i];
    }
    if (wks == 0){
      std::cout <<"HistoHelperRoot::smoothASH3D: wks is zero! "<<std::endl;
      return;
    }
    const double fac3 = am3 / wks;
    for (i = lsup+1-m3;i<lsup+m3;i++) {
      wk3[i] =  wk3[i]*fac3;
    }
 
    for (i = lsup+1-m1;i<lsup+m1;i++) {
      for (j = lsup+1-m2;j<lsup+m2;j++) {
        for (k = lsup+1-m3;k<lsup+m3;k++) {
          wk[i][j][k] = wk1[i]*wk2[j]*wk3[k];
        }
      }
    }
    //
    for (k = 0;k<nx-1;k++) {
      for (l = 0;l<ny-1;l++) {
        for (m = 0;m<nz-1;m++) {
          for (i = std::max(0,k-m1+1);i<std::min(nx-1,k+m1);i++) {
            for (j = std::max(0,l-m2+1);j<std::min(ny-1,l+m2);j++) {
              for (n = std::max(0,m-m3+1);n<std::min(nz-1,m+m3);n++) {
                res[i][j][n] = res[i][j][n] + wk[lsup+i-k][lsup+j-l][lsup+n-m]*h[k][l][m];
                wgt[i][j][n] = wgt[i][j][n] + wk[lsup+i-k][lsup+j-l][lsup+n-m];
              }
            }
          }
        }
      }
    }
    for (k = 0;k<nx-1;k++) {
      for (l = 0;l<ny-1;l++) {
        for (m = 0;m<nz-1;m++) {
          res[k][l][m] = res[k][l][m]*inv_am1_am2;
          if (wgt[k][l][m] != 0.) {res[k][l][m] = res[k][l][m]/wgt[k][l][m];}
        }
      }
    }
    // replace the content of histo with results of smoothing:
    input3D->Reset();
    for (int iz = 1;iz<nz;iz++) {
      for (int iy = 1;iy<ny;iy++) {
        for (int ix = 1;ix<nx;ix++) {
          input3D->SetBinContent(ix,iy,iz,res[ix-1][iy-1][iz-1]);
        }
      }
    }
    for (i = 0; i < nx-1; i++){
      for (j = 0; j < ny-1; j++) {
        delete[] h[i][j];
        delete[] res[i][j];
      }
      delete[] h[i];
      delete[] res[i];
    }
    delete[] h;
    delete[] res;
    //
    for (i = 0; i < dimension; i++){
      for (j = 0; j < dimension; j++)
    delete[] wgt[i][j];
      delete[] wgt[i];
    }
    delete[] wgt;
  }
  if(debug) {
    std::cout << "First 2x2x2 bins after smoothing: " << std::endl;
    for(int i=1;i<3;i++) {
      for(int j=1;j<3;j++) {
        for(int k=1;k<3;k++) {
          std::cout<<i<<" "<<j<<" "<<k<<" : "<<input3D->GetBinContent(i,j,k)<< " / " ;
    }
      }
    }
    std::cout << std::endl;
    int ioffset = input3D->GetNbinsX() / 2 ;
    int joffset = input3D->GetNbinsY() / 2 ;
    int koffset = input3D->GetNbinsZ() / 2 ;
    std::cout << "Middle (" << ioffset+1 << "-" << ioffset+3 << ", "
              << joffset+1 << "-" << joffset+3 << ", "
              << koffset+1 << "-" << koffset+3 << ") 2x2 bins after smoothing: " << std::endl;
    for(int i=1;i<3;i++) {
      for(int j=1;j<3;j++) {
        for(int k=1;k<3;k++) {
          std::cout<<i<<" "<<j<<" "<<k<<" : "<<input3D->GetBinContent(i+ioffset,j+joffset,k+koffset)<< " / " ;
    }
      }
    }
    std::cout << std::endl;
  }
}

Member Data Documentation

m_checkOverflows

bool Analysis::HistoHelperRoot::m_checkOverflows

private

Definition at line 83 of file HistoHelperRoot.h.

m_histoLimitsMap1D

std::map<std::string, HistoLimits> Analysis::HistoHelperRoot::m_histoLimitsMap1D

private

Definition at line 80 of file HistoHelperRoot.h.

m_histoLimitsMap2D

std::map<std::string, HistoLimits> Analysis::HistoHelperRoot::m_histoLimitsMap2D

private

Definition at line 81 of file HistoHelperRoot.h.

m_histoLimitsMap3D

std::map<std::string, HistoLimits> Analysis::HistoHelperRoot::m_histoLimitsMap3D

private

Definition at line 82 of file HistoHelperRoot.h.

m_histoMap1D

std::map<std::string, LockedHandle<TH1> > Analysis::HistoHelperRoot::m_histoMap1D

private

Definition at line 77 of file HistoHelperRoot.h.

m_histoMap2D

std::map<std::string, LockedHandle<TH2> > Analysis::HistoHelperRoot::m_histoMap2D

private

Definition at line 78 of file HistoHelperRoot.h.

m_histoMap3D

std::map<std::string, LockedHandle<TH3> > Analysis::HistoHelperRoot::m_histoMap3D

private

Definition at line 79 of file HistoHelperRoot.h.

m_histoSvc

ITHistSvc* Analysis::HistoHelperRoot::m_histoSvc

private

Definition at line 76 of file HistoHelperRoot.h.

---

The documentation for this class was generated from the following files:

• HistoHelperRoot.h
• HistoHelperRoot.cxx