Monitored::HistogramFactory Class Reference

Bridge between ROOT framework and monitoring code. More...

#include <HistogramFactory.h>

Collaboration diagram for Monitored::HistogramFactory:

Public Member Functions
	HistogramFactory (const ServiceHandle< ITHistSvc > &histSvc, const std::string &groupName)
	Default constructor.
virtual	~HistogramFactory ()
	Virtual destructor.
virtual TNamed *	create (const HistogramDef &def)
	Book and register ROOT object for given definition.
std::string	getFullName (const HistogramDef &def) const
	Invent path name.
virtual void	remove (const HistogramDef &def)
	Removes histogram (used to get rid of old LB tagged histograms)

Static Public Member Functions
static std::mutex &	globalROOTMutex ()

Private Member Functions
template<class H, class HBASE, typename... Types>
HBASE *	create (const HistogramDef &def, Types &&... hargs)
	Create and register histogram.
template<class H>
TH1 *	create1D (const HistogramDef &def)
	Helper for generic 'create' method for 1D histograms.
template<class H>
TH1 *	create1DProfile (const HistogramDef &def)
	Helper for generic 'create' method for 1DProfile histograms.
template<class H>
TH2 *	create2D (const HistogramDef &def)
	Helper for generic 'create' method for 2D histograms.
template<class H>
TH2 *	create2DProfile (const HistogramDef &def)
	Helper for generic 'create' method for 2DProfile histograms.
TEfficiency *	createEfficiency (const HistogramDef &def)
	Create and register efficiency graph.
TTree *	createTree (const HistogramDef &def)
	Create and register tree.

Static Private Member Functions
static void	setOpts (TH1 *hist, const HistogramDef &def)
	Setup various histogram options.
static void	setLabels (TH1 *hist, const HistogramDef &def)
	Set labels for all axes.
static void	setLabels (TAxis *axis, const std::vector< std::string > &labels)
	Setup labels for histogram axes.

Private Attributes
ServiceHandle< ITHistSvc >	m_histSvc
std::string	m_streamName
	defines the stream for THistSvc
std::string	m_groupName
	defines location of group of histograms
bool	m_deleteOnRemove {true}
	delete histogram during remove
std::mutex	m_createLock

Static Private Attributes
static std::mutex	s_histDirMutex

Detailed Description

Bridge between ROOT framework and monitoring code.

Main purpose of this class is to properly register and retrieve histograms for specific definitions.

Definition at line 26 of file HistogramFactory.h.

Constructor & Destructor Documentation

HistogramFactory()

HistogramFactory::HistogramFactory	(	const ServiceHandle< ITHistSvc > &	histSvc,
		const std::string &	groupName )

Default constructor.

Parameters

histSvc	ROOT framework histogramming service
groupName	Name of the group to which produced histograms will belong

Definition at line 19 of file HistogramFactory.cxx.

: m_histSvc(histSvc)
{
  // The Gaudi/offline THistSvc does not delete objects on de-registration,
  // but the online TrigMonTHistSvc does. We detect the latter case by checking
  // the existence of one of its properties.
  SmartIF<IProperty> hs{histSvc.get()};
  if (hs && hs->hasProperty("IncludeName")) {
    m_deleteOnRemove = false;
  }
 
  size_t whereToStart = 0;
  // do we have a leading slash? This distinguishes temporary streams in THistSvc
  if (! histoPath.empty() && histoPath[0] == '/') {
    whereToStart = 1;
  }
  size_t split = histoPath.find('/', whereToStart);
  m_streamName = (whereToStart == 1 ? "/" : "") + histoPath.substr(0,split);
  m_groupName = split!=std::string::npos ? histoPath.substr(split+1) : "";
  // Infrequently, loading a ROOT class in a MT context can fail.
  // So try to load the classes we'll need early.
  TClass::GetClass("TH1F");
  TClass::GetClass("TH1D");
  TClass::GetClass("TH1C");
  TClass::GetClass("TH1S");
  TClass::GetClass("TH1I");
  TClass::GetClass("TH2F");
  TClass::GetClass("TH2D");
  TClass::GetClass("TH2C");
  TClass::GetClass("TH2S");
  TClass::GetClass("TH2I");
  TClass::GetClass("TProfile");
  TClass::GetClass("TProfile2D");
  TClass::GetClass("TEfficiency");
  TClass::GetClass("TTree");
}

~HistogramFactory()

virtual Monitored::HistogramFactory::~HistogramFactory ( )

inlinevirtual

Virtual destructor.

Definition at line 38 of file HistogramFactory.h.

{}

Member Function Documentation

create() [1/2]

TNamed * HistogramFactory::create ( const HistogramDef & def )

virtual

Book and register ROOT object for given definition.

Based on the histogram type, method will return proper kind of the ROOT object

Parameters

def	Histogram definition

Returns

ROOT object handler

Definition at line 58 of file HistogramFactory.cxx.

                                                        {
  std::scoped_lock lock(m_createLock);
  TNamed* rootObj(0);
 
  if (def.type == "TH1F") {
    rootObj = create1D<TH1F>(def);
  } else if (def.type == "TH1D") {
    rootObj = create1D<TH1D>(def);
  } else if (def.type == "TH1C") {
    rootObj = create1D<TH1C>(def);
  } else if (def.type == "TH1S") {
    rootObj = create1D<TH1S>(def);
  } else if (def.type == "TH1I") {
    rootObj = create1D<TH1I>(def);
  } else if (def.type == "TH2F") {
    rootObj = create2D<TH2F>(def);
  } else if (def.type == "TH2D") {
    rootObj = create2D<TH2D>(def);
  } else if (def.type == "TH2C") {
    rootObj = create2D<TH2C>(def);
  } else if (def.type == "TH2S") {
    rootObj = create2D<TH2S>(def);
  } else if (def.type == "TH2I") {
    rootObj = create2D<TH2I>(def);
  } else if (def.type == "TProfile") {
    rootObj = create1DProfile<TProfile>(def);
  } else if (def.type == "TProfile2D") {
    rootObj = create2DProfile<TProfile2D>(def);
  } else if (def.type == "TEfficiency") {
    rootObj = createEfficiency(def);
  } else if (def.type == "TTree") {
    rootObj = createTree(def);
  }
  
  if (rootObj == 0) {
    throw HistogramException("Can not create yet histogram of type: >" + def.type + "<\n" +
                             "Try one of: TH1[F,D,C,S,I], TH2[F,D,C,S,I], TProfile, TProfile2D, " +
                             "TEfficiency, TTree.");
  }
 
  return rootObj;
}

create() [2/2]

template<class H, class HBASE, typename... Types>

HBASE * HistogramFactory::create ( const HistogramDef & def, Types &&... hargs )

private

Create and register histogram.

If histogram already exists under that name, re-use it

Template Parameters

H	Actual type of histogram to be created
HBASE	Histogram base class (TH[1,2,3])
Types	Types of the remaining arguments for TH constructor (except name, title)

Parameters

def	Histogram definition
hargs	Arguments that defines specific type of the histogram

Returns

Histogram handler

Definition at line 208 of file HistogramFactory.cxx.

                                                                         {    
  std::string fullName = getFullName(def);
   
  // Check if histogram exists already
  HBASE* histo = nullptr;
  if ( m_histSvc->exists( fullName ) ) {
    if ( !m_histSvc->getHist( fullName, histo ) ) {
      throw HistogramException("Histogram >"+ fullName + "< seems to exist but can not be obtained from THistSvc");
    }    
    return histo;
  }
 
  // Create the histogram and register it
  // Hold global lock until we have detached object from gDirectory
  H* h = nullptr;
  { 
    std::scoped_lock<std::mutex> dirLock(globalROOTMutex());
    h = new H(def.alias.c_str(), def.title.c_str(), std::forward<Types>(hargs)...);
    h->SetDirectory(0);
  }
  if ( !m_histSvc->regHist( fullName, std::unique_ptr<TH1>(h) ) ) {
    throw HistogramException("Histogram >"+ fullName + "< can not be registered in THistSvc");
  }
 
  h->GetYaxis()->SetTitleOffset(1.25); // magic shift to make histograms readable even if no post-procesing is done
  setLabels(h, def);
  setOpts(h, def);
 
  return h;
}

create1D()

template<class H>

TH1 * HistogramFactory::create1D ( const HistogramDef & def )

private

Helper for generic 'create' method for 1D histograms.

Template Parameters

H	Actual type of histogram to be created

Parameters

def	Histogram definition

Returns

Histogram handler

Definition at line 102 of file HistogramFactory.cxx.

                                                       {
  if ( def.xarray.size()!=0 ) {
    return create<H,TH1>(def, def.xbins, &(def.xarray)[0]);
  } else {
    return create<H,TH1>(def, def.xbins, def.xmin, def.xmax);
  }
}

create1DProfile()

template<class H>

TH1 * HistogramFactory::create1DProfile ( const HistogramDef & def )

private

Helper for generic 'create' method for 1DProfile histograms.

Template Parameters

H	Actual type of histogram to be created

Parameters

def	Histogram definition

Returns

Histogram handler

Definition at line 111 of file HistogramFactory.cxx.

                                                              {
  if (def.xarray.size()!=0) {
    return create<H,TH1>(def, def.xbins, &(def.xarray)[0],
                              def.ymin, def.ymax);
  } else {
    return create<H,TH1>(def, def.xbins, def.xmin, def.xmax, 
                              def.ymin, def.ymax);
  }
}

create2D()

template<class H>

TH2 * HistogramFactory::create2D ( const HistogramDef & def )

private

Helper for generic 'create' method for 2D histograms.

Template Parameters

H	Actual type of histogram to be created

Parameters

def	Histogram definition

Returns

Histogram handler

Definition at line 122 of file HistogramFactory.cxx.

                                                       {
  if (def.xarray.size()!=0 && def.yarray.size()!=0) {
    return create<H,TH2>(def, def.xbins, &(def.xarray)[0],
                              def.ybins, &(def.yarray)[0]);
  } else if (def.yarray.size()!=0) {
    return create<H,TH2>(def, def.xbins, def.xmin, def.xmax,
                              def.ybins, &(def.yarray)[0]);
  } else if (def.xarray.size()!=0) {
    return create<H,TH2>(def, def.xbins, &(def.xarray)[0],
                              def.ybins, def.ymin, def.ymax);
  } else {
    return create<H,TH2>(def, def.xbins, def.xmin, def.xmax,
                              def.ybins, def.ymin, def.ymax);
  }
}

create2DProfile()

template<class H>

TH2 * HistogramFactory::create2DProfile ( const HistogramDef & def )

private

Helper for generic 'create' method for 2DProfile histograms.

Template Parameters

H	Actual type of histogram to be created

Parameters

def	Histogram definition

Returns

Histogram handler

Definition at line 139 of file HistogramFactory.cxx.

                                                              {
  if (def.xarray.size()!=0 && def.yarray.size()!=0) {
    return create<H,TH2>(def, def.xbins, &(def.xarray)[0],
                              def.ybins, &(def.yarray)[0]);
  } else if (def.yarray.size()!=0) {
    return create<H,TH2>(def, def.xbins, def.xmin, def.xmax, 
                              def.ybins, &(def.yarray)[0]);
  } else if (def.xarray.size()!=0) {
    return create<H,TH2>(def, def.xbins, &(def.xarray)[0],
                              def.ybins, def.ymin, def.ymax);
  } else {
    return create<H,TH2>(def, def.xbins, def.xmin, def.xmax, 
                              def.ybins, def.ymin, def.ymax, 
                              def.zmin, def.zmax);
  }
}

createEfficiency()

TEfficiency * HistogramFactory::createEfficiency ( const HistogramDef & def )

private

Create and register efficiency graph.

If graph already exists under that name, re-use it

Parameters

def	Histogram definition

Returns

Efficiency graph handler

Definition at line 156 of file HistogramFactory.cxx.

                                                                       {    
  std::string fullName = getFullName(def);
 
  // Check if efficiency exists already
  TEfficiency* e = nullptr;
  if ( m_histSvc->existsEfficiency(fullName) ) {
    if ( !m_histSvc->getEfficiency(fullName,e) ) {
      throw HistogramException("Histogram >"+ fullName + "< seems to exist but can not be obtained from THistSvc");
    }
    return e;
  }
 
  // Otherwise, create the efficiency and register it
  // Hold global lock until we have detached object from gDirectory
  {
    std::scoped_lock<std::mutex> dirLock(globalROOTMutex());
    if (def.ybins==0 && def.zbins==0) { // 1D TEfficiency
      if (def.xarray.size()!=0) {
        e = new TEfficiency(def.alias.c_str(), def.title.c_str(),
          def.xbins, &(def.xarray)[0]);
      } else {
        e = new TEfficiency(def.alias.c_str(), def.title.c_str(),
          def.xbins, def.xmin, def.xmax);
      }
    } else if (def.ybins>0 && def.zbins==0) { // 2D TEfficiency
      if (def.xarray.size()!=0 && def.yarray.size()!=0) {
        e = new TEfficiency(def.alias.c_str(), def.title.c_str(),
          def.xbins, &(def.xarray)[0], def.ybins, &(def.yarray)[0]);
      } else {
        e = new TEfficiency(def.alias.c_str(), def.title.c_str(),
          def.xbins, def.xmin, def.xmax, def.ybins, def.ymin, def.ymax);
      }
    } else if (def.ybins>0 && def.zbins>0) { // 3D TEfficiency
      e = new TEfficiency(def.alias.c_str(), def.title.c_str(),
        def.xbins, def.xmin, def.xmax, def.ybins, def.ymin, def.ymax, def.zbins, def.zmin, def.zmax);
    } else {
      throw HistogramException("Histogram >"+ fullName + "< could not be defined. Check xbins, ybins, and zbins.");
    }
    e->SetDirectory(0);
  }
  if ( !m_histSvc->regEfficiency(fullName, std::unique_ptr<TEfficiency>(e)) ) {
    throw HistogramException("Histogram >"+ fullName + "< can not be registered in THistSvc");
  }
  TH1* total ATLAS_THREAD_SAFE = const_cast<TH1*>(e->GetTotalHistogram());
  setLabels(total, def);
  TH1* passed ATLAS_THREAD_SAFE = const_cast<TH1*>(e->GetPassedHistogram());
  setLabels(passed, def);
 
  return e;
}

createTree()

TTree * HistogramFactory::createTree ( const HistogramDef & def )

private

Create and register tree.

If tree already exists under that name, re-use it

Parameters

def	Histogram definition

Returns

Pointer to tree

Definition at line 239 of file HistogramFactory.cxx.

                                                           {
   std::string fullName = getFullName(def);
 
  // Check if tree exists already
  TTree* t = nullptr;
  if ( m_histSvc->existsTree(fullName) ) {
    if ( !m_histSvc->getTree(fullName,t) ) {
      throw HistogramException("Tree >"+ fullName + "< seems to exist but can not be obtained from THistSvc");
    }
    return t;
  }
 
  // Otherwise, create the tree and register it
  // branches will be created by HistogramFillerTree
  {
    std::scoped_lock<std::mutex> dirLock(globalROOTMutex());
    t = new TTree(def.alias.c_str(),def.title.c_str());
    t->SetDirectory(0);
  }
  if ( !m_histSvc->regTree(fullName, std::unique_ptr<TTree>(t) ) ) {
    throw HistogramException("Tree >"+ fullName + "< can not be registered in THistSvc");
  }
 
  return t;
}

getFullName()

std::string HistogramFactory::getFullName

(

const HistogramDef &

def

)

const

Invent path name.

If def path contains any of: EXPERT, SHIFT, DEBUG, RUNSTAT, EXPRESS this is online convention this becomes the first element of the path followed by the group name. Else if the def.path is DEFAULT then only the group name is used if the path yet different is concatenated with the group name.

Parameters

def	Histogram definition

Returns

Full path to histogram

Definition at line 292 of file HistogramFactory.cxx.

                                                                     {
 
  // for online paths, always prepend a slash. Otherwise take it from provided stream name
  std::string path;
  if ( onlinePaths.count( def.path)!=0 ) {
    path =  "/" + def.path + "/" + m_streamName + "/" + m_groupName;
  } else if ( def.path=="DEFAULT" ) {
    path = "/" + m_streamName + "/" + m_groupName;
  } else {
    path = m_streamName + "/" + def.tld + "/" + m_groupName + "/" + def.path;
  }
 
  // remove duplicate slashes
  std::string fullName = path + "/" + def.alias;
  fullName.erase( std::unique( fullName.begin(), fullName.end(), 
    [](const char a, const char b) { 
      return a == b and a == '/';
    } ), fullName.end() );
 
  return fullName;
}

globalROOTMutex()

std::mutex & Monitored::HistogramFactory::globalROOTMutex ( )

inlinestatic

Definition at line 68 of file HistogramFactory.h.

{ return s_histDirMutex; }

remove()

void HistogramFactory::remove ( const HistogramDef & def )

virtual

Removes histogram (used to get rid of old LB tagged histograms)

Definition at line 314 of file HistogramFactory.cxx.

                                                     {
  const std::string path = getFullName( def );
 
  TObject* obj = nullptr;
  if (def.type=="TEfficiency") {
    TEfficiency* e;
    m_histSvc->getEfficiency(path, e).ignore();
    obj = e;
  } else if (def.type=="TGraph") {
    TGraph* g;
    m_histSvc->getGraph(path, g).ignore();
    obj = g;
  } else if (def.type=="TTree") {
    TTree* t;
    m_histSvc->getTree(path, t).ignore();
    obj = t;
  } else {
    TH1* h;
    m_histSvc->getHist(path, h).ignore();
    obj = h;
  }
 
  if (obj) {
    m_histSvc->deReg(path).ignore();
    if (m_deleteOnRemove) {
      delete obj;
    }
  }
}

setLabels() [1/2]

void HistogramFactory::setLabels ( TAxis * axis, const std::vector< std::string > & labels )

staticprivate

Setup labels for histogram axes.

Parameters

hist	Histogram handler
labels	Histogram labels (from histogram definition)

Definition at line 280 of file HistogramFactory.cxx.

                                                                                {
  if ( !labels.empty() ) {
    const int nBin = axis->GetNbins();
    for ( int bin=0; bin<nBin; bin++ ) {
      axis->SetBinLabel(bin+1, labels[bin].c_str());
    }
  }
}

setLabels() [2/2]

void HistogramFactory::setLabels ( TH1 * hist, const HistogramDef & def )

staticprivate

Set labels for all axes.

Parameters

hist	Histogram pointer
def	Histogram definition

Definition at line 274 of file HistogramFactory.cxx.

                                                                   {
  setLabels(hist->GetXaxis(), def.xlabels);
  setLabels(hist->GetYaxis(), def.ylabels);
  setLabels(hist->GetZaxis(), def.zlabels);
}

setOpts()

void HistogramFactory::setOpts ( TH1 * hist, const HistogramDef & def )

staticprivate

Setup various histogram options.

Available options: kCanRebin, Sumw2

Parameters

hist	Histogram handler
opt	Histogram options (from histogram definition)

Definition at line 265 of file HistogramFactory.cxx.

                                                                 {
  // apply extension policy
  const unsigned canExtendPolicy = def.kCanRebin ? TH1::kAllAxes : TH1::kNoAxis;
  hist->SetCanExtend(canExtendPolicy);
 
  // apply Sumw2 option
  hist->Sumw2(def.Sumw2);
}

Member Data Documentation

m_createLock

std::mutex Monitored::HistogramFactory::m_createLock

mutableprivate

Definition at line 171 of file HistogramFactory.h.

m_deleteOnRemove

bool Monitored::HistogramFactory::m_deleteOnRemove {true}

private

delete histogram during remove

Definition at line 170 of file HistogramFactory.h.

{true};  

m_groupName

std::string Monitored::HistogramFactory::m_groupName

private

defines location of group of histograms

Definition at line 168 of file HistogramFactory.h.

m_histSvc

ServiceHandle<ITHistSvc> Monitored::HistogramFactory::m_histSvc

private

Definition at line 166 of file HistogramFactory.h.

m_streamName

std::string Monitored::HistogramFactory::m_streamName

private

defines the stream for THistSvc

Definition at line 167 of file HistogramFactory.h.

s_histDirMutex

std::mutex Monitored::HistogramFactory::s_histDirMutex

inlinestaticprivate

Definition at line 172 of file HistogramFactory.h.

---

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

• HistogramFactory.h
• HistogramFactory.cxx