Declare a monitored scalar variable. More...

#include <MonitoredScalar.h>

Inheritance diagram for Monitored::Scalar< T >:

Collaboration diagram for Monitored::Scalar< T >:

Public Member Functions
	Scalar (Scalar &&)=default
	Scalar (Scalar const &)=delete
Scalar &	operator= (Scalar const &)=delete
T	operator= (T value)
	operator const T & () const
	operator T& ()
virtual double	get (size_t) const override
virtual std::string	getString (size_t) const override
virtual bool	hasStringRepresentation () const override
	indcates that the stored content can be converted to strings
virtual size_t	size () const override
	gives size of vector representation
const std::string &	name () const
Client API
	Scalar (std::string name, const T &defaultValue={})
	Scalar with optional default value.
	Scalar (std::string name, const T &defaultValue, std::function< double(const T &)> valueTransform)
	Scalar with default value and optional transformation applied before filling.
	Scalar (std::string name, std::function< T()> generator)
	Scalar with generator function to retrieve the value.

Public Attributes
friend	MonitoredGroup

Private Attributes
T	m_value {}
std::function< double(const T &)>	m_valueTransform
std::function< T()>	m_valueGenerator
const std::string	m_name

Friends
std::string	operator+ (const Scalar &lhs, const std::string &rhs)
std::string	operator+ (const std::string &lhs, const Scalar &rhs)

Detailed Description

template<class T>
class Monitored::Scalar< T >

Declare a monitored scalar variable.

A monitored Scalar behaves similar to a regular builtin type:

Template Parameters

T	Type of scalar (convertable to double or string)

Examples:

auto eta = Monitored::Scalar( "Eta", -3. );

eta = 0.6;

auto count = Monitored::Scalar<float>( "Count", 0 );

bool comparisonResult = count == count;

  count += 1;
  count++;
  --count;
  count *= 3;

In case of std::string an alphanumeric histogram fill will be performed:

    auto det = Monitored::Scalar<std::string>( "DetID", "SCT" );
    Monitored::Group(monTool, det);
    det = "PIX";
    Monitored::Group(monTool, det);

See also: Monitored::Collection; Monitored::Timer

Definition at line 34 of file MonitoredScalar.h.

Constructor & Destructor Documentation

◆ Scalar() [1/5]

template<class T>

Monitored::Scalar< T >::Scalar	(	std::string	name,
		const T &	defaultValue = {} )

inline

Scalar with optional default value.

Parameters

name	Name of monitored quantity
defaultValue	Optional default value

Example

    auto eta = Monitored::Scalar<double>( "Eta" ); //explicit double
    auto phi = Monitored::Scalar( "Phi", -99.0 );  //deduced double
    auto group = Monitored::Group( monTool, eta, phi );
    phi = 0.1;
    eta = -0.2;

Definition at line 50 of file MonitoredScalar.h.

                                                   {}) :
        IMonitoredVariable(std::move(name)),
        m_value(defaultValue)
    {}

◆ Scalar() [2/5]

template<class T>

Monitored::Scalar< T >::Scalar	(	std::string	name,
		const T &	defaultValue,
		std::function< double(const T &)>	valueTransform )

inline

Scalar with default value and optional transformation applied before filling.

Parameters

name	Name of monitored quantity
defaultValue	Default value assigned to the monitored scalar
valueTransform	Optional transformation applied to value before filling

Example

// Take absolute value before filling

auto phi = Monitored::Scalar<double>( "Phi", -3.0, [](double d){ return fabs(d); } );

Definition at line 65 of file MonitoredScalar.h.

                                                                                                :
        IMonitoredVariable(std::move(name)),
        m_value(defaultValue),
        m_valueTransform(std::move(valueTransform))
    {}

◆ Scalar() [3/5]

template<class T>

Monitored::Scalar< T >::Scalar	(	std::string	name,
		std::function< T()>	generator )

inline

Scalar with generator function to retrieve the value.

Parameters

name	Name of monitored quantity
generator	Function returning the monitored value

Example

std::vector<float> v{1,2,3};

auto eta = Monitored::Scalar<int>( "Eta", [&](){ return v.size(); } );

Definition at line 80 of file MonitoredScalar.h.

                                                       :
      IMonitoredVariable(std::move(name)),
      m_valueGenerator(std::move(generator))
    {}

◆ Scalar() [4/5]

template<class T>

Monitored::Scalar< T >::Scalar ( Scalar< T > && )

default

◆ Scalar() [5/5]

template<class T>

Monitored::Scalar< T >::Scalar ( Scalar< T > const & )

delete

Member Function Documentation

◆ get()

template<class T>

virtual double Monitored::Scalar< T >::get ( size_t ) const

inlineoverridevirtual

Implements Monitored::IMonitoredVariable.

Definition at line 110 of file MonitoredScalar.h.

                                              {
      if constexpr (std::is_convertible_v<double, T>) {
        return (m_valueGenerator ? static_cast<double>(m_valueGenerator()) :
                m_valueTransform ? m_valueTransform(m_value) : static_cast<double>(m_value));
      }
      else return 0;
    }

◆ getString()

template<class T>

virtual std::string Monitored::Scalar< T >::getString ( size_t ) const

inlineoverridevirtual

Implements Monitored::IMonitoredVariable.

Definition at line 118 of file MonitoredScalar.h.

                                                       {
      if constexpr (std::is_constructible_v<std::string, T>) {
        return (m_valueGenerator ? m_valueGenerator() : m_value);
      }
      else return {};
    }

◆ hasStringRepresentation()

template<class T>

virtual bool Monitored::Scalar< T >::hasStringRepresentation ( ) const

inlineoverridevirtual

indcates that the stored content can be converted to strings

Implements Monitored::IMonitoredVariable.

Definition at line 125 of file MonitoredScalar.h.

                                                          {
      return std::is_constructible<std::string, T>::value;
    }

◆ name()

const std::string & Monitored::IMonitoredVariable::name ( ) const

inlineinherited

Definition at line 19 of file IMonitoredVariable.h.

19{ return m_name; }

Monitored::IMonitoredVariable::m_name

const std::string m_name

Definition IMonitoredVariable.h:31

◆ operator const T &()

template<class T>

Monitored::Scalar< T >::operator const T & ( ) const

inline

Definition at line 98 of file MonitoredScalar.h.

98{ return m_value; }

◆ operator T&()

template<class T>

Monitored::Scalar< T >::operator T& ( )

inline

Definition at line 99 of file MonitoredScalar.h.

99{ return m_value; }

◆ operator=() [1/2]

template<class T>

Scalar & Monitored::Scalar< T >::operator= ( Scalar< T > const & )

delete

◆ operator=() [2/2]

template<class T>

T Monitored::Scalar< T >::operator= ( T value )

inline

Definition at line 92 of file MonitoredScalar.h.

    {
      m_value = value;
      return value;
    }

◆ size()

template<class T>

virtual size_t Monitored::Scalar< T >::size ( ) const

inlineoverridevirtual

gives size of vector representation

Implements Monitored::IMonitoredVariable.

Definition at line 129 of file MonitoredScalar.h.

                                         {
      return 1;
    }

◆ operator+ [1/2]

template<class T>

std::string operator+	(	const Scalar< T > &	lhs,
		const std::string &	rhs )

friend

Definition at line 102 of file MonitoredScalar.h.

                                                                        {
      return lhs.m_value + rhs;
    }

◆ operator+ [2/2]

template<class T>

std::string operator+	(	const std::string &	lhs,
		const Scalar< T > &	rhs )

friend

Definition at line 106 of file MonitoredScalar.h.

                                                                        {
      return lhs + rhs.m_value;
    }

Member Data Documentation

◆ m_name

const std::string Monitored::IMonitoredVariable::m_name

privateinherited

Definition at line 31 of file IMonitoredVariable.h.

◆ m_value

template<class T>

T Monitored::Scalar< T >::m_value {}

private

Definition at line 134 of file MonitoredScalar.h.

134{};

◆ m_valueGenerator

template<class T>

std::function<T()> Monitored::Scalar< T >::m_valueGenerator

private

Definition at line 136 of file MonitoredScalar.h.

◆ m_valueTransform

template<class T>

std::function<double(const T&)> Monitored::Scalar< T >::m_valueTransform

private

Definition at line 135 of file MonitoredScalar.h.

◆ MonitoredGroup

friend Monitored::IMonitoredVariable::MonitoredGroup

inherited

Definition at line 16 of file IMonitoredVariable.h.

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

MonitoredScalar.h

Public Member Functions

Public Attributes

Private Attributes

Friends

Detailed Description

Examples:

Constructor & Destructor Documentation

◆ Scalar() [1/5]

Example

◆ Scalar() [2/5]

Example

◆ Scalar() [3/5]

Example

◆ Scalar() [4/5]

◆ Scalar() [5/5]

Member Function Documentation

◆ get()

◆ getString()

◆ hasStringRepresentation()

◆ name()

◆ operator const T &()

◆ operator T&()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ size()

Friends And Related Symbol Documentation

◆ operator+ [1/2]

◆ operator+ [2/2]

Member Data Documentation

◆ m_name

◆ m_value

◆ m_valueGenerator

◆ m_valueTransform

◆ MonitoredGroup