Monitored::HistogramFillerTree Class Reference

Filler for TTrees. More...

#include <HistogramFillerTree.h>

Inheritance diagram for Monitored::HistogramFillerTree:

Collaboration diagram for Monitored::HistogramFillerTree:

Public Member Functions
	HistogramFillerTree (const HistogramDef &definition, std::shared_ptr< IHistogramProvider > provider)
virtual unsigned	fill (const HistogramFiller::VariablesPack &vars) const override
	Method that actually fills the ROOT object.
void	touch () const
	Ensure histogram exists.
const std::vector< std::string > &	histogramVariablesNames () const
const std::string &	histogramWeightName () const
const std::string &	histogramCutMaskName () const
const std::unique_lock< std::mutex >	getLock () const

Protected Member Functions
template<class H, typename W, typename C, typename ... Ms>
unsigned	fill (W weight, C cut, const Ms &... m) const
	Fill histogram from IMonitoredVariable.
template<class H>
H *	histogram () const

Protected Attributes
std::shared_ptr< HistogramDef >	m_histDef
std::shared_ptr< IHistogramProvider >	m_histogramProvider
std::mutex	m_lock

Private Member Functions
void	parseDefinition ()
template<typename T>
void	branchHelper (TTree *tree, const std::pair< std::string, std::string > &brdef) const
void	createBranches (TTree *tree) const

Private Attributes
std::vector< std::pair< std::string, std::string > >	m_branchDefs
std::vector< std::function< void(TBranch *, const IMonitoredVariable &)> >	m_fillerFunctions

Detailed Description

Filler for TTrees.

Definition at line 22 of file HistogramFillerTree.h.

Constructor & Destructor Documentation

HistogramFillerTree()

Monitored::HistogramFillerTree::HistogramFillerTree ( const HistogramDef & definition, std::shared_ptr< IHistogramProvider > provider )

inline

Definition at line 24 of file HistogramFillerTree.h.

      : HistogramFiller(definition, std::move(provider)) {
        parseDefinition();
    }

Member Function Documentation

branchHelper()

template<typename T>

void Monitored::HistogramFillerTree::branchHelper ( TTree * tree, const std::pair< std::string, std::string > & brdef ) const

inlineprivate

Definition at line 134 of file HistogramFillerTree.h.

                                                                                     {
      std::vector<T> dummy;
      std::vector<T>* dummyptr = &dummy;
      // we only need dummy object to exist through the end of this method
      tree->Branch(brdef.first.c_str(), &dummyptr);
    }

createBranches()

void Monitored::HistogramFillerTree::createBranches ( TTree * tree ) const

inlineprivate

Definition at line 141 of file HistogramFillerTree.h.

                                           {
      for (const auto& brdef : m_branchDefs) {
        if (brdef.second == "vector<char>") branchHelper<char>(tree, brdef);
        else if (brdef.second == "vector<unsigned char>") branchHelper<unsigned char>(tree, brdef);
        else if (brdef.second == "vector<int>") branchHelper<int>(tree, brdef);
        else if (brdef.second == "vector<unsigned int>") branchHelper<unsigned int>(tree, brdef);
        else if (brdef.second == "vector<float>") branchHelper<float>(tree, brdef);
        else if (brdef.second == "vector<double>") branchHelper<double>(tree, brdef);
        else if (brdef.second == "vector<long>") branchHelper<long>(tree, brdef);
        else if (brdef.second == "vector<unsigned long>") branchHelper<unsigned long>(tree, brdef);
        else if (brdef.second == "vector<string>") branchHelper<std::string>(tree, brdef);
        else if (brdef.second == "string") {
            std::string dummy; tree->Branch(brdef.first.c_str(), &dummy);
        } else if (brdef.second != "IGNORE") {
          tree->Branch(brdef.first.c_str(), (void*) nullptr, (brdef.first+"/"+brdef.second).c_str());
        }
      }
    }

fill() [1/2]

template<class H, typename W, typename C, typename ... Ms>

unsigned Monitored::HistogramFiller::fill ( W weight, C cut, const Ms &... m ) const

inlineprotectedinherited

Fill histogram from IMonitoredVariable.

Supports arbitrary dimensions and double/string representation.

Template Parameters

H	histogram type (TH1, TH2, ...)

Parameters

weight	weight accessor (use detail::noWeight if not needed)
cut	cut mask accessor (use detail::noCut if not needed)
m...	IMonitoredVariable list to fill from

Definition at line 168 of file HistogramFiller.h.

                                                         {
      auto hist = this->histogram<H>();
 
      size_t i = 0;
      for (; i < std::max({m.size()...}); ++i ) {
        if ( cut(i) ) {
          detail::doFill(hist, weight, i, m...);
        }
      }
      return i;
    }

fill() [2/2]

virtual unsigned Monitored::HistogramFillerTree::fill ( const HistogramFiller::VariablesPack & ) const

inlineoverridevirtual

Method that actually fills the ROOT object.

Returns

number of fills performed

Implements Monitored::HistogramFiller.

Definition at line 29 of file HistogramFillerTree.h.

                                                                                     {
 
      if (vars.cut) {
        const size_t maskSize = vars.cut->size();
        // Abort if no cut entries or first (and only) entry is false
        if (maskSize == 0 || (maskSize == 1 && !vars.cut->get(0))) { return 0; }
 
        if (ATH_UNLIKELY(maskSize > 1)) {
          MsgStream log(Athena::getMessageSvc(), "HistogramFillerTree");
          log << MSG::WARNING << "HistogramFillerTree (" << m_histDef->alias
              << ") does not support more than a single entry being filled at a time\n"
              << "so a cut mask with > 1 entry doesn't make sense. Using first entry only." << endmsg;
          if (!vars.cut->get(0)) { return 0; }
        }
      }
 
      if (ATH_UNLIKELY(vars.size() != m_branchDefs.size())) {
        MsgStream log(Athena::getMessageSvc(), "HistogramFillerTree");
        log << MSG::ERROR << "Mismatch of passed variables and expected variables for " << m_histDef->alias 
                          << "(" << vars.size() << ", " << m_branchDefs.size() << ")" << endmsg;
        return 0;
      }
 
      auto tree = this->histogram<TTree>();
      if (tree->GetListOfBranches()->GetEntries() == 0) {
        createBranches(tree);
      }
      auto branchList = tree->GetListOfBranches();
      // following logic allows us to skip branches that were badly-defined
      size_t idx = 0, idxgood = 0;
      for (const auto& brdef : m_branchDefs) {
        if (ATH_UNLIKELY(brdef.second == "IGNORE")) {
          ++idx; continue;
        }
        TBranch* branch = static_cast<TBranch*>(branchList->At(idxgood));
        m_fillerFunctions[idx](branch, *vars[idx]);
        ++idx; ++idxgood;
      }
      for (Int_t i = 0; i < branchList->GetEntries(); ++i) {
        
 
      }
      tree->SetEntries(tree->GetEntries() + 1);
      return 1;     
    }

getLock()

const std::unique_lock< std::mutex > Monitored::HistogramFiller::getLock ( ) const

inlineinherited

Definition at line 147 of file HistogramFiller.h.

                                                   {
      return std::unique_lock(m_lock);
    }

histogram()

template<class H>

H * Monitored::HistogramFiller::histogram ( ) const

inlineprotectedinherited

Definition at line 153 of file HistogramFiller.h.

                         {
      return static_cast<H*>(m_histogramProvider->histogram());
    }

histogramCutMaskName()

const std::string & Monitored::HistogramFiller::histogramCutMaskName ( ) const

inlineinherited

Definition at line 143 of file HistogramFiller.h.

                                                  {
      return m_histDef->cutMask;
    }

histogramVariablesNames()

const std::vector< std::string > & Monitored::HistogramFiller::histogramVariablesNames ( ) const

inlineinherited

Definition at line 135 of file HistogramFiller.h.

                                                                {
      return m_histDef->name;
    }

histogramWeightName()

const std::string & Monitored::HistogramFiller::histogramWeightName ( ) const

inlineinherited

Definition at line 139 of file HistogramFiller.h.

                                                 {
      return m_histDef->weight;
    }

parseDefinition()

void Monitored::HistogramFillerTree::parseDefinition ( )

inlineprivate

Definition at line 79 of file HistogramFillerTree.h.

                           {
      std::vector<std::string> tokenized;
      boost::split(tokenized, m_histDef->treeDef, [](char c){ return c ==':'; });
      for (const auto& token : tokenized) {
        auto ipart = token.find('/');
        if (ipart == std::string::npos) {
          MsgStream log(Athena::getMessageSvc(), "HistogramFillerTree");
          log << MSG::ERROR << "Tree " << m_histDef->alias << ": Badly formed variable definition " << token 
              << "; skipping" << endmsg;
          continue;
        }
        auto branch = token.substr(0, ipart);
        auto type = token.substr(ipart+1);
        std::function<void(TBranch*, const IMonitoredVariable&)> fillerFunc;
        // scalar
        if (type == "B") fillerFunc = scalarFillerFunc<Char_t>;
        else if (type == "b") fillerFunc = scalarFillerFunc<UChar_t>;
        else if (type == "S") fillerFunc = scalarFillerFunc<Short_t>;
        else if (type == "s") fillerFunc = scalarFillerFunc<UShort_t>;
        else if (type == "I") fillerFunc = scalarFillerFunc<Int_t>;
        else if (type == "i") fillerFunc = scalarFillerFunc<UInt_t>;
        else if (type == "F") fillerFunc = scalarFillerFunc<Float_t>;
        else if (type == "f") fillerFunc = scalarFillerFunc<Float16_t>;
        else if (type == "D") fillerFunc = scalarFillerFunc<Double_t>;
        else if (type == "d") fillerFunc = scalarFillerFunc<Double32_t>;
        else if (type == "L") fillerFunc = scalarFillerFunc<Long64_t>;
        else if (type == "l") fillerFunc = scalarFillerFunc<ULong64_t>;
        else if (type == "O") fillerFunc = scalarFillerFunc<Bool_t>;
        else if (type == "string") fillerFunc = scalarFillerFunc<std::string>;
        else if (type == "vector<char>") fillerFunc = vectorFillerFunc<char>;
        else if (type == "vector<unsigned char>") fillerFunc = vectorFillerFunc<unsigned char>;
        else if (type == "vector<int>") fillerFunc = vectorFillerFunc<int>;
        else if (type == "vector<unsigned int>") fillerFunc = vectorFillerFunc<unsigned int>;
        else if (type == "vector<float>") fillerFunc = vectorFillerFunc<float>;
        else if (type == "vector<double>") fillerFunc = vectorFillerFunc<double>;
        else if (type == "vector<long>") fillerFunc = vectorFillerFunc<long>;
        else if (type == "vector<unsigned long>") fillerFunc = vectorFillerFunc<unsigned long>;
        else if (type == "vector<string>") fillerFunc = vectorFillerFunc<std::string>;
        else if (type == "C") {
          MsgStream log(Athena::getMessageSvc(), "HistogramFillerTree");
          log << MSG::ERROR << "Tree " << m_histDef->alias << ": Branch type \"C\" not supported for branch" << branch
                            << "; please use \"string\"" << endmsg;
          type = "IGNORE";
        } else {
          MsgStream log(Athena::getMessageSvc(), "HistogramFillerTree");
          log << MSG::ERROR << "Tree " << m_histDef->alias << ": Unrecognized branch type " << type << " for branch " << branch
                            << "; ignoring branch " << endmsg;
          type = "IGNORE";
        }
        m_branchDefs.emplace_back(branch, type);
        m_fillerFunctions.push_back(std::move(fillerFunc));
      }
    }

touch()

void Monitored::HistogramFiller::touch ( ) const

inlineinherited

Ensure histogram exists.

Definition at line 130 of file HistogramFiller.h.

                       {
      histogram<void>();
    }

Member Data Documentation

m_branchDefs

std::vector<std::pair<std::string, std::string> > Monitored::HistogramFillerTree::m_branchDefs

private

Definition at line 76 of file HistogramFillerTree.h.

m_fillerFunctions

std::vector<std::function<void(TBranch*, const IMonitoredVariable&)> > Monitored::HistogramFillerTree::m_fillerFunctions

private

Definition at line 77 of file HistogramFillerTree.h.

m_histDef

std::shared_ptr<HistogramDef> Monitored::HistogramFiller::m_histDef

protectedinherited

Definition at line 180 of file HistogramFiller.h.

m_histogramProvider

std::shared_ptr<IHistogramProvider> Monitored::HistogramFiller::m_histogramProvider

protectedinherited

Definition at line 181 of file HistogramFiller.h.

m_lock

std::mutex Monitored::HistogramFiller::m_lock

mutableprotectedinherited

Definition at line 182 of file HistogramFiller.h.

---

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

• HistogramFillerTree.h