Gaudi::TestSuite::Counter::GaudiHistoAlgorithm Class Reference

Example of algorithm using histograms accumulators. More...

Inheritance diagram for Gaudi::TestSuite::Counter::GaudiHistoAlgorithm:

Collaboration diagram for Gaudi::TestSuite::Counter::GaudiHistoAlgorithm:

Public Types
using	Base = FSMCallbackHolder<Gaudi::Algorithm>
Public Types inherited from Gaudi::FSMCallbackHolder< Gaudi::Algorithm >
using	Parent
Public Types inherited from extends< BASE, Interfaces >
using	base_class = extends
	Typedef to this class.
using	extend_interfaces_base = extend_interfaces<Interfaces...>
	Typedef to the base of this class.
Public Types inherited from extend_interfaces< Interfaces... >
using	ext_iids
	take union of the ext_iids of all Interfaces...

Public Member Functions
StatusCode	initialize () override
StatusCode	execute (const EventContext &) const override
Public Member Functions inherited from Gaudi::FSMCallbackHolder< Gaudi::Algorithm >
void	registerCallBack (StateMachine::Transition s, IFSMCallbackHolder::CallBack c) override
StatusCode	sysInitialize () override
StatusCode	sysStart () override
StatusCode	sysStop () override
StatusCode	sysFinalize () override
Public Member Functions inherited from extends< BASE, Interfaces >
void const *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast.
StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface.
std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames.

Private Attributes
Gaudi::Accumulators::Counter	m_nCalls { this, "calls" }
Gaudi::Accumulators::StaticHistogram< 1 >	m_empty1D
Gaudi::Accumulators::StaticHistogram< 2 >	m_empty2D
Gaudi::Accumulators::StaticHistogram< 3 >	m_empty3D
Gaudi::Accumulators::StaticHistogram< 1 >	m_gauss
Gaudi::Accumulators::StaticHistogram< 2 >	m_gaussVflat
Gaudi::Accumulators::StaticHistogram< 3 >	m_gaussVflatVgauss
Gaudi::Accumulators::StaticHistogram< 1, Gaudi::Accumulators::atomicity::none >	m_gauss_noato
Gaudi::Accumulators::StaticHistogram< 2, Gaudi::Accumulators::atomicity::none >	m_gaussVflat_noato
Gaudi::Accumulators::StaticHistogram< 3, Gaudi::Accumulators::atomicity::none >	m_gaussVflatVgauss_noato
Gaudi::Accumulators::StaticHistogram< 1, Gaudi::Accumulators::atomicity::full, int >	m_gauss_int
Gaudi::Accumulators::StaticHistogram< 2, Gaudi::Accumulators::atomicity::full, int >	m_gaussVflat_int
Gaudi::Accumulators::StaticHistogram< 3, Gaudi::Accumulators::atomicity::full, int >	m_gaussVflatVgauss_int
Gaudi::Accumulators::StaticWeightedHistogram< 1 >	m_gauss_w
Gaudi::Accumulators::StaticWeightedHistogram< 2 >	m_gaussVflat_w
Gaudi::Accumulators::StaticWeightedHistogram< 3 >	m_gaussVflatVgauss_w
Gaudi::Accumulators::StaticHistogram< 1 >	m_gauss_buf
Gaudi::Accumulators::StaticHistogram< 2 >	m_gaussVflat_buf
Gaudi::Accumulators::StaticHistogram< 3 >	m_gaussVflatVgauss_buf
Gaudi::Accumulators::StaticProfileHistogram< 1 >	m_prof_gauss
Gaudi::Accumulators::StaticProfileHistogram< 2 >	m_prof_gaussVflat
Gaudi::Accumulators::StaticProfileHistogram< 3 >	m_prof_gaussVflatVgauss
Gaudi::Accumulators::StaticProfileHistogram< 1, Gaudi::Accumulators::atomicity::none >	m_prof_gauss_noato
Gaudi::Accumulators::StaticProfileHistogram< 2, Gaudi::Accumulators::atomicity::none >	m_prof_gaussVflat_noato
Gaudi::Accumulators::StaticProfileHistogram< 3, Gaudi::Accumulators::atomicity::none >	m_prof_gaussVflatVgauss_noato
Gaudi::Accumulators::StaticProfileHistogram< 1, Gaudi::Accumulators::atomicity::full, int >	m_prof_gauss_int
Gaudi::Accumulators::StaticProfileHistogram< 2, Gaudi::Accumulators::atomicity::full, int >	m_prof_gaussVflat_int
Gaudi::Accumulators::StaticProfileHistogram< 3, Gaudi::Accumulators::atomicity::full, int >	m_prof_gaussVflatVgauss_int
Gaudi::Accumulators::StaticWeightedProfileHistogram< 1 >	m_prof_gauss_w
Gaudi::Accumulators::StaticWeightedProfileHistogram< 2 >	m_prof_gaussVflat_w
Gaudi::Accumulators::StaticWeightedProfileHistogram< 3 >	m_prof_gaussVflatVgauss_w
Gaudi::Accumulators::StaticProfileHistogram< 1 >	m_prof_gauss_buf
Gaudi::Accumulators::StaticProfileHistogram< 2 >	m_prof_gaussVflat_buf
Gaudi::Accumulators::StaticProfileHistogram< 3 >	m_prof_gaussVflatVgauss_buf
Accumulators::LogHistogram< 1 >	m_log_gauss { this, "LogGauss", "Log, Gaussian", { 5, 0, 2 } }
Accumulators::LogHistogram< 2, Accumulators::atomicity::full, float >	m_log_gaussVflat
Gaudi::Accumulators::StaticHistogram< 1 >	m_gaussAbsName
Gaudi::Accumulators::Histogram< 1 >	m_custom_gauss_noprop
Gaudi::Accumulators::Histogram< 1 >	m_custom_gauss { this, "CustomGauss" }
Gaudi::Accumulators::Histogram< 2 >	m_custom_gaussVflat { this, "CustomGaussFlat" }
Gaudi::Accumulators::Histogram< 3 >	m_custom_gaussVflatVgauss { this, "CustomGaussFlatGauss" }
Gaudi::Accumulators::WeightedHistogram< 1 >	m_custom_gauss_w { this, "CustomGaussW" }
Gaudi::Accumulators::WeightedHistogram< 2 >	m_custom_gaussVflat_w { this, "CustomGaussFlatW" }
Gaudi::Accumulators::WeightedHistogram< 3 >	m_custom_gaussVflatVgauss_w { this, "CustomGaussFlatGaussW" }
Gaudi::Accumulators::ProfileHistogram< 1 >	m_custom_prof_gauss { this, "CustomProfGauss" }
Gaudi::Accumulators::ProfileHistogram< 2 >	m_custom_prof_gaussVflat { this, "CustomProfGaussFlat" }
Gaudi::Accumulators::ProfileHistogram< 3 >	m_custom_prof_gaussVflatVgauss
Gaudi::Accumulators::WeightedProfileHistogram< 1 >	m_custom_prof_gauss_w { this, "CustomProfGaussW" }
Gaudi::Accumulators::WeightedProfileHistogram< 2 >	m_custom_prof_gaussVflat_w
Gaudi::Accumulators::WeightedProfileHistogram< 3 >	m_custom_prof_gaussVflatVgauss_w
Gaudi::Accumulators::Histogram< 1 >	m_custom_gauss_noinit { this, "CustomGaussNoInit", "", {}, true }

Detailed Description

Example of algorithm using histograms accumulators.

Definition at line 77 of file CounterHistos.cpp.

Member Typedef Documentation

Base

using Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::Base = FSMCallbackHolder<Gaudi::Algorithm>

Definition at line 79 of file CounterHistos.cpp.

Member Function Documentation

execute()

StatusCode Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::execute ( const EventContext & ) const

inlineoverride

Definition at line 86 of file CounterHistos.cpp.

                                                                 {
          // some random number generators, just to provide numbers
          static Rndm::Numbers Gauss( randSvc(), Rndm::Gauss( 0.0, 1.0 ) );
          static Rndm::Numbers Flat( randSvc(), Rndm::Flat( -10.0, 10.0 ) );
          static Rndm::Numbers Gauss3( randSvc(), Rndm::Gauss( 5.0, 1.0 ) );
 
          // cache some numbers
          const double gauss( Gauss() );
          const double gauss2( Gauss() );
          const double flat( Flat() );
          const double gauss3( Gauss3() );
 
          // updating histograms
          ++m_gauss[gauss];
          ++m_gaussAbsName[gauss];
          ++m_gaussVflat[{ flat, gauss }];
          ++m_gaussVflatVgauss[{ flat, gauss, gauss2 }];
          ++m_gauss_noato[gauss];
          ++m_gaussVflat_noato[{ flat, gauss }];
          ++m_gaussVflatVgauss_noato[{ flat, gauss, gauss2 }];
          ++m_gauss_int[(int)gauss];
          ++m_gaussVflat_int[{ (int)flat, (int)gauss }];
          ++m_gaussVflatVgauss_int[{ (int)flat, (int)gauss, (int)gauss2 }];
 
          // weighted cases
          m_gauss_w[gauss] += .5;
          m_gaussVflat_w[{ flat, gauss }] += .5;
          m_gaussVflatVgauss_w[{ flat, gauss, gauss2 }] += .5;
 
          // using buffers
          auto gauss_buf            = m_gauss_buf.buffer();
          auto gaussVflat_buf       = m_gaussVflat_buf.buffer();
          auto gaussVflatVgauss_buf = m_gaussVflatVgauss_buf.buffer();
          for ( unsigned int i = 0; i < 10; i++ ) {
            ++gauss_buf[gauss];
            ++gaussVflat_buf[{ flat, gauss }];
            ++gaussVflatVgauss_buf[{ flat, gauss, gauss2 }];
          }
 
          // updating profile histograms
          m_prof_gauss[gauss] += gauss3;
          m_prof_gaussVflat[{ flat, gauss }] += gauss3;
          m_prof_gaussVflatVgauss[{ flat, gauss, gauss2 }] += gauss3;
          m_prof_gauss_noato[gauss] += gauss3;
          m_prof_gaussVflat_noato[{ flat, gauss }] += gauss3;
          m_prof_gaussVflatVgauss_noato[{ flat, gauss, gauss2 }] += gauss3;
          m_prof_gauss_int[(int)gauss] += (int)gauss3;
          m_prof_gaussVflat_int[{ (int)flat, (int)gauss }] += (int)gauss3;
          m_prof_gaussVflatVgauss_int[{ (int)flat, (int)gauss, (int)gauss2 }] += (int)gauss3;
 
          // weighted profile histograms
          m_prof_gauss_w[gauss] += { gauss3, .5 };
          m_prof_gaussVflat_w[{ flat, gauss }] += { gauss3, .5 };
          m_prof_gaussVflatVgauss_w[{ flat, gauss, gauss2 }] += { gauss3, .5 };
 
          // using buffers on profile histograms
          auto prof_gauss_buf            = m_prof_gauss_buf.buffer();
          auto prof_gaussVflat_buf       = m_prof_gaussVflat_buf.buffer();
          auto prof_gaussVflatVgauss_buf = m_prof_gaussVflatVgauss_buf.buffer();
          for ( unsigned int i = 0; i < 10; i++ ) {
            prof_gauss_buf[gauss] += gauss3;
            prof_gaussVflat_buf[{ flat, gauss }] += gauss3;
            prof_gaussVflatVgauss_buf[{ flat, gauss, gauss2 }] += gauss3;
          }
 
          // using CaloHistogram
          m_log_gauss[gauss]++;
          m_log_gaussVflat[{ flat, gauss }]++;
 
          // using Custom histograms, with title and axis defined in python
          ++m_custom_gauss_noprop[gauss];
          ++m_custom_gauss[gauss];
          ++m_custom_gaussVflat[{ flat, gauss }];
          ++m_custom_gaussVflatVgauss[{ flat, gauss, gauss2 }];
          m_custom_gauss_w[gauss] += .5;
          m_custom_gaussVflat_w[{ flat, gauss }] += .5;
          m_custom_gaussVflatVgauss_w[{ flat, gauss, gauss2 }] += .5;
          m_custom_prof_gauss[gauss] += gauss3;
          m_custom_prof_gaussVflat[{ flat, gauss }] += gauss3;
          m_custom_prof_gaussVflatVgauss[{ flat, gauss, gauss2 }] += gauss3;
          m_custom_prof_gauss_w[gauss] += { gauss3, .5 };
          m_custom_prof_gaussVflat_w[{ flat, gauss }] += { gauss3, .5 };
          m_custom_prof_gaussVflatVgauss_w[{ flat, gauss, gauss2 }] += { gauss3, .5 };
          ++m_custom_gauss_noinit[gauss];
 
          if ( m_nCalls.nEntries() == 0 ) always() << "Filling Histograms...... Please be patient !" << endmsg;
          ++m_nCalls;
          return StatusCode::SUCCESS;
        }

initialize()

StatusCode Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::initialize ( )

inlineoverride

Definition at line 82 of file CounterHistos.cpp.

                                         {
          return Base::initialize().andThen( [&] { m_custom_gauss_noinit.createHistogram( *this ); } );
        }

Member Data Documentation

m_custom_gauss

Gaudi::Accumulators::Histogram<1> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_custom_gauss { this, "CustomGauss" }

mutableprivate

Definition at line 318 of file CounterHistos.cpp.

{ this, "CustomGauss" };

m_custom_gauss_noinit

Gaudi::Accumulators::Histogram<1> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_custom_gauss_noinit { this, "CustomGaussNoInit", "", {}, true }

mutableprivate

Definition at line 338 of file CounterHistos.cpp.

{ this, "CustomGaussNoInit", "", {}, true };

m_custom_gauss_noprop

Gaudi::Accumulators::Histogram<1> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_custom_gauss_noprop

mutableprivate

Initial value:

{
            this, "CustomGaussNoProp", "Gaussian mean=0, sigma=1, atomic", { 100, -5, 5, "X" } }

Definition at line 316 of file CounterHistos.cpp.

                                                                   {
            this, "CustomGaussNoProp", "Gaussian mean=0, sigma=1, atomic", { 100, -5, 5, "X" } };

m_custom_gauss_w

Gaudi::Accumulators::WeightedHistogram<1> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_custom_gauss_w { this, "CustomGaussW" }

mutableprivate

Definition at line 322 of file CounterHistos.cpp.

{ this, "CustomGaussW" };

m_custom_gaussVflat

Gaudi::Accumulators::Histogram<2> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_custom_gaussVflat { this, "CustomGaussFlat" }

mutableprivate

Definition at line 319 of file CounterHistos.cpp.

{ this, "CustomGaussFlat" };

m_custom_gaussVflat_w

Gaudi::Accumulators::WeightedHistogram<2> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_custom_gaussVflat_w { this, "CustomGaussFlatW" }

mutableprivate

Definition at line 323 of file CounterHistos.cpp.

{ this, "CustomGaussFlatW" };

m_custom_gaussVflatVgauss

Gaudi::Accumulators::Histogram<3> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_custom_gaussVflatVgauss { this, "CustomGaussFlatGauss" }

mutableprivate

Definition at line 320 of file CounterHistos.cpp.

{ this, "CustomGaussFlatGauss" };

m_custom_gaussVflatVgauss_w

Gaudi::Accumulators::WeightedHistogram<3> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_custom_gaussVflatVgauss_w { this, "CustomGaussFlatGaussW" }

mutableprivate

Definition at line 324 of file CounterHistos.cpp.

{ this, "CustomGaussFlatGaussW" };

m_custom_prof_gauss

Gaudi::Accumulators::ProfileHistogram<1> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_custom_prof_gauss { this, "CustomProfGauss" }

mutableprivate

Definition at line 326 of file CounterHistos.cpp.

{ this, "CustomProfGauss" };

m_custom_prof_gauss_w

Gaudi::Accumulators::WeightedProfileHistogram<1> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_custom_prof_gauss_w { this, "CustomProfGaussW" }

mutableprivate

Definition at line 331 of file CounterHistos.cpp.

{ this, "CustomProfGaussW" };

m_custom_prof_gaussVflat

Gaudi::Accumulators::ProfileHistogram<2> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_custom_prof_gaussVflat { this, "CustomProfGaussFlat" }

mutableprivate

Definition at line 327 of file CounterHistos.cpp.

{ this, "CustomProfGaussFlat" };

m_custom_prof_gaussVflat_w

Gaudi::Accumulators::WeightedProfileHistogram<2> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_custom_prof_gaussVflat_w

mutableprivate

Initial value:

{ this,
                                                                                             "CustomProfGaussFlatW" }

Definition at line 332 of file CounterHistos.cpp.

                                                                                       { this,
                                                                                             "CustomProfGaussFlatW" };

m_custom_prof_gaussVflatVgauss

Gaudi::Accumulators::ProfileHistogram<3> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_custom_prof_gaussVflatVgauss

mutableprivate

Initial value:

{ this,
                                                                                         "CustomProfGaussFlatGauss" }

Definition at line 328 of file CounterHistos.cpp.

                                                                                   { this,
                                                                                         "CustomProfGaussFlatGauss" };

m_custom_prof_gaussVflatVgauss_w

Gaudi::Accumulators::WeightedProfileHistogram<3> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_custom_prof_gaussVflatVgauss_w

mutableprivate

Initial value:

{
            this, "CustomProfGaussFlatGaussW" }

Definition at line 334 of file CounterHistos.cpp.

                                                                                             {
            this, "CustomProfGaussFlatGaussW" };

m_empty1D

Gaudi::Accumulators::StaticHistogram<1> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_empty1D

mutableprivate

Initial value:

{
            this, "Empty1D", "Empty 1D histogram", { 100, -5, 5, "X" } }

Definition at line 182 of file CounterHistos.cpp.

                                                             {
            this, "Empty1D", "Empty 1D histogram", { 100, -5, 5, "X" } };

m_empty2D

Gaudi::Accumulators::StaticHistogram<2> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_empty2D

mutableprivate

Initial value:

{
            this, "Empty2D", "Empty 2D histogram", { { 50, -5, 5, "X" }, { 50, -5, 5, "Y" } } }

Definition at line 184 of file CounterHistos.cpp.

                                                             {
            this, "Empty2D", "Empty 2D histogram", { { 50, -5, 5, "X" }, { 50, -5, 5, "Y" } } };

m_empty3D

Gaudi::Accumulators::StaticHistogram<3> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_empty3D

mutableprivate

Initial value:

{
            this, "Empty3D", "Empty 3D histogram", { { 10, -5, 5, "X" }, { 10, -5, 5, "Y" }, { 10, -5, 5, "Z" } } }

Definition at line 186 of file CounterHistos.cpp.

                                                             {
            this, "Empty3D", "Empty 3D histogram", { { 10, -5, 5, "X" }, { 10, -5, 5, "Y" }, { 10, -5, 5, "Z" } } };

m_gauss

Gaudi::Accumulators::StaticHistogram<1> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_gauss

mutableprivate

Initial value:

{
            this, "Gauss", "Gaussian mean=0, sigma=1, atomic", { 100, -5, 5, "X" } }

Definition at line 190 of file CounterHistos.cpp.

                                                           {
            this, "Gauss", "Gaussian mean=0, sigma=1, atomic", { 100, -5, 5, "X" } };

m_gauss_buf

Gaudi::Accumulators::StaticHistogram<1> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_gauss_buf

mutableprivate

Initial value:

{
            this, "GaussBuf", "Gaussian mean=0, sigma=1, buffered", { 100, -5, 5 } }

Definition at line 234 of file CounterHistos.cpp.

                                                               {
            this, "GaussBuf", "Gaussian mean=0, sigma=1, buffered", { 100, -5, 5 } };

m_gauss_int

Gaudi::Accumulators::StaticHistogram<1, Gaudi::Accumulators::atomicity::full, int> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_gauss_int

mutableprivate

Initial value:

{
            this, "GaussInt", "Gaussian mean=0, sigma=1, integer values", { 10, -5, 5 } }

Definition at line 212 of file CounterHistos.cpp.

                                                                                                    {
            this, "GaussInt", "Gaussian mean=0, sigma=1, integer values", { 10, -5, 5 } };

m_gauss_noato

Gaudi::Accumulators::StaticHistogram<1, Gaudi::Accumulators::atomicity::none> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_gauss_noato

mutableprivate

Initial value:

{
            this, "GaussNA", "Gaussian mean=0, sigma=1, non atomic", { 100, -5, 5 } }

Definition at line 201 of file CounterHistos.cpp.

                                                                                                 {
            this, "GaussNA", "Gaussian mean=0, sigma=1, non atomic", { 100, -5, 5 } };

m_gauss_w

Gaudi::Accumulators::StaticWeightedHistogram<1> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_gauss_w

mutableprivate

Initial value:

{
            this, "GaussW", "Gaussian mean=0, sigma=1, weighted", { 100, -5, 5 } }

Definition at line 223 of file CounterHistos.cpp.

                                                                     {
            this, "GaussW", "Gaussian mean=0, sigma=1, weighted", { 100, -5, 5 } };

m_gaussAbsName

Gaudi::Accumulators::StaticHistogram<1> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_gaussAbsName

mutableprivate

Initial value:

{
            this, "/TopDir/SubDir/Gauss", "Gaussian mean=0, sigma=1, atomic", { 100, -5, 5, "X" } }

Definition at line 312 of file CounterHistos.cpp.

                                                                  {
            this, "/TopDir/SubDir/Gauss", "Gaussian mean=0, sigma=1, atomic", { 100, -5, 5, "X" } };

m_gaussVflat

Gaudi::Accumulators::StaticHistogram<2> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_gaussVflat

mutableprivate

Initial value:

{
            this, "GaussFlat", "Gaussian V Flat, atomic", { { 50, -5, 5, "X" }, { 50, -5, 5, "Y" } } }

Definition at line 192 of file CounterHistos.cpp.

                                                                {
            this, "GaussFlat", "Gaussian V Flat, atomic", { { 50, -5, 5, "X" }, { 50, -5, 5, "Y" } } };

m_gaussVflat_buf

Gaudi::Accumulators::StaticHistogram<2> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_gaussVflat_buf

mutableprivate

Initial value:

{
            this, "GaussFlatBuf", "Gaussian V Flat, buffered", { { 50, -5, 5 }, { 50, -5, 5 } } }

Definition at line 236 of file CounterHistos.cpp.

                                                                    {
            this, "GaussFlatBuf", "Gaussian V Flat, buffered", { { 50, -5, 5 }, { 50, -5, 5 } } };

m_gaussVflat_int

Gaudi::Accumulators::StaticHistogram<2, Gaudi::Accumulators::atomicity::full, int> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_gaussVflat_int

mutableprivate

Initial value:

{
            this, "GaussFlatInt", "Gaussian V Flat, integer values", { { 10, -5, 5 }, { 10, -5, 5 } } }

Definition at line 214 of file CounterHistos.cpp.

                                                                                                         {
            this, "GaussFlatInt", "Gaussian V Flat, integer values", { { 10, -5, 5 }, { 10, -5, 5 } } };

m_gaussVflat_noato

Gaudi::Accumulators::StaticHistogram<2, Gaudi::Accumulators::atomicity::none> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_gaussVflat_noato

mutableprivate

Initial value:

{
            this, "GaussFlatNA", "Gaussian V Flat, non atomic", { { 50, -5, 5 }, { 50, -5, 5 } } }

Definition at line 203 of file CounterHistos.cpp.

                                                                                                      {
            this, "GaussFlatNA", "Gaussian V Flat, non atomic", { { 50, -5, 5 }, { 50, -5, 5 } } };

m_gaussVflat_w

Gaudi::Accumulators::StaticWeightedHistogram<2> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_gaussVflat_w

mutableprivate

Initial value:

{
            this, "GaussFlatW", "Gaussian V Flat, weighted", { { 50, -5, 5 }, { 50, -5, 5 } } }

Definition at line 225 of file CounterHistos.cpp.

                                                                          {
            this, "GaussFlatW", "Gaussian V Flat, weighted", { { 50, -5, 5 }, { 50, -5, 5 } } };

m_gaussVflatVgauss

Gaudi::Accumulators::StaticHistogram<3> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_gaussVflatVgauss

mutableprivate

Initial value:

{
            this,
            "GaussFlatGauss",
            "Gaussian V Flat V Gaussian, atomic",
            { { 10, -5, 5, "X" }, { 10, -5, 5, "Y" }, { 10, -5, 5, "Z" } } }

Definition at line 194 of file CounterHistos.cpp.

                                                                      {
            this,
            "GaussFlatGauss",
            "Gaussian V Flat V Gaussian, atomic",
            { { 10, -5, 5, "X" }, { 10, -5, 5, "Y" }, { 10, -5, 5, "Z" } } };

m_gaussVflatVgauss_buf

Gaudi::Accumulators::StaticHistogram<3> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_gaussVflatVgauss_buf

mutableprivate

Initial value:

{
            this,
            "GaussFlatGaussBuf",
            "Gaussian V Flat V Gaussian, buffered",
            { { 10, -5, 5 }, { 10, -5, 5 }, { 10, -5, 5 } } }

Definition at line 238 of file CounterHistos.cpp.

                                                                          {
            this,
            "GaussFlatGaussBuf",
            "Gaussian V Flat V Gaussian, buffered",
            { { 10, -5, 5 }, { 10, -5, 5 }, { 10, -5, 5 } } };

m_gaussVflatVgauss_int

Gaudi::Accumulators::StaticHistogram<3, Gaudi::Accumulators::atomicity::full, int> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_gaussVflatVgauss_int

mutableprivate

Initial value:

{ this,
                                    "GaussFlatGaussInt",
                                    "Gaussian V Flat V Gaussian, interger values",
                                    { { 10, -5, 5 }, { 10, -5, 5 }, { 10, -5, 5 } } }

Definition at line 217 of file CounterHistos.cpp.

                                  { this,
                                    "GaussFlatGaussInt",
                                    "Gaussian V Flat V Gaussian, interger values",
                                    { { 10, -5, 5 }, { 10, -5, 5 }, { 10, -5, 5 } } };

m_gaussVflatVgauss_noato

Gaudi::Accumulators::StaticHistogram<3, Gaudi::Accumulators::atomicity::none> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_gaussVflatVgauss_noato

mutableprivate

Initial value:

{
            this,
            "GaussFlatGaussNA",
            "Gaussian V Flat V Gaussian, non atomic",
            { { 10, -5, 5 }, { 10, -5, 5 }, { 10, -5, 5 } } }

Definition at line 205 of file CounterHistos.cpp.

                                                                                                            {
            this,
            "GaussFlatGaussNA",
            "Gaussian V Flat V Gaussian, non atomic",
            { { 10, -5, 5 }, { 10, -5, 5 }, { 10, -5, 5 } } };

m_gaussVflatVgauss_w

Gaudi::Accumulators::StaticWeightedHistogram<3> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_gaussVflatVgauss_w

mutableprivate

Initial value:

{
            this,
            "GaussFlatGaussW",
            "Gaussian V Flat V Gaussian, weighted",
            { { 10, -5, 5 }, { 10, -5, 5 }, { 10, -5, 5 } } }

Definition at line 227 of file CounterHistos.cpp.

                                                                                {
            this,
            "GaussFlatGaussW",
            "Gaussian V Flat V Gaussian, weighted",
            { { 10, -5, 5 }, { 10, -5, 5 }, { 10, -5, 5 } } };

m_log_gauss

Accumulators::LogHistogram<1> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_log_gauss { this, "LogGauss", "Log, Gaussian", { 5, 0, 2 } }

mutableprivate

Definition at line 307 of file CounterHistos.cpp.

{ this, "LogGauss", "Log, Gaussian", { 5, 0, 2 } };

m_log_gaussVflat

Accumulators::LogHistogram<2, Accumulators::atomicity::full, float> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_log_gaussVflat

mutableprivate

Initial value:

{
            this, "LogGaussFlat", "LogLog, Gaussian V Flat", { { 5, 0, 2 }, { 5, 0, 2 } } }

Definition at line 308 of file CounterHistos.cpp.

                                                                                              {
            this, "LogGaussFlat", "LogLog, Gaussian V Flat", { { 5, 0, 2 }, { 5, 0, 2 } } };

m_nCalls

Gaudi::Accumulators::Counter Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_nCalls { this, "calls" }

mutableprivate

Definition at line 177 of file CounterHistos.cpp.

{ this, "calls" };

m_prof_gauss

Gaudi::Accumulators::StaticProfileHistogram<1> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_prof_gauss

mutableprivate

Initial value:

{
            this, "ProfGauss", "Profile, Gaussian mean=0, sigma=1, atomic", { 100, -5, 5 } }

Definition at line 247 of file CounterHistos.cpp.

                                                                       {
            this, "ProfGauss", "Profile, Gaussian mean=0, sigma=1, atomic", { 100, -5, 5 } };

m_prof_gauss_buf

Gaudi::Accumulators::StaticProfileHistogram<1> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_prof_gauss_buf

mutableprivate

Initial value:

{
            this, "ProfGaussBuf", "Profile, Gaussian mean=0, sigma=1, buffered", { 100, -5, 5 } }

Definition at line 296 of file CounterHistos.cpp.

                                                                           {
            this, "ProfGaussBuf", "Profile, Gaussian mean=0, sigma=1, buffered", { 100, -5, 5 } };

m_prof_gauss_int

Gaudi::Accumulators::StaticProfileHistogram<1, Gaudi::Accumulators::atomicity::full, int> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_prof_gauss_int

mutableprivate

Initial value:

{
                this, "ProfGaussInt", "Profile, Gaussian mean=0, sigma=1, integer values", { 10, -5, 5 } }

Definition at line 271 of file CounterHistos.cpp.

                            {
                this, "ProfGaussInt", "Profile, Gaussian mean=0, sigma=1, integer values", { 10, -5, 5 } };

m_prof_gauss_noato

Gaudi::Accumulators::StaticProfileHistogram<1, Gaudi::Accumulators::atomicity::none> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_prof_gauss_noato

mutableprivate

Initial value:

{
            this, "ProfGaussNA", "Profile, Gaussian mean=0, sigma=1, non atomic", { 100, -5, 5 } }

Definition at line 258 of file CounterHistos.cpp.

                                                                                                             {
            this, "ProfGaussNA", "Profile, Gaussian mean=0, sigma=1, non atomic", { 100, -5, 5 } };

m_prof_gauss_w

Gaudi::Accumulators::StaticWeightedProfileHistogram<1> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_prof_gauss_w

mutableprivate

Initial value:

{
            this, "ProfGaussW", "Profile, Gaussian mean=0, sigma=1, weighted", { 100, -5, 5 } }

Definition at line 285 of file CounterHistos.cpp.

                                                                                 {
            this, "ProfGaussW", "Profile, Gaussian mean=0, sigma=1, weighted", { 100, -5, 5 } };

m_prof_gaussVflat

Gaudi::Accumulators::StaticProfileHistogram<2> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_prof_gaussVflat

mutableprivate

Initial value:

{
            this, "ProfGaussFlat", "Profile, Gaussian V Flat, atomic", { { 50, -5, 5 }, { 50, -5, 5 } } }

Definition at line 249 of file CounterHistos.cpp.

                                                                            {
            this, "ProfGaussFlat", "Profile, Gaussian V Flat, atomic", { { 50, -5, 5 }, { 50, -5, 5 } } };

m_prof_gaussVflat_buf

Gaudi::Accumulators::StaticProfileHistogram<2> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_prof_gaussVflat_buf

mutableprivate

Initial value:

{
            this, "ProfGaussFlatBuf", "Profile, Gaussian V Flat, buffered", { { 50, -5, 5 }, { 50, -5, 5 } } }

Definition at line 298 of file CounterHistos.cpp.

                                                                                {
            this, "ProfGaussFlatBuf", "Profile, Gaussian V Flat, buffered", { { 50, -5, 5 }, { 50, -5, 5 } } };

m_prof_gaussVflat_int

Gaudi::Accumulators::StaticProfileHistogram<2, Gaudi::Accumulators::atomicity::full, int> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_prof_gaussVflat_int

mutableprivate

Initial value:

{ this,
                                   "ProfGaussFlatInt",
                                   "Profile, Gaussian V Flat, integer values",
                                   { { 10, -5, 5 }, { 10, -5, 5 } } }

Definition at line 274 of file CounterHistos.cpp.

                                 { this,
                                   "ProfGaussFlatInt",
                                   "Profile, Gaussian V Flat, integer values",
                                   { { 10, -5, 5 }, { 10, -5, 5 } } };

m_prof_gaussVflat_noato

Gaudi::Accumulators::StaticProfileHistogram<2, Gaudi::Accumulators::atomicity::none> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_prof_gaussVflat_noato

mutableprivate

Initial value:

{
                this, "ProfGaussFlatNA", "Profile, Gaussian V Flat, non atomic", { { 50, -5, 5 }, { 50, -5, 5 } } }

Definition at line 261 of file CounterHistos.cpp.

                                   {
                this, "ProfGaussFlatNA", "Profile, Gaussian V Flat, non atomic", { { 50, -5, 5 }, { 50, -5, 5 } } };

m_prof_gaussVflat_w

Gaudi::Accumulators::StaticWeightedProfileHistogram<2> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_prof_gaussVflat_w

mutableprivate

Initial value:

{
            this, "ProfGaussFlatW", "Profile, Gaussian V Flat, weighted", { { 50, -5, 5 }, { 50, -5, 5 } } }

Definition at line 287 of file CounterHistos.cpp.

                                                                                      {
            this, "ProfGaussFlatW", "Profile, Gaussian V Flat, weighted", { { 50, -5, 5 }, { 50, -5, 5 } } };

m_prof_gaussVflatVgauss

Gaudi::Accumulators::StaticProfileHistogram<3> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_prof_gaussVflatVgauss

mutableprivate

Initial value:

{
            this,
            "ProfGaussFlatGauss",
            "Profile, Gaussian V Flat V Gaussian, atomic",
            { { 10, -5, 5 }, { 10, -5, 5 }, { 10, -5, 5 } } }

Definition at line 251 of file CounterHistos.cpp.

                                                                                  {
            this,
            "ProfGaussFlatGauss",
            "Profile, Gaussian V Flat V Gaussian, atomic",
            { { 10, -5, 5 }, { 10, -5, 5 }, { 10, -5, 5 } } };

m_prof_gaussVflatVgauss_buf

Gaudi::Accumulators::StaticProfileHistogram<3> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_prof_gaussVflatVgauss_buf

mutableprivate

Initial value:

{
            this,
            "ProfGaussFlatGaussBuf",
            "Profile, Gaussian V Flat V Gaussian, buffered",
            { { 10, -5, 5 }, { 10, -5, 5 }, { 10, -5, 5 } } }

Definition at line 300 of file CounterHistos.cpp.

                                                                                      {
            this,
            "ProfGaussFlatGaussBuf",
            "Profile, Gaussian V Flat V Gaussian, buffered",
            { { 10, -5, 5 }, { 10, -5, 5 }, { 10, -5, 5 } } };

m_prof_gaussVflatVgauss_int

Gaudi::Accumulators::StaticProfileHistogram<3, Gaudi::Accumulators::atomicity::full, int> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_prof_gaussVflatVgauss_int

mutableprivate

Initial value:

{ this,
                                         "ProfGaussFlatGaussInt",
                                         "Profile, Gaussian V Flat V Gaussian, interger values",
                                         { { 10, -5, 5 }, { 10, -5, 5 }, { 10, -5, 5 } } }

Definition at line 279 of file CounterHistos.cpp.

                                       { this,
                                         "ProfGaussFlatGaussInt",
                                         "Profile, Gaussian V Flat V Gaussian, interger values",
                                         { { 10, -5, 5 }, { 10, -5, 5 }, { 10, -5, 5 } } };

m_prof_gaussVflatVgauss_noato

Gaudi::Accumulators::StaticProfileHistogram<3, Gaudi::Accumulators::atomicity::none> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_prof_gaussVflatVgauss_noato

mutableprivate

Initial value:

{ this,
                                           "ProfGaussFlatGaussNA",
                                           "Profile, Gaussian V Flat V Gaussian, non atomic",
                                           { { 10, -5, 5 }, { 10, -5, 5 }, { 10, -5, 5 } } }

Definition at line 264 of file CounterHistos.cpp.

                                         { this,
                                           "ProfGaussFlatGaussNA",
                                           "Profile, Gaussian V Flat V Gaussian, non atomic",
                                           { { 10, -5, 5 }, { 10, -5, 5 }, { 10, -5, 5 } } };

m_prof_gaussVflatVgauss_w

Gaudi::Accumulators::StaticWeightedProfileHistogram<3> Gaudi::TestSuite::Counter::GaudiHistoAlgorithm::m_prof_gaussVflatVgauss_w

mutableprivate

Initial value:

{
            this,
            "ProfGaussFlatGaussW",
            "Profile, Gaussian V Flat V Gaussian, weighted",
            { { 10, -5, 5 }, { 10, -5, 5 }, { 10, -5, 5 } } }

Definition at line 289 of file CounterHistos.cpp.

                                                                                            {
            this,
            "ProfGaussFlatGaussW",
            "Profile, Gaussian V Flat V Gaussian, weighted",
            { { 10, -5, 5 }, { 10, -5, 5 }, { 10, -5, 5 } } };

---

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

• GaudiTestSuite/src/Histograms/CounterHistos.cpp