Monitored::detail Namespace Reference

Classes
struct	get_value_type
	Get element type for containers. More...
struct	get_value_type< ActsTrk::TrackContainer >
struct	get_value_type< std::reference_wrapper< T > >
	Specializations for reference_wrappers which are hopefully never chosen. More...
struct	get_value_type< std::reference_wrapper< T[N]> >
struct	get_value_type< T[N]>
	Get element type for arrays. More...
struct	make_pointer_const
struct	make_pointer_const< T * >

Functions
template<typename T = int>
int	findToolIndex (const ToolHandleArray< GenericMonitoringTool > &toolArray, const std::string &name)
	Finds the index of an element in a tool handle array by its string name.
template<typename H, typename W, typename M, typename ... Ms>
void	doFill (H *hist, W weight, size_t i, const M &m1, const Ms &... m)
	Perform (arbitrary dimension) histogram fill with weight.
template<typename W>
void	doFill (TProfile *, W, size_t, const double &, const char *const &)
template<typename W>
void	doFill (TProfile *, W, size_t, const char *const &, const char *const &)
template<typename W>
void	doFill (TProfile2D *, W, size_t, const double &, const double &, const char *const &)
template<typename W>
void	doFill (TProfile2D *, W, size_t, const char *const &, const char *const &, const char *const &)
template<typename W>
void	doFill (TProfile2D *, W, size_t, const char *const &, const double &, const char *const &)
template<typename W>
void	doFill (TProfile2D *, W, size_t, const double &, const char *const &, const char *const &)
template<Axis AXIS, typename H>
constexpr auto	getAxis (H *hist)
	Helper to get corresponding TAxis selected by Monitored::Axis.
template<Axis AXIS, typename H>
double	getFillValue (const H *hist, const IMonitoredVariable *var, size_t i)
	Return value for filling i'th entry of var into AXIS for hist.
bool	shouldRebinHistogram (const TAxis *axis, const double value)
	Method checks if histogram should be rebinned.
template<Axis AXIS, typename H>
void	rebinHistogram (H *hist, const double value)
	Method that rebins a histogram.
template<typename T>
bool	fillWillRebinHistogram (const TAxis *axis, T value)
	Check if Fill would result in rebinning.
template<>
bool	fillWillRebinHistogram (const TAxis *axis, const char *value)
	Check if Fill would result in rebinning for alphanumeric axis.
template<typename H, typename T, T... a, typename ... Vs>
bool	fillWillRebinHistogram (H *hist, std::integer_sequence< T, a... >, const Vs &... v)
	Check if any of the histogram axes will be rebinned.

Variables
auto	noWeight = [](size_t){ return 1.0; }
	no weight for filling
auto	noCut = [](size_t){ return true; }
	no cut for filling
constexpr std::array	axis_name {"X", "Y", "Z"}
	Convert axis to ROOT-compatible character.
constexpr std::array	axis_bit {TH1::kXaxis, TH1::kYaxis, TH1::kZaxis}

Function Documentation

doFill() [1/7]

template<typename H, typename W, typename M, typename ... Ms>

void Monitored::detail::doFill	(	H *	hist,
		W	weight,
		size_t	i,
		const M &	m1,
		const Ms &...	m )

Perform (arbitrary dimension) histogram fill with weight.

Parameters

hist	histogram to fill
weight	weight accessor
i	IMonitoredVariable entry to fill
m1,m...	IMonitoredVariable list to fill from

Definition at line 164 of file HistogramFillerUtils.h.

                                                                          {
 
      // Template magic: Recursively convert all M to double or string
      if constexpr(std::is_same_v<M, Monitored::IMonitoredVariable>) {
        // For >=2D: If one variable has a single entry, do repeated fills with that value
        const size_t j = m1.size()==1 ? 0 : i;
        if (not m1.hasStringRepresentation())
          doFill(hist, weight, i, m..., m1.get(j));
        else
          doFill(hist, weight, i, m..., m1.getString(j).c_str());
      } else {
        // In case re-binning occurs need to take the OH lock for online (no-op offline)
        if ( ATH_UNLIKELY(fillWillRebinHistogram(hist, std::index_sequence_for<M, Ms...>{},
                                                 m1, m...)) ){
          oh_scoped_lock_histogram lock;
          // Rebinning requires a lock on the global ROOT directory state
          std::scoped_lock<std::mutex> dirLock(HistogramFactory::globalROOTMutex());
          hist->Fill(m1, m..., weight(i));
        }
        else hist->Fill(m1, m..., weight(i));
      }
    }

doFill() [2/7]

template<typename W>

void Monitored::detail::doFill	(	TProfile *	,
		W	,
		size_t	,
		const char *const &	,
		const char *const &	)

Definition at line 192 of file HistogramFillerUtils.h.

{}

doFill() [3/7]

template<typename W>

void Monitored::detail::doFill	(	TProfile *	,
		W	,
		size_t	,
		const double &	,
		const char *const &	)

Definition at line 190 of file HistogramFillerUtils.h.

{}

doFill() [4/7]

template<typename W>

void Monitored::detail::doFill	(	TProfile2D *	,
		W	,
		size_t	,
		const char *const &	,
		const char *const &	,
		const char *const &	)

Definition at line 196 of file HistogramFillerUtils.h.

{}

doFill() [5/7]

template<typename W>

void Monitored::detail::doFill	(	TProfile2D *	,
		W	,
		size_t	,
		const char *const &	,
		const double &	,
		const char *const &	)

Definition at line 198 of file HistogramFillerUtils.h.

{}

doFill() [6/7]

template<typename W>

void Monitored::detail::doFill	(	TProfile2D *	,
		W	,
		size_t	,
		const double &	,
		const char *const &	,
		const char *const &	)

Definition at line 200 of file HistogramFillerUtils.h.

{}

doFill() [7/7]

template<typename W>

void Monitored::detail::doFill	(	TProfile2D *	,
		W	,
		size_t	,
		const double &	,
		const double &	,
		const char *const &	)

Definition at line 194 of file HistogramFillerUtils.h.

{}

fillWillRebinHistogram() [1/3]

template<>

bool Monitored::detail::fillWillRebinHistogram	(	const TAxis *	axis,
		const char *	value )

Check if Fill would result in rebinning for alphanumeric axis.

Note that even adding a new label to an unlabeled bin is not thread-safe and needs to be treated as "rebinning" (ADHI-4881).

Definition at line 130 of file HistogramFillerUtils.h.

                                                                      {
      // valid bin found
      if ( not axis or axis->FindFixBin(value)>0 ) return false;
 
      // If there are no labels yet at least one unlabeled bin is available
      const THashList* labels = axis->GetLabels();
      if ( not labels ) return false;
 
      return true;
    }

fillWillRebinHistogram() [2/3]

template<typename T>

bool Monitored::detail::fillWillRebinHistogram	(	const TAxis *	axis,
		T	value )

Check if Fill would result in rebinning.

Determine if Fill(value) would result in a rebinning of the histogram.

Definition at line 113 of file HistogramFillerUtils.h.

                                                            {
      if (not axis) return false;
      const int bin = axis->FindFixBin(value);
      // if under/overflow
      if ( bin==0 or bin==axis->GetNbins()+1 ) {
        return true;
      }
      return false;
    }

fillWillRebinHistogram() [3/3]

template<typename H, typename T, T... a, typename ... Vs>

bool Monitored::detail::fillWillRebinHistogram	(	H *	hist,
		std::integer_sequence< T, a... >	,
		const Vs &...	v )

Check if any of the histogram axes will be rebinned.

Parameters

hist	histogram to check
a...	integer sequence of axes to check (0, 1, ...)
v...	x, y, ... values to fill

Definition at line 149 of file HistogramFillerUtils.h.

                                                                                       {
      // First check if axis is extensible, then if value would be outside of range
      return (... || (getAxis<static_cast<Axis>(a)>(hist)->CanExtend() and
                      detail::fillWillRebinHistogram(getAxis<static_cast<Axis>(a)>(hist), v)));
    }

findToolIndex()

template<typename T = int>

int Monitored::detail::findToolIndex	(	const ToolHandleArray< GenericMonitoringTool > &	toolArray,
		const std::string &	name )

Finds the index of an element in a tool handle array by its string name.

Definition at line 138 of file MonitoredGroup.h.

                                                                                                        {
      auto it = std::find_if(toolArray.begin(),toolArray.end(),[&](const auto& r) {return r.name()==name;});
      return it!=toolArray.end()
        ? std::distance(toolArray.begin(),it)
        : throw std::runtime_error("The tool "+name+" could not be found in the tool array.");
    }

getAxis()

template<Axis AXIS, typename H>

auto Monitored::detail::getAxis ( H * hist )

constexpr

Helper to get corresponding TAxis selected by Monitored::Axis.

(works for const/non-const TAxis/TH1 thanks to auto return type)

Definition at line 40 of file HistogramFillerUtils.h.

                                    {
      if constexpr (AXIS==Axis::X) return hist->GetXaxis();
      else if constexpr (AXIS==Axis::Y) return hist->GetYaxis();
      else return hist->GetZaxis();
    }

getFillValue()

template<Axis AXIS, typename H>

double Monitored::detail::getFillValue	(	const H *	hist,
		const IMonitoredVariable *	var,
		size_t	i )

Return value for filling i'th entry of var into AXIS for hist.

If var is string-valued performs a bin lookup first.

Template Parameters

AXIS	Histograms axis

Parameters

hist	Histogram
var	MonitoredVariable for value lookup
i	index for IMonitoredVariable value lookup

Definition at line 56 of file HistogramFillerUtils.h.

                                                                                {
      if ( var->hasStringRepresentation() ) {
        const TAxis* axis = getAxis<AXIS>(hist);
        const int binNumber = axis->FindFixBin( var->getString(i).c_str() );
        return axis->GetBinCenter(binNumber);
      } else {
        return var->get(i);
      }
    }

rebinHistogram()

template<Axis AXIS, typename H>

void Monitored::detail::rebinHistogram	(	H *	hist,
		const double	value )

Method that rebins a histogram.

Algorithm will increase a size of the histogram until value can be included in new range of values. Examples for xMin=1.0, xMax=3.0; value=2.9, xMax will be unchanged value=3.0, xMax will be doubled value=4.9, xMax will be doubled value=5.0, xMax will be quadrupled value=5.1, xMax will be quadrupled value=8.9, xMax will be quadrupled value=9.0, xMax will be octupled value=9.1, xMax will be octupled

Definition at line 89 of file HistogramFillerUtils.h.

                                                     {
      hist->SetCanExtend(axis_bit[AXIS]);
      TAxis* a = getAxis<AXIS>(hist);
 
      // Rebinning requires to take OH lock in online (no-op offline)
      oh_scoped_lock_histogram lock;
      // Rebinning requires a lock on the global ROOT directory state
      std::scoped_lock<std::mutex> dirLock(HistogramFactory::globalROOTMutex());
      do {
        // need to unset cleanup bit of parent histogram during this operation
        // since it gets copied to a hidden temporary (probably unintentionally)
        bool curcleanup = hist->TestBit(TObject::kMustCleanup);
        hist->ResetBit(TObject::kMustCleanup);
        hist->LabelsInflate(axis_name[AXIS]);
        hist->SetBit(TObject::kMustCleanup, curcleanup);
      } while (shouldRebinHistogram(a, value));
    }

shouldRebinHistogram()

bool Monitored::detail::shouldRebinHistogram	(	const TAxis *	axis,
		const double	value )

Method checks if histogram should be rebinned.

It should happen when the new value is greater or equal to the greatest value of the histogram axis.

Definition at line 70 of file HistogramFillerUtils.h.

                                                                     {
      return axis ? axis->GetXmax() <= value : false;
    }

Variable Documentation

axis_bit

std::array Monitored::detail::axis_bit {TH1::kXaxis, TH1::kYaxis, TH1::kZaxis}

constexpr

Definition at line 33 of file HistogramFillerUtils.h.

{TH1::kXaxis, TH1::kYaxis, TH1::kZaxis};

axis_name

std::array Monitored::detail::axis_name {"X", "Y", "Z"}

constexpr

Convert axis to ROOT-compatible character.

Definition at line 32 of file HistogramFillerUtils.h.

{"X", "Y", "Z"};

noCut

auto Monitored::detail::noCut = [](size_t){ return true; }

no cut for filling

Definition at line 29 of file HistogramFillerUtils.h.

{ return true; };   

noWeight

auto Monitored::detail::noWeight = [](size_t){ return 1.0; }

no weight for filling

Definition at line 28 of file HistogramFillerUtils.h.

{ return 1.0; };