Monitored::Scalar< T > Class Template Reference

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 More...
virtual size_t	size () const override
	gives size of vector representation More...
const std::string &	name () const
Client API
	Scalar (std::string name, const T &defaultValue={})
	Scalar with optional default value. More...
	Scalar (std::string name, const T &defaultValue, std::function< double(const T &)> valueTransform)
	Scalar with default value and optional transformation applied before filling. More...
	Scalar (std::string name, std::function< T()> generator)
	Scalar with generator function to retrieve the value. More...

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

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 101 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 109 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 116 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.

{ return m_name; }

operator const T &()

template<class T >

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

inline

Definition at line 98 of file MonitoredScalar.h.

{ return m_value; }

operator T&()

template<class T >

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

inline

Definition at line 99 of file MonitoredScalar.h.

{ 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 120 of file MonitoredScalar.h.

                                         {
      return 1;
    }

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 125 of file MonitoredScalar.h.

m_valueGenerator

template<class T >

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

private

Definition at line 127 of file MonitoredScalar.h.

m_valueTransform

template<class T >

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

private

Definition at line 126 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