Concrete implimentation of Counter to monitor all properties of a given Chain instance. More...

#include <CounterChain.h>

Inheritance diagram for CounterChain:

Collaboration diagram for CounterChain:

Public Member Functions
	CounterChain ()=delete
	Forbid default constructor.
	CounterChain (const std::string &name, const MonitorBase *parent)
	Construct counter.
	CounterChain (const std::string &name, unsigned nRos, const MonitorBase *parent)
	Construct counter.
virtual	~CounterChain ()=default
	Default destructor.
CounterChain &	operator= (const CounterChain &)=delete
	Forbid assignment.
	CounterChain (const CounterChain &)=delete
	Forbid copy.
virtual StatusCode	newEvent (const CostData &data, size_t index, const float weight=1.) override
	Concrete implimentation.
const std::string &	getName () const
	Getter for Counter's name.
const MonitorBase *	getParent () const
	Return cached non-owning const ptr to this Counter's parent Monitor.
bool	variableExists (const std::string &name) const
	Check if a variable of a given name exists.
Variable &	getVariable (std::string_view name)
	Returns a mutable reference to a named Variable.
StatusCode	fill (std::string_view name, float value, float weight=1.0)
	Fill (for per-Call) or accumulate in a buffer (for per-Event) a quantity histogrammed by a named Variable.
StatusCode	fill (std::string_view name, float xvalue, float yvalue, float weight)
	Fill (for per-Call) or accumulate in a buffer (for per-Event) a quantity histogrammed by a named Variable.
StatusCode	increment (std::string_view name, float weight=1.0)
	Convenience function.
StatusCode	setDenominator (const std::string &name, float value)
	Optional for per-Event Variables.
virtual StatusCode	endEvent (float weight=1.0)
	Called by the framework.

Protected Member Functions
void	regHistogram (const std::string &name, const std::string &title, const VariableType type=VariableType::kPerCall, const LogType xaxis=kLog, const float min=0.1, const float max=1000000., const size_t bins=70)
	Book a histogram for this Counter, to be filled in per-event monitoring.
void	regHistogram (const std::string &name, const std::string &title, const VariableType type, const LogType xaxis, const float xmin, const float xmax, const size_t xbins, const LogType yaxis, const float ymin, const float ymax, const size_t ybins)
	Book a 2D histogram for this Counter, to be filled in per-event monitoring.
void	regTProfile (const std::string &name, const std::string &title, const VariableType type=VariableType::kPerCall, const LogType xaxis=kLog, const float min=0.1, const float max=1000000., const size_t bins=70)
	Book a TProfile for this Counter, to be filled in per-event monitoring.
TH1 *	bookGetPointer (TH1 *hist, const std::string &tDir="") const
	Appends Counter name (to histogram path) and forwards histogram book request to parent Monitor.
float	timeToMilliSec (const uint64_t start, const uint64_t stop) const
	Helper function.

Private Attributes
bool	m_isInitialized {}
const std::string	m_name
	Counter's name.
const MonitorBase *	m_parent {}
	Counter's parent Monitor.
std::unordered_map< std::string, Variable, CxxUtils::TransparentStringHash, std::equal_to<> >	m_variables
	Store of Counter's Variables.

Detailed Description

Concrete implimentation of Counter to monitor all properties of a given Chain instance.

Definition at line 14 of file CounterChain.h.

Constructor & Destructor Documentation

◆ CounterChain() [1/4]

CounterChain::CounterChain ( )

delete

Forbid default constructor.

◆ CounterChain() [2/4]

CounterChain::CounterChain	(	const std::string &	name,
		const MonitorBase *	parent )

Construct counter.

Parameters

[in]	name	Counter's name
[in]	parent	Counter's parent monitor, cached non-owning pointer.

Definition at line 12 of file CounterChain.cxx.

  : CounterBase(name, parent), m_isInitialized(false)
{
  regHistogram("Group_perCall", "Chain group/Call;Group;Calls", VariableType::kPerCall, kLinear, -0.5, 9.5, 10);
  regHistogram("Chain_perEvent", "Chain calls/Event;Chain call;Events", VariableType::kPerEvent, kLinear, -0.5, 49.5);
  regHistogram("AlgCalls_perEvent", "Algorithm Calls/Event;Calls;Events", VariableType::kPerEvent, kLinear, -0.5, 999.5, 100);
  regHistogram("Time_perCall", "CPU Time/Call;Time [ms];Calls", VariableType::kPerCall, kLog, 0.01, 100000);
  regHistogram("Time_perEvent", "CPU Time/Event;Time [ms];Events", VariableType::kPerEvent);
  regHistogram("UniqueTime_perCall", "Unique CPU Time/Call;Time [ms];Calls", VariableType::kPerCall, kLog, 0.01, 100000);
  regHistogram("ChainPassed_perEvent", "Passed chain/Event;Passsed;Events", VariableType::kPerEvent, kLinear, -0.5, 1.5, 2);
  regHistogram("Request_perEvent", "Number of requests/Event;Number of requests;Events", VariableType::kPerEvent, LogType::kLinear, -0.5, 299.5, 300);
  regHistogram("NetworkRequest_perEvent", "Number of network requests/Event;Number of requests;Events", VariableType::kPerEvent, LogType::kLinear, -0.5, 149.5, 150);
  regHistogram("CachedROBSize_perEvent", "Cached ROB Size/Event;ROB size;Events", VariableType::kPerEvent, LogType::kLinear, 0, 1024, 50);
  regHistogram("NetworkROBSize_perEvent", "Network ROB Size/Event;ROB size;Events", VariableType::kPerEvent, LogType::kLinear, 0, 1024, 50);
  regHistogram("RequestTime_perEvent", "ROB Elapsed Time/Event;Elapsed Time [ms];Events", VariableType::kPerEvent);
}

◆ CounterChain() [3/4]

CounterChain::CounterChain	(	const std::string &	name,
		unsigned	nRos,
		const MonitorBase *	parent )

Construct counter.

Parameters

[in]	name	Counter's name
[in]	nRos	Number of possible ROSes
[in]	parent	Counter's parent monitor, cached non-owning pointer.

Definition at line 29 of file CounterChain.cxx.

  : CounterChain(name, parent)
{
  regTProfile("ROSRequests_perEvent", "Number of ROS requests;ROS names;Numer of requests to ROS per event", VariableType::kPerCall, LogType::kLinear, 0, nRos, nRos);
  regTProfile("NetworkROSRequests_perEvent", "Number of network ROS requests;ROS names;Numer of requests to ROS over the network per event", VariableType::kPerCall, LogType::kLinear, 0, nRos, nRos);
  regTProfile("ROBRequestsPerROS_perEvent", "Number of ROBs per ROS requests;ROS names;Numer of ROBs requested per request", VariableType::kPerCall, LogType::kLinear, 0, nRos, nRos);
  regTProfile("ROBRequestsPerROSPerEvent_perEvent", "Number of ROBs per ROS requests per event;ROS names;Numer of ROBs requested by ROS per event", VariableType::kPerCall, LogType::kLinear, 0, nRos, nRos);
}

◆ ~CounterChain()

virtual CounterChain::~CounterChain ( )

virtualdefault

Default destructor.

◆ CounterChain() [4/4]

CounterChain::CounterChain ( const CounterChain & )

delete

Forbid copy.

Member Function Documentation

◆ bookGetPointer()

TH1 * CounterBase::bookGetPointer	(	TH1 *	hist,
		const std::string &	tDir = "" ) const

protectedinherited

Appends Counter name (to histogram path) and forwards histogram book request to parent Monitor.

Parameters

[in]	hist	Bare pointer to histogram. Ownership transferred to THistSvc.
[in]	tDir	Histogram name & directory.

Returns: Cached pointer to histogram. Used to fill histogram without having to perform THishSvc lookup.

Definition at line 235 of file CounterBase.cxx.

                                                                       {
  std::string dir = getName();
  if (tDir != "") {
    dir += "/";
    dir += tDir;
  }
  return getParent()->bookGetPointer(hist, dir);
}

◆ endEvent()

StatusCode CounterBase::endEvent ( float weight = 1.0 )

virtualinherited

Called by the framework.

Causes per-Event Variables to fill their histograms with their accumulated data.

Definition at line 227 of file CounterBase.cxx.

                                      {
  for (auto& nameVariablePair : m_variables) {
    ATH_CHECK( nameVariablePair.second.endEvent() );
  }
  return StatusCode::SUCCESS;
}

◆ fill() [1/2]

StatusCode CounterBase::fill	(	std::string_view	name,
		float	value,
		float	weight = 1.0 )

inherited

Fill (for per-Call) or accumulate in a buffer (for per-Event) a quantity histogrammed by a named Variable.

Parameters

[in]	name	Variable to increment
[in]	value	The payload value
[in]	weight	Global event weight

Definition at line 193 of file CounterBase.cxx.

                                                                           {
  auto it = m_variables.find(name);
  if (it == m_variables.end()) {
    return StatusCode::FAILURE;
  }
  ATH_CHECK( it->second.fill(value, weight) );
  return StatusCode::SUCCESS;
}

◆ fill() [2/2]

StatusCode CounterBase::fill	(	std::string_view	name,
		float	xvalue,
		float	yvalue,
		float	weight )

inherited

Fill (for per-Call) or accumulate in a buffer (for per-Event) a quantity histogrammed by a named Variable.

Parameters

[in]	name	Variable to increment
[in]	xvalue	The payload x-axis value
[in]	yvalue	The payload y-axis value
[in]	weight	Global event weight

Definition at line 202 of file CounterBase.cxx.

                                                                                           {
  auto it = m_variables.find(name);
  if (it == m_variables.end()) {
    return StatusCode::FAILURE;
  }
  ATH_CHECK( it->second.fill(xvalue, yvalue, weight) );
  return StatusCode::SUCCESS;
}

◆ getName()

const std::string & CounterBase::getName ( ) const

inherited

Getter for Counter's name.

Returns: Counter's name const string reference.

Definition at line 19 of file CounterBase.cxx.

                                            {
  return m_name;
}

◆ getParent()

const MonitorBase * CounterBase::getParent ( ) const

inherited

Return cached non-owning const ptr to this Counter's parent Monitor.

Returns: Cached pointer parent Monitor.

Definition at line 24 of file CounterBase.cxx.

                                                {
  return m_parent;
}

◆ getVariable()

Variable & CounterBase::getVariable ( std::string_view name )

inherited

Returns a mutable reference to a named Variable.

Throws if no such Variable exists. Used when more complicated logic is needed on a Variable than simply using the fill() method.

Parameters

[in] name Variable to return

Returns: Mutable reference to Variable

Definition at line 184 of file CounterBase.cxx.

                                                      {
  auto it = m_variables.find(name);
  if (it == m_variables.end()) {
    throw std::runtime_error( std::format("CounterBase::getVariable: No variable with name {}", name) );
  }
  return (it->second);
}

◆ increment()

StatusCode CounterBase::increment	(	std::string_view	name,
		float	weight = 1.0 )

inherited

Convenience function.

Equivalent to fill(name, 1.0, weight);

Parameters

[in]	name	Variable to increment
[in]	weight	Global event weight

Definition at line 222 of file CounterBase.cxx.

                                                                   {
  return fill(name, 1.0, weight);
}

◆ newEvent()

StatusCode CounterChain::newEvent	(	const CostData &	data,
		size_t	index,
		const float	weight = 1. )

overridevirtual

Concrete implimentation.

Monitores chain at specified index. Expected to match this instances name().

Parameters

[in]	data	Access to event data
[in]	index	Index within appropriate event data container which is to be analysed by this Counter
[in]	weight	Global event weight

Implements CounterBase.

Definition at line 39 of file CounterChain.cxx.

                                                                                        {
 
  ATH_CHECK( increment("Chain_perEvent", weight) );
 
  if (!m_isInitialized && variableExists("ROSRequests_perEvent")) {
    // Set histograms labels
    for (const auto& rosToRobPair : data.costROSData().getROStoROBMap()) {
      int binForROS = data.costROSData().getBinForROS(rosToRobPair.first) + 1;
      ATH_CHECK( getVariable("ROSRequests_perEvent").setBinLabel(binForROS, rosToRobPair.first));
      ATH_CHECK( getVariable("NetworkROSRequests_perEvent").setBinLabel(binForROS, rosToRobPair.first));
      ATH_CHECK( getVariable("ROBRequestsPerROS_perEvent").setBinLabel(binForROS, rosToRobPair.first));
      ATH_CHECK( getVariable("ROBRequestsPerROSPerEvent_perEvent").setBinLabel(binForROS, rosToRobPair.first));
    }
 
    // Fill the bins with groups and add the labels
    int bin = 1;
    for (const std::string& group : data.seededChains()[index].groups){
      ATH_CHECK( getVariable("Group_perCall").setBinLabel(bin, group) );
      ATH_CHECK( getVariable("Group_perCall").fill(group, weight) );
      ++bin;
    }
 
    m_isInitialized = true;
  }
 
  if (data.seededChains()[index].isPassRaw){
    ATH_CHECK( increment("ChainPassed_perEvent", weight) );
  }
 
  // Monitor algorithms associated with chain name
  if (!data.chainToAlgMap().count(getName())) return StatusCode::SUCCESS;
 
  std::map<std::string, int> nRosPerEvent; // Accumulate how many times ROS was requested in a request per this event
  std::map<std::string, int> nNetworkRosPerEvent; // Accumulate how many times ROS was requested in a request per this event
  std::map<std::string, int> nRobsPerRosPerEvent; // Accumulate how many ROBs ROS requested per this event
  const std::string slotStr{"slot"};
  const std::string startStr{"start"};
  const std::string stopStr{"stop"};
  for (const size_t algIndex : data.chainToAlgMap().at(getName())){
    const xAOD::TrigComposite* alg = data.costCollection().at(algIndex);
    const uint32_t slot = alg->getDetail<uint32_t>(slotStr);
    if (slot != data.onlineSlot()) {
      continue; // When monitoring the master slot, this Monitor ignores algs running in different slots 
    }
 
    ATH_CHECK( increment("AlgCalls_perEvent", weight) );
 
    const uint64_t start = alg->getDetail<uint64_t>(startStr); // in mus
    const uint64_t stop  = alg->getDetail<uint64_t>(stopStr); // in mus
    const float cpuTime = timeToMilliSec(start, stop);
    ATH_CHECK( fill("Time_perEvent", cpuTime, weight) );
    ATH_CHECK( fill("Time_perCall", cpuTime, weight) );
 
    // Monitor data requests
    if (!data.algToRequestMap().count(algIndex)) continue;
    static const std::string idStr{"robs_id"};
    static const std::string historyStr{"robs_history"};
    static const std::string sizeStr{"robs_size"};
    for (size_t requestIdx : data.algToRequestMap().at(algIndex)) {
      const xAOD::TrigComposite* request = data.rosCollection().at(requestIdx);
      const std::vector<uint32_t> robIdsPerRequest = request->getDetail<std::vector<uint32_t>>(idStr);
      const std::vector<unsigned> robs_history = request->getDetail<std::vector<unsigned>>(historyStr);
      const std::vector<uint32_t> robs_size = request->getDetail<std::vector<uint32_t>>(sizeStr);
 
      std::map<std::string, int> nRobsPerRosPerRequest; // Accumulate how many ROBs ROS requested per request
 
      bool networkRequestIncremented = false;
      std::set<std::string> requestedROSes;
      std::set<std::string> requestedNetworkROSes;
      for (size_t i = 0; i < robs_size.size(); ++i) {
        // ROB request was fetched over the network
        if (robs_history[i] == robmonitor::RETRIEVED) {
          // size is stored in words, should be in kilobytes
          ATH_CHECK( fill("NetworkROBSize_perEvent", robs_size[i] / 500., weight) );
          networkRequestIncremented = true;
        }
        // ROB request was cached
        else if (robs_history[i] == robmonitor::HLT_CACHED || robs_history[i] == robmonitor::DCM_CACHED) {
          ATH_CHECK( fill("CachedROBSize_perEvent", robs_size[i] / 500., weight) );
        }
 
        uint32_t robId = robIdsPerRequest[i];
        if (variableExists("ROBRequestsPerROS_perEvent")){
          std::string rosForROB = data.costROSData().getROSForROB(robId);
          if (!rosForROB.empty()){
            requestedROSes.insert(rosForROB);
            nRobsPerRosPerRequest[rosForROB] += 1;
            nRobsPerRosPerEvent[rosForROB] += 1;
 
            if (robs_history[i] == robmonitor::RETRIEVED) {
              requestedNetworkROSes.insert(std::move(rosForROB));
            }
          }
        }
      }
 
      // Save number of ROBs per ROS per request
      for (const auto& robPerRosPair : nRobsPerRosPerRequest) {
        ATH_CHECK( fill("ROBRequestsPerROS_perEvent", data.costROSData().getBinForROS(robPerRosPair.first), robPerRosPair.second, weight) );
      }
 
      // Save the requested ROSes per request
      for (const std::string& rosName : requestedROSes){
          nRosPerEvent[rosName] += 1;
      }
    
      for (const std::string& rosName : requestedNetworkROSes){
          nNetworkRosPerEvent[rosName] += 1;
      }
 
      ATH_CHECK( increment("Request_perEvent", weight) );
 
      if (networkRequestIncremented) {
        ATH_CHECK( increment("NetworkRequest_perEvent", weight) );
      }
 
      const float rosTime = timeToMilliSec(request->getDetail<uint64_t>("start"), request->getDetail<uint64_t>("stop"));
      ATH_CHECK( fill("RequestTime_perEvent", rosTime, weight) );
    }
  }
 
  // Save the requested ROSes per event
  for (const auto& robPerRosPair : nRosPerEvent) {
    ATH_CHECK( fill("ROSRequests_perEvent", data.costROSData().getBinForROS(robPerRosPair.first), robPerRosPair.second, weight) );
  }
 
  for (const auto& robPerRosPair : nNetworkRosPerEvent) {
    ATH_CHECK( fill("NetworkROSRequests_perEvent", data.costROSData().getBinForROS(robPerRosPair.first), robPerRosPair.second, weight) );
  }
 
  // Save the number of ROBs per ROS per event
  for (const auto& robPerRosPair : nRobsPerRosPerEvent) {
    ATH_CHECK( fill("ROBRequestsPerROSPerEvent_perEvent", data.costROSData().getBinForROS(robPerRosPair.first), robPerRosPair.second, weight) );
  }
 
  // Monitor unique algorithms associated with chain name
  if (!data.chainToUniqAlgMap().count(getName())) return StatusCode::SUCCESS;
 
  for (const size_t algIndex : data.chainToUniqAlgMap().at(getName())){
    const xAOD::TrigComposite* alg = data.costCollection().at(algIndex);
    const uint32_t slot = alg->getDetail<uint32_t>(slotStr);
    if (slot != data.onlineSlot()) {
      continue;
    }
    const uint64_t start = alg->getDetail<uint64_t>(startStr); // in mus
    const uint64_t stop  = alg->getDetail<uint64_t>(stopStr); // in mus
    const float cpuTime = timeToMilliSec(start, stop);
 
    ATH_CHECK( fill("UniqueTime_perCall", cpuTime, weight) );
  }
 
  return StatusCode::SUCCESS;
}

◆ operator=()

CounterChain & CounterChain::operator= ( const CounterChain & )

delete

Forbid assignment.

◆ regHistogram() [1/2]

void CounterBase::regHistogram	(	const std::string &	name,
		const std::string &	title,
		const VariableType	type,
		const LogType	xaxis,
		const float	xmin,
		const float	xmax,
		const size_t	xbins,
		const LogType	yaxis,
		const float	ymin,
		const float	ymax,
		const size_t	ybins )

protectedinherited

Book a 2D histogram for this Counter, to be filled in per-event monitoring.

Parameters

[in]	name	The name of the histogram (and corresponding Variable)
[in]	title	ROOT histogram title string in format "title;xaxis;yaxis"
[in]	xaxis	Controls if the x-axis should use fixed-width or logarithmic bin boundaries.
[in]	xmin	X-axis minimum bound.
[in]	xmax	X-axis maximum bound.
[in]	xbins	Number of histogram bins.
[in]	yaxis	Controls if the y-axis should use fixed-width or logarithmic bin boundaries.
[in]	ymin	Y-axis minimum bound.
[in]	ymax	Y-axis maximum bound.
[in]	ybins	Number of histogram bins.

Definition at line 111 of file CounterBase.cxx.

{
  std::string hisSvcName = getParent()->getParent()->getName() + "_" + getParent()->getName() + "_" + getName() + "_" + name;
  std::unique_ptr<TH2F> hist;
 
  if (xmax <= xmin || ymax <= ymin || xbins == 0 || ybins == 0) {
    throw std::runtime_error("CounterBase::regHistogram: Cannot have max <= min or bins == 0");
  }
 
  if (xaxis == kLinear && yaxis == kLinear) {
    hist = std::make_unique<TH2F>(hisSvcName.c_str(), title.c_str(), xbins, xmin, xmax, ybins, ymin, ymax);
  } else if (xaxis == kLog || yaxis == kLog) {
    if ( (xaxis == kLog && xmin <= 0) || (yaxis == kLog && ymin <= 0) ) {
      throw std::runtime_error("CounterBase::regHistogram: Cannot have min <= 0 with log binning");
    }
    std::unique_ptr<double[]> xlogbins = std::make_unique<double[]>(xbins+1);
    std::unique_ptr<double[]> ylogbins = std::make_unique<double[]>(ybins+1);
    if (xaxis == kLog){
      const double xlogmin = log10(xmin);
      const double xlogmax = log10(xmax);
      const double dlogx   = (xlogmax-xlogmin)/((double)xbins);
      for (size_t i = 0; i <= xbins; ++i) { 
        const double xlog = xlogmin + i*dlogx;
        xlogbins[i] = exp( log(10) * xlog ); 
      }
    } else {
      const double dx = (xmax-xmin)/((double)xbins);
      for (size_t i = 0; i <= xbins; ++i) {
        xlogbins[i] = xmin + i*dx; 
      }
    }
 
    if (yaxis == kLog){
      const double ylogmin = log10(ymin);
      const double ylogmax = log10(ymax);
      const double dlogy   = (ylogmax-ylogmin)/((double)ybins);
      for (size_t i = 0; i <= ybins; ++i) { 
        const double ylog = ylogmin + i*dlogy;
        ylogbins[i] = exp( log(10) * ylog ); 
      }
    } else {
      const double dy = (ymax-ymin)/((double)ybins);
      for (size_t i = 0; i <= ybins; ++i) {
        ylogbins[i] = ymin + i*dy; 
      }
    }
 
    hist = std::make_unique<TH2F>(hisSvcName.c_str(), title.c_str(), xbins, xlogbins.get(), ybins, ylogbins.get());
  } else {
    throw std::runtime_error("CounterBase::regHistogram: Unknown logarithm flag");
  }
 
  m_variables.emplace(std::piecewise_construct,
    std::forward_as_tuple(name),
    std::forward_as_tuple(name, bookGetPointer(hist.release()), type)
  );
  // Histogram is now owned by THistSvc. A cache of the ptr is kept in the Variable
}

◆ regHistogram() [2/2]

void CounterBase::regHistogram	(	const std::string &	name,
		const std::string &	title,
		const VariableType	type = VariableType::kPerCall,
		const LogType	xaxis = kLog,
		const float	min = 0.1,
		const float	max = 1000000.,
		const size_t	bins = 70 )

protectedinherited

Book a histogram for this Counter, to be filled in per-event monitoring.

Parameters

[in]	name	The name of the histogram (and corresponding Variable)
[in]	title	ROOT histogram title string in format "title;xaxis;yaxis"
[in]	xaxis	Controls if the x-axis should use fixed-width or logarithmic bin boundaries.
[in]	min	X-axis minimum bound.
[in]	max	X-axis maximum bound.
[in]	bins	Number of histogram bins.

Definition at line 29 of file CounterBase.cxx.

{
  std::string hisSvcName = getParent()->getParent()->getName() + "_" + getParent()->getName() + "_" + getName() + "_" + name;
  std::unique_ptr<TH1F> hist;
 
  if (max <= min || bins == 0) {
    throw std::runtime_error("CounterBase::regHistogram: Cannot have max <= min or bins == 0");
  }
 
  if (xaxis == kLinear) {
    hist = std::make_unique<TH1F>(hisSvcName.c_str(), title.c_str(), bins, min, max);
  } else if (xaxis == kLog) {
    if (min <= 0) {
      throw std::runtime_error("CounterBase::regHistogram: Cannot have min <= 0 with log binning");
    }
    std::unique_ptr<double[]> xbins = std::make_unique<double[]>(bins+1);
    const double xlogmin = log10(min);
    const double xlogmax = log10(max);
    const double dlogx   = (xlogmax-xlogmin)/((double)bins);
    for (size_t i = 0; i <= bins; ++i) { 
      const double xlog = xlogmin + i*dlogx;
      xbins[i] = exp( log(10) * xlog ); 
    }
    hist = std::make_unique<TH1F>(hisSvcName.c_str(), title.c_str(), bins, xbins.get());
  } else {
    throw std::runtime_error("CounterBase::regHistogram: Unknown logarithm flag");
  }
 
  m_variables.emplace(std::piecewise_construct,
    std::forward_as_tuple(name),
    std::forward_as_tuple(name, bookGetPointer(hist.release()), type)
  );
  // Histogram is now owned by THistSvc. A cache of the ptr is kept in the Variable
}

◆ regTProfile()

void CounterBase::regTProfile	(	const std::string &	name,
		const std::string &	title,
		const VariableType	type = VariableType::kPerCall,
		const LogType	xaxis = kLog,
		const float	min = 0.1,
		const float	max = 1000000.,
		const size_t	bins = 70 )

protectedinherited

Book a TProfile for this Counter, to be filled in per-event monitoring.

Parameters

[in]	name	The name of the histogram (and corresponding Variable)
[in]	title	ROOT histogram title string in format "title;xaxis;yaxis"
[in]	xaxis	Controls if the x-axis should use fixed-width or logarithmic bin boundaries.
[in]	min	X-axis minimum bound.
[in]	max	X-axis maximum bound.
[in]	bins	Number of histogram bins.

Definition at line 70 of file CounterBase.cxx.

{
  std::string hisSvcName = getParent()->getParent()->getName() + "_" + getParent()->getName() + "_" + getName() + "_" + name;
  std::unique_ptr<TProfile> hist;
 
  if (max <= min || bins == 0) {
    throw std::runtime_error("CounterBase::regTProfile: Cannot have max <= min or bins == 0");
  }
 
  if (xaxis == kLinear) {
    hist = std::make_unique<TProfile>(hisSvcName.c_str(), title.c_str(), bins, min, max);
  } else if (xaxis == kLog) {
    if (min <= 0) {
      throw std::runtime_error("CounterBase::regTProfile: Cannot have min <= 0 with log binning");
    }
    std::unique_ptr<double[]> xbins = std::make_unique<double[]>(bins+1);
    const double xlogmin = log10(min);
    const double xlogmax = log10(max);
    const double dlogx   = (xlogmax-xlogmin)/((double)bins);
    for (size_t i = 0; i <= bins; ++i) { 
      const double xlog = xlogmin + i*dlogx;
      xbins[i] = exp( log(10) * xlog ); 
    }
    hist = std::make_unique<TProfile>(hisSvcName.c_str(), title.c_str(), bins, xbins.get());
  } else {
    throw std::runtime_error("CounterBase::regTProfile: Unknown logarithm flag");
  }
 
  m_variables.emplace(std::piecewise_construct,
    std::forward_as_tuple(name),
    std::forward_as_tuple(name, bookGetPointer(hist.release()), type)
  );
  // Histogram is now owned by THistSvc. A cache of the ptr is kept in the Variable
}

◆ setDenominator()

StatusCode CounterBase::setDenominator	(	const std::string &	name,
		float	value )

inherited

Optional for per-Event Variables.

Sets a denominator to divide the value through by before filling.

Parameters

[in]	name	Variable to set the denominator for.
[in]	value	The denominator

Definition at line 212 of file CounterBase.cxx.

                                                                         {
  auto it = m_variables.find(name);
  if (it == m_variables.end()) {
    return StatusCode::FAILURE;
  }
  it->second.setDenominator(value);
  return StatusCode::SUCCESS;
}

◆ timeToMilliSec()

float CounterBase::timeToMilliSec	(	const uint64_t	start,
		const uint64_t	stop ) const

protectedinherited

Helper function.

Compute the time difference in discreet microseconds and covert to fractional milliseconds.

Returns: Time difference in milliseconds, floating point.

Definition at line 245 of file CounterBase.cxx.

                                                                                 {
  if (stop < start) {
    throw std::runtime_error("Asked for a stop time " + std::to_string(stop) + " which is before the start time " + std::to_string(start));
  }
  const uint64_t difference = stop - start;
  return (difference * 1e-3); // micro to ms
}

◆ variableExists()

bool CounterBase::variableExists ( const std::string & name ) const

inherited

Check if a variable of a given name exists.

Parameters

[in] name Name of Variable.

Returns: True if variable already exists.

Definition at line 180 of file CounterBase.cxx.

                                                            {
  return m_variables.contains(name);
}

Member Data Documentation

◆ m_isInitialized

bool CounterChain::m_isInitialized {}

private

Definition at line 60 of file CounterChain.h.

60{};

◆ m_name

const std::string CounterBase::m_name

privateinherited

Counter's name.

Definition at line 210 of file CounterBase.h.

◆ m_parent

const MonitorBase* CounterBase::m_parent {}

privateinherited

Counter's parent Monitor.

Cached non-owning const pointer.

Definition at line 211 of file CounterBase.h.

211{};

◆ m_variables

std::unordered_map< std::string, Variable, CxxUtils::TransparentStringHash, std::equal_to<> > CounterBase::m_variables

privateinherited

Store of Counter's Variables.

These wrap a histogram pointer. Keyed by name.

Definition at line 212 of file CounterBase.h.

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

Public Member Functions

Protected Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CounterChain() [1/4]

◆ CounterChain() [2/4]

◆ CounterChain() [3/4]

◆ ~CounterChain()

◆ CounterChain() [4/4]

Member Function Documentation

◆ bookGetPointer()

◆ endEvent()

◆ fill() [1/2]

◆ fill() [2/2]

◆ getName()

◆ getParent()

◆ getVariable()

◆ increment()

◆ newEvent()

◆ operator=()

◆ regHistogram() [1/2]

◆ regHistogram() [2/2]

◆ regTProfile()

◆ setDenominator()

◆ timeToMilliSec()

◆ variableExists()

Member Data Documentation

◆ m_isInitialized

◆ m_name

◆ m_parent

◆ m_variables