Skip to content
Snippets Groups Projects
Commit 4f40d8d4 authored by Gitlab CI's avatar Gitlab CI Committed by Sebastien Ponce
Browse files

Fixed formatting 

patch generated by https://gitlab.cern.ch/gaudi/Gaudi/-/jobs/10130864
parent 75c16496
No related branches found
No related tags found
1 merge request!1113New (counter based) histograms
Hide whitespace changes
Inline Side-by-side
Showing
with 216 additions and 158 deletions
GaudiCommonSvc/src/HistogramPersistencySvc/RootHistogramSink.cpp
+ 28
− 34
View file @ 4f40d8d4
......@@ -23,23 +23,22 @@
#include <fmt/format.h>
#include <deque>
#include <algorithm>
#include <deque>
namespace {
struct Axis {
unsigned int nBins;
double minValue;
double maxValue;
std::string title;
double minValue;
double maxValue;
std::string title;
};
Axis toAxis( nlohmann::json& jAxis ) {
return { jAxis.at("nBins").get<unsigned int>(),
jAxis.at("minValue").get<double>(),
jAxis.at("maxValue").get<double>(),
";" + jAxis.at("title").get<std::string>() }; // ";" to prepare concatenations of titles
return {jAxis.at( "nBins" ).get<unsigned int>(), jAxis.at( "minValue" ).get<double>(),
jAxis.at( "maxValue" ).get<double>(),
";" + jAxis.at( "title" ).get<std::string>()}; // ";" to prepare concatenations of titles
}
template <typename Traits, std::size_t... index>
......@@ -50,12 +49,12 @@ namespace {
auto jsonAxis = j.at( "axis" );
auto axis = std::array{toAxis( jsonAxis[index] )...};
auto weights = j.at( "bins" ).get<std::vector<typename Traits::WeightType>>();
auto title = j.at("title").get<std::string>();
auto title = j.at( "title" ).get<std::string>();
// weird way ROOT has to give titles to axis
title += (axis[index].title + ...);
title += ( axis[index].title + ... );
// compute total number of bins, multiplying bins per axis
auto totNBins = ((axis[index].nBins+2) * ...);
assert(weights.size() == totNBins);
auto totNBins = ( ( axis[index].nBins + 2 ) * ... );
assert( weights.size() == totNBins );
// Create Root histogram calling constructors with the args tuple
auto histo = std::make_from_tuple<typename Traits::Histo>(
std::tuple_cat( std::tuple{id.c_str(), title.c_str()},
......@@ -73,9 +72,7 @@ namespace {
struct Traits<false, RootHisto> {
using Histo = RootHisto;
using WeightType = double;
static auto fill( Histo& histo, unsigned int i, const WeightType& weight ) {
histo.SetBinContent( i, weight );
}
static auto fill( Histo& histo, unsigned int i, const WeightType& weight ) { histo.SetBinContent( i, weight ); }
};
template <typename RootHisto>
struct Traits<true, RootHisto> {
......@@ -104,26 +101,25 @@ namespace {
using namespace std::string_literals;
static const auto registry =
std::map{std::pair{std::pair{"histogram:Histogram"s, 1}, &saveRootHisto<1, false, TH1D>},
std::pair{std::pair{"histogram:WeightedHistogram"s, 1}, &saveRootHisto<1, false, TH1D>},
std::pair{std::pair{"histogram:Histogram"s, 2}, &saveRootHisto<2, false, TH2D>},
std::pair{std::pair{"histogram:WeightedHistogram"s, 2}, &saveRootHisto<2, false, TH2D>},
std::pair{std::pair{"histogram:Histogram"s, 3}, &saveRootHisto<3, false, TH3D>},
std::pair{std::pair{"histogram:WeightedHistogram"s, 3}, &saveRootHisto<3, false, TH3D>},
std::pair{std::pair{"histogram:ProfileHistogram"s, 1}, &saveRootHisto<1, true, TProfile>},
std::pair{std::pair{"histogram:WeightedProfileHistogram"s, 1}, &saveRootHisto<1, true, TProfile>},
std::pair{std::pair{"histogram:ProfileHistogram"s, 2}, &saveRootHisto<2, true, TProfile2D>},
std::pair{std::pair{"histogram:WeightedProfileHistogram"s, 2}, &saveRootHisto<2, true, TProfile2D>},
std::pair{std::pair{"histogram:ProfileHistogram"s, 3}, &saveRootHisto<3, true, TProfile3D>},
std::pair{std::pair{"histogram:WeightedProfileHistogram"s, 3}, &saveRootHisto<3, true, TProfile3D>}};
}
std::map{std::pair{std::pair{"histogram:Histogram"s, 1}, &saveRootHisto<1, false, TH1D>},
std::pair{std::pair{"histogram:WeightedHistogram"s, 1}, &saveRootHisto<1, false, TH1D>},
std::pair{std::pair{"histogram:Histogram"s, 2}, &saveRootHisto<2, false, TH2D>},
std::pair{std::pair{"histogram:WeightedHistogram"s, 2}, &saveRootHisto<2, false, TH2D>},
std::pair{std::pair{"histogram:Histogram"s, 3}, &saveRootHisto<3, false, TH3D>},
std::pair{std::pair{"histogram:WeightedHistogram"s, 3}, &saveRootHisto<3, false, TH3D>},
std::pair{std::pair{"histogram:ProfileHistogram"s, 1}, &saveRootHisto<1, true, TProfile>},
std::pair{std::pair{"histogram:WeightedProfileHistogram"s, 1}, &saveRootHisto<1, true, TProfile>},
std::pair{std::pair{"histogram:ProfileHistogram"s, 2}, &saveRootHisto<2, true, TProfile2D>},
std::pair{std::pair{"histogram:WeightedProfileHistogram"s, 2}, &saveRootHisto<2, true, TProfile2D>},
std::pair{std::pair{"histogram:ProfileHistogram"s, 3}, &saveRootHisto<3, true, TProfile3D>},
std::pair{std::pair{"histogram:WeightedProfileHistogram"s, 3}, &saveRootHisto<3, true, TProfile3D>}};
} // namespace
namespace Gaudi::Histograming::Sink {
class Root : public Service, public Gaudi::Monitoring::Hub::Sink {
public:
using Service::Service;
StatusCode initialize() override {
......@@ -141,8 +137,8 @@ namespace Gaudi::Histograming::Sink {
} );
TFile histoFile( "testHisto.root", "RECREATE" );
std::for_each( begin( m_monitoringEntities ), end( m_monitoringEntities ), []( auto& ent ) {
auto j = ent.toJSON();
auto dim = j.at( "dimension" ).template get<unsigned int>();
auto j = ent.toJSON();
auto dim = j.at( "dimension" ).template get<unsigned int>();
auto type = j.at( "type" ).template get<std::string>();
auto saver = registry.find( {type, dim} );
if ( saver == registry.end() )
......@@ -162,10 +158,8 @@ namespace Gaudi::Histograming::Sink {
private:
std::deque<Gaudi::Monitoring::Hub::Entity> m_monitoringEntities;
};
DECLARE_COMPONENT( Root )
} // namespace Gaudi::Histograming::Sink
GaudiExamples/options/Histograms.py
+ 5
− 1
View file @ 4f40d8d4
......@@ -29,4 +29,8 @@ algs = [
]
app = ApplicationMgr(
EvtMax=50000, EvtSel='NONE', HistogramPersistency='ROOT', TopAlg=algs, ExtSvc=[MessageSvcSink(), RootHistoSink()])
EvtMax=50000,
EvtSel='NONE',
HistogramPersistency='ROOT',
TopAlg=algs,
ExtSvc=[MessageSvcSink(), RootHistoSink()])
GaudiExamples/options/HistogramsTiming.py
+ 4
− 4
View file @ 4f40d8d4
......@@ -16,10 +16,10 @@ RootHistSvc('RootHistSvc').OutputFile = 'histo.root'
#HistogramSvc('HistogramDataSvc').Input = [ "InFile DATAFILE='../data/input.hbook' TYP='HBOOK'" ]
from Configurables import (
HistoTimingAlgDA as CounterHistoTimingDA, HistoTimingAlgIA as
CounterHistoTimingIA, HistoTimingAlgD as CounterHistoTimingD,
HistoTimingAlgI as CounterHistoTimingI)
from Configurables import (HistoTimingAlgDA as CounterHistoTimingDA,
HistoTimingAlgIA as CounterHistoTimingIA,
HistoTimingAlgD as CounterHistoTimingD,
HistoTimingAlgI as CounterHistoTimingI)
seq = GaudiSequencer("TimingSeq", MeasureTime=True)
seq.Members = [
......
GaudiExamples/options/Histograms_with_global.py
+ 1
− 1
View file @ 4f40d8d4
......@@ -22,7 +22,7 @@ algorithms = [
app = C.ApplicationMgr(
'ApplicationMgr',
TopAlg=[ 'SimpleHistos', 'SimpleCounterHistos' ],
TopAlg=['SimpleHistos', 'SimpleCounterHistos'],
EvtMax=50000,
EvtSel='NONE',
)
......
GaudiExamples/src/Histograms/CounterHistos.cpp
+ 60
− 36
View file @ 4f40d8d4
......@@ -98,8 +98,8 @@ namespace Gaudi {
m_gauss_w += {gauss, .5};
m_gaussVflat_w += {{flat, gauss}, .5};
m_gaussVflatVgauss_w += {{flat, gauss, gauss2}, .5};
auto gauss_buf = m_gauss_buf.buffer();
auto gaussVflat_buf = m_gaussVflat_buf.buffer();
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;
......@@ -120,8 +120,8 @@ namespace Gaudi {
m_prof_gauss_w += {{gauss, flat}, .5};
m_prof_gaussVflat_w += {{flat, gauss, flat2}, .5};
m_prof_gaussVflatVgauss_w += {{flat, gauss, gauss2, flat2}, .5};
auto prof_gauss_buf = m_prof_gauss_buf.buffer();
auto prof_gaussVflat_buf = m_prof_gaussVflat_buf.buffer();
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, flat};
......@@ -141,43 +141,52 @@ namespace Gaudi {
// "default" case, that is bins containing doubles and atomic
mutable Gaudi::Accumulators::Histogram<1> m_gauss{
this, "Gauss", "Gaussian mean=0, sigma=1, atomic", {100, -5, 5, "X"}};
this, "Gauss", "Gaussian mean=0, sigma=1, atomic", {100, -5, 5, "X"}};
mutable Gaudi::Accumulators::Histogram<2> m_gaussVflat{
this, "GaussFlat", "Gaussian V Flat, atomic", {{50, -5, 5, "X"}, {50, -5, 5, "Y"}}};
this, "GaussFlat", "Gaussian V Flat, atomic", {{50, -5, 5, "X"}, {50, -5, 5, "Y"}}};
mutable Gaudi::Accumulators::Histogram<3> m_gaussVflatVgauss{
this, "GaussFlatGauss", "Gaussian V Flat V Gaussian, atomic", {{10, -5, 5, "X"}, {10, -5, 5, "Y"}, {10, -5, 5, "Z"}}};
this,
"GaussFlatGauss",
"Gaussian V Flat V Gaussian, atomic",
{{10, -5, 5, "X"}, {10, -5, 5, "Y"}, {10, -5, 5, "Z"}}};
// non atomic versions
mutable Gaudi::Accumulators::Histogram<1, Gaudi::Accumulators::atomicity::none> m_gauss_noato{
this, "GaussNA", "Gaussian mean=0, sigma=1, non atomic", {100, -5, 5}};
this, "GaussNA", "Gaussian mean=0, sigma=1, non atomic", {100, -5, 5}};
mutable Gaudi::Accumulators::Histogram<2, Gaudi::Accumulators::atomicity::none> m_gaussVflat_noato{
this, "GaussFlatNA", "Gaussian V Flat, non atomic", {{50, -5, 5}, {50, -5, 5}}};
this, "GaussFlatNA", "Gaussian V Flat, non atomic", {{50, -5, 5}, {50, -5, 5}}};
mutable Gaudi::Accumulators::Histogram<3, Gaudi::Accumulators::atomicity::none> m_gaussVflatVgauss_noato{
this, "GaussFlatGaussNA", "Gaussian V Flat V Gaussian, non atomic", {{10, -5, 5}, {10, -5, 5}, {10, -5, 5}}};
this,
"GaussFlatGaussNA",
"Gaussian V Flat V Gaussian, non atomic",
{{10, -5, 5}, {10, -5, 5}, {10, -5, 5}}};
// using integers
mutable Gaudi::Accumulators::Histogram<1, Gaudi::Accumulators::atomicity::full, int>
m_gauss_int{this, "GaussInt", "Gaussian mean=0, sigma=1, integer values", {10, -5, 5}};
mutable Gaudi::Accumulators::Histogram<2, Gaudi::Accumulators::atomicity::full, int>
m_gaussVflat_int{this, "GaussFlatInt", "Gaussian V Flat, integer values", {{10, -5, 5}, {10, -5, 5}}};
mutable Gaudi::Accumulators::Histogram<3, Gaudi::Accumulators::atomicity::full, int>
m_gaussVflatVgauss_int{this, "GaussFlatGaussInt", "Gaussian V Flat V Gaussian, interger values", {{10, -5, 5}, {10, -5, 5}, {10, -5, 5}}};
mutable Gaudi::Accumulators::Histogram<1, Gaudi::Accumulators::atomicity::full, int> m_gauss_int{
this, "GaussInt", "Gaussian mean=0, sigma=1, integer values", {10, -5, 5}};
mutable Gaudi::Accumulators::Histogram<2, Gaudi::Accumulators::atomicity::full, int> m_gaussVflat_int{
this, "GaussFlatInt", "Gaussian V Flat, integer values", {{10, -5, 5}, {10, -5, 5}}};
mutable Gaudi::Accumulators::Histogram<3, Gaudi::Accumulators::atomicity::full, int> m_gaussVflatVgauss_int{
this,
"GaussFlatGaussInt",
"Gaussian V Flat V Gaussian, interger values",
{{10, -5, 5}, {10, -5, 5}, {10, -5, 5}}};
// weighted version, "default" case
mutable Gaudi::Accumulators::WeightedHistogram<1> m_gauss_w{
this, "GaussW", "Gaussian mean=0, sigma=1, weighted", {100, -5, 5}};
this, "GaussW", "Gaussian mean=0, sigma=1, weighted", {100, -5, 5}};
mutable Gaudi::Accumulators::WeightedHistogram<2> m_gaussVflat_w{
this, "GaussFlatW", "Gaussian V Flat, weighted", {{50, -5, 5}, {50, -5, 5}}};
this, "GaussFlatW", "Gaussian V Flat, weighted", {{50, -5, 5}, {50, -5, 5}}};
mutable Gaudi::Accumulators::WeightedHistogram<3> m_gaussVflatVgauss_w{
this, "GaussFlatGaussW", "Gaussian V Flat V Gaussian, weighted", {{10, -5, 5}, {10, -5, 5}, {10, -5, 5}}};
this, "GaussFlatGaussW", "Gaussian V Flat V Gaussian, weighted", {{10, -5, 5}, {10, -5, 5}, {10, -5, 5}}};
// "default" case, dedicated to testing buffers
mutable Gaudi::Accumulators::Histogram<1> m_gauss_buf{
this, "GaussBuf", "Gaussian mean=0, sigma=1, buffered", {100, -5, 5}};
this, "GaussBuf", "Gaussian mean=0, sigma=1, buffered", {100, -5, 5}};
mutable Gaudi::Accumulators::Histogram<2> m_gaussVflat_buf{
this, "GaussFlatBuf", "Gaussian V Flat, buffered", {{50, -5, 5}, {50, -5, 5}}};
this, "GaussFlatBuf", "Gaussian V Flat, buffered", {{50, -5, 5}, {50, -5, 5}}};
mutable Gaudi::Accumulators::Histogram<3> m_gaussVflatVgauss_buf{
this, "GaussFlatGaussBuf", "Gaussian V Flat V Gaussian, buffered", {{10, -5, 5}, {10, -5, 5}, {10, -5, 5}}};
this, "GaussFlatGaussBuf", "Gaussian V Flat V Gaussian, buffered", {{10, -5, 5}, {10, -5, 5}, {10, -5, 5}}};
// Testing profiling histograms in all dimensions and features
......@@ -185,42 +194,57 @@ namespace Gaudi {
mutable Gaudi::Accumulators::ProfileHistogram<1> m_prof_gauss{
this, "ProfGauss", "Profile, Gaussian mean=0, sigma=1, atomic", {100, -5, 5}};
mutable Gaudi::Accumulators::ProfileHistogram<2> m_prof_gaussVflat{
this, "ProfGaussFlat", "Profile, Gaussian V Flat, atomic", {{50, -5, 5}, {50, -5, 5}}};
this, "ProfGaussFlat", "Profile, Gaussian V Flat, atomic", {{50, -5, 5}, {50, -5, 5}}};
mutable Gaudi::Accumulators::ProfileHistogram<3> m_prof_gaussVflatVgauss{
this, "ProfGaussFlatGauss", "Profile, Gaussian V Flat V Gaussian, atomic", {{10, -5, 5}, {10, -5, 5}, {10, -5, 5}}};
this,
"ProfGaussFlatGauss",
"Profile, Gaussian V Flat V Gaussian, atomic",
{{10, -5, 5}, {10, -5, 5}, {10, -5, 5}}};
// non atomic versions
mutable Gaudi::Accumulators::ProfileHistogram<1, Gaudi::Accumulators::atomicity::none> m_prof_gauss_noato{
this, "ProfGaussNA", "Profile, Gaussian mean=0, sigma=1, non atomic", {100, -5, 5}};
mutable Gaudi::Accumulators::ProfileHistogram<2, Gaudi::Accumulators::atomicity::none> m_prof_gaussVflat_noato{
this, "ProfGaussFlatNA", "Profile, Gaussian V Flat, non atomic", {{50, -5, 5}, {50, -5, 5}}};
mutable Gaudi::Accumulators::ProfileHistogram<3, Gaudi::Accumulators::atomicity::none> m_prof_gaussVflatVgauss_noato{
this, "ProfGaussFlatGaussNA", "Profile, Gaussian V Flat V Gaussian, non atomic", {{10, -5, 5}, {10, -5, 5}, {10, -5, 5}}};
this, "ProfGaussFlatNA", "Profile, Gaussian V Flat, non atomic", {{50, -5, 5}, {50, -5, 5}}};
mutable Gaudi::Accumulators::ProfileHistogram<3, Gaudi::Accumulators::atomicity::none>
m_prof_gaussVflatVgauss_noato{this,
"ProfGaussFlatGaussNA",
"Profile, Gaussian V Flat V Gaussian, non atomic",
{{10, -5, 5}, {10, -5, 5}, {10, -5, 5}}};
// using integers internally
mutable Gaudi::Accumulators::ProfileHistogram<1, Gaudi::Accumulators::atomicity::full, int>
m_prof_gauss_int{this, "ProfGaussInt", "Profile, Gaussian mean=0, sigma=1, integer values", {10, -5, 5}};
mutable Gaudi::Accumulators::ProfileHistogram<1, Gaudi::Accumulators::atomicity::full, int> m_prof_gauss_int{
this, "ProfGaussInt", "Profile, Gaussian mean=0, sigma=1, integer values", {10, -5, 5}};
mutable Gaudi::Accumulators::ProfileHistogram<2, Gaudi::Accumulators::atomicity::full, int>
m_prof_gaussVflat_int{this, "ProfGaussFlatInt", "Profile, Gaussian V Flat, integer values", {{10, -5, 5}, {10, -5, 5}}};
m_prof_gaussVflat_int{
this, "ProfGaussFlatInt", "Profile, Gaussian V Flat, integer values", {{10, -5, 5}, {10, -5, 5}}};
mutable Gaudi::Accumulators::ProfileHistogram<3, Gaudi::Accumulators::atomicity::full, int>
m_prof_gaussVflatVgauss_int{this, "ProfGaussFlatGaussInt", "Profile, Gaussian V Flat V Gaussian, interger values", {{10, -5, 5}, {10, -5, 5}, {10, -5, 5}}};
m_prof_gaussVflatVgauss_int{this,
"ProfGaussFlatGaussInt",
"Profile, Gaussian V Flat V Gaussian, interger values",
{{10, -5, 5}, {10, -5, 5}, {10, -5, 5}}};
// weighted version, "default" case
mutable Gaudi::Accumulators::WeightedProfileHistogram<1> m_prof_gauss_w{
this, "ProfGaussW", "Profile, Gaussian mean=0, sigma=1, weighted", {100, -5, 5}};
mutable Gaudi::Accumulators::WeightedProfileHistogram<2> m_prof_gaussVflat_w{
this, "ProfGaussFlatW", "Profile, Gaussian V Flat, weighted", {{50, -5, 5}, {50, -5, 5}}};
this, "ProfGaussFlatW", "Profile, Gaussian V Flat, weighted", {{50, -5, 5}, {50, -5, 5}}};
mutable Gaudi::Accumulators::WeightedProfileHistogram<3> m_prof_gaussVflatVgauss_w{
this, "ProfGaussFlatGaussW", "Profile, Gaussian V Flat V Gaussian, weighted", {{10, -5, 5}, {10, -5, 5}, {10, -5, 5}}};
this,
"ProfGaussFlatGaussW",
"Profile, Gaussian V Flat V Gaussian, weighted",
{{10, -5, 5}, {10, -5, 5}, {10, -5, 5}}};
// "default" case, dedicated to testing buffers
mutable Gaudi::Accumulators::ProfileHistogram<1> m_prof_gauss_buf{
this, "ProfGaussBuf", "Profile, Gaussian mean=0, sigma=1, buffered", {100, -5, 5}};
mutable Gaudi::Accumulators::ProfileHistogram<2> m_prof_gaussVflat_buf{
this, "ProfGaussFlatBuf", "Profile, Gaussian V Flat, buffered", {{50, -5, 5}, {50, -5, 5}}};
this, "ProfGaussFlatBuf", "Profile, Gaussian V Flat, buffered", {{50, -5, 5}, {50, -5, 5}}};
mutable Gaudi::Accumulators::ProfileHistogram<3> m_prof_gaussVflatVgauss_buf{
this, "ProfGaussFlatGaussBuf", "Profile, Gaussian V Flat V Gaussian, buffered", {{10, -5, 5}, {10, -5, 5}, {10, -5, 5}}};
this,
"ProfGaussFlatGaussBuf",
"Profile, Gaussian V Flat V Gaussian, buffered",
{{10, -5, 5}, {10, -5, 5}, {10, -5, 5}}};
};
DECLARE_COMPONENT( GaudiHistoAlgorithm )
} // namespace Counter
......
GaudiKernel/Gaudi/Accumulators.h
+ 25
− 18
View file @ 4f40d8d4
......@@ -473,7 +473,8 @@ namespace Gaudi::Accumulators {
* and increase them altogether
* @see Gaudi::Accumulators for detailed documentation
*/
template <typename Arithmetic, atomicity Atomicity, typename InputTypeT=Arithmetic, template <atomicity, typename> class... Bases>
template <typename Arithmetic, atomicity Atomicity, typename InputTypeT = Arithmetic,
template <atomicity, typename> class... Bases>
class AccumulatorSet : public Bases<Atomicity, Arithmetic>... {
public:
using InputType = InputTypeT;
......@@ -483,7 +484,8 @@ namespace Gaudi::Accumulators {
constexpr AccumulatorSet() = default;
/// constructor of an empty AccumulatorSet, copying the (non existent) config from another GenericAccumulator
template <atomicity ato>
AccumulatorSet( construct_empty_t, const AccumulatorSet<Arithmetic, ato, InputType, Bases...>& ) : AccumulatorSet() {}
AccumulatorSet( construct_empty_t, const AccumulatorSet<Arithmetic, ato, InputType, Bases...>& )
: AccumulatorSet() {}
AccumulatorSet& operator+=( const InputType by ) {
( Bases<Atomicity, Arithmetic>::operator+=( by ), ... );
return *this;
......@@ -645,7 +647,7 @@ namespace Gaudi::Accumulators {
if ( 1 > nbEntries ) return Result{-1};
return sqrt( static_cast<Result>( this->nTrueEntries() * this->nFalseEntries() ) / nbEntries ) / nbEntries;
}
auto effErr() const { return efficiencyErr(); }
auto effErr() const { return efficiencyErr(); }
using AccumulatorSet<bool, Atomicity, bool, TrueAccumulator, FalseAccumulator>::operator+=;
struct binomial_t {
unsigned long nPass;
......@@ -665,13 +667,15 @@ namespace Gaudi::Accumulators {
* This Base class is still templated on the counting and summing accumulators
* @see Gaudi::Accumulators for detailed documentation
*/
template <atomicity Atomicity, typename Arithmetic,
template<atomicity, typename> typename CountAcc,
template<atomicity, typename> typename SumAcc>
struct AveragingAccumulatorBase : AccumulatorSet<Arithmetic, Atomicity, typename CountAcc<Atomicity, Arithmetic>::InputType, CountAcc, SumAcc> {
static_assert(std::is_same_v<typename CountAcc<Atomicity, Arithmetic>::InputType, typename SumAcc<Atomicity, Arithmetic>::InputType>,
"Incompatible Counters in definition of AveragingAccumulator. Both should have identical Input");
using AccumulatorSet<Arithmetic, Atomicity, typename CountAcc<Atomicity, Arithmetic>::InputType, CountAcc, SumAcc>::AccumulatorSet;
template <atomicity Atomicity, typename Arithmetic, template <atomicity, typename> typename CountAcc,
template <atomicity, typename> typename SumAcc>
struct AveragingAccumulatorBase
: AccumulatorSet<Arithmetic, Atomicity, typename CountAcc<Atomicity, Arithmetic>::InputType, CountAcc, SumAcc> {
static_assert( std::is_same_v<typename CountAcc<Atomicity, Arithmetic>::InputType,
typename SumAcc<Atomicity, Arithmetic>::InputType>,
"Incompatible Counters in definition of AveragingAccumulator. Both should have identical Input" );
using AccumulatorSet<Arithmetic, Atomicity, typename CountAcc<Atomicity, Arithmetic>::InputType, CountAcc,
SumAcc>::AccumulatorSet;
template <typename Result = fp_result_type<Arithmetic>>
auto mean() const {
auto n = this->nEntries();
......@@ -692,13 +696,15 @@ namespace Gaudi::Accumulators {
* This Base class is still templated on the averaging and square accumulators
* @see Gaudi::Accumulators for detailed documentation
*/
template <atomicity Atomicity, typename Arithmetic,
template<atomicity, typename> typename AvgAcc,
template<atomicity, typename> typename SquareAcc>
struct SigmaAccumulatorBase : AccumulatorSet<Arithmetic, Atomicity, typename AvgAcc<Atomicity, Arithmetic>::InputType, AvgAcc, SquareAcc> {
static_assert(std::is_same_v<typename AvgAcc<Atomicity, Arithmetic>::InputType, typename SquareAcc<Atomicity, Arithmetic>::InputType>,
"Incompatible Counters in definition of SigmaAccumulator. Both should have identical Input");
using AccumulatorSet<Arithmetic, Atomicity, typename SquareAcc<Atomicity, Arithmetic>::InputType, AvgAcc, SquareAcc>::AccumulatorSet;
template <atomicity Atomicity, typename Arithmetic, template <atomicity, typename> typename AvgAcc,
template <atomicity, typename> typename SquareAcc>
struct SigmaAccumulatorBase
: AccumulatorSet<Arithmetic, Atomicity, typename AvgAcc<Atomicity, Arithmetic>::InputType, AvgAcc, SquareAcc> {
static_assert( std::is_same_v<typename AvgAcc<Atomicity, Arithmetic>::InputType,
typename SquareAcc<Atomicity, Arithmetic>::InputType>,
"Incompatible Counters in definition of SigmaAccumulator. Both should have identical Input" );
using AccumulatorSet<Arithmetic, Atomicity, typename SquareAcc<Atomicity, Arithmetic>::InputType, AvgAcc,
SquareAcc>::AccumulatorSet;
template <typename Result = fp_result_type<Arithmetic>>
auto biased_sample_variance() const {
auto n = this->nEntries();
......@@ -751,7 +757,8 @@ namespace Gaudi::Accumulators {
* @see Gaudi::Accumulators for detailed documentation
*/
template <atomicity Atomicity, typename Arithmetic>
using StatAccumulator = AccumulatorSet<Arithmetic, Atomicity, Arithmetic, SigmaAccumulator, MinAccumulator, MaxAccumulator>;
using StatAccumulator =
AccumulatorSet<Arithmetic, Atomicity, Arithmetic, SigmaAccumulator, MinAccumulator, MaxAccumulator>;
/**
* Buffer is a non atomic Accumulator which, when it goes out-of-scope,
......
GaudiKernel/Gaudi/Accumulators/Histogram.h
+ 93
− 64
View file @ 4f40d8d4
......@@ -21,10 +21,10 @@
#include <nlohmann/json.hpp>
#include <array>
#include <cmath>
#include <type_traits>
#include <utility>
#include <array>
namespace Gaudi::Accumulators {
......@@ -65,19 +65,24 @@ namespace Gaudi::Accumulators {
* @see Gaudi::Accumulators for detailed documentation
*/
template <atomicity Atomicity, typename Arithmetic>
struct WeightedCountAccumulator : GenericAccumulator<std::pair<Arithmetic, Arithmetic>, Arithmetic, Atomicity, ExtractWeight> {
using GenericAccumulator<std::pair<Arithmetic, Arithmetic>, Arithmetic, Atomicity, ExtractWeight>::GenericAccumulator;
struct WeightedCountAccumulator
: GenericAccumulator<std::pair<Arithmetic, Arithmetic>, Arithmetic, Atomicity, ExtractWeight> {
using GenericAccumulator<std::pair<Arithmetic, Arithmetic>, Arithmetic, Atomicity,
ExtractWeight>::GenericAccumulator;
Arithmetic nEntries() const { return this->value(); }
};
/**
* WeightedSumAccumulator. A WeightedSumAccumulator is an Accumulator storing a weighted sum of values.
* It takes a pair (valueTuple, weight) and basically sums the product of the last item othe 2 part of its in put pair : weight and value
* It takes a pair (valueTuple, weight) and basically sums the product of the last item othe 2 part of its in put pair
* : weight and value
* @see Gaudi::Accumulators for detailed documentation
*/
template <atomicity Atomicity, typename Arithmetic>
struct WeightedSumAccumulator : GenericAccumulator<std::pair<Arithmetic, Arithmetic>, Arithmetic, Atomicity, WeightedProduct> {
using GenericAccumulator<std::pair<Arithmetic, Arithmetic>, Arithmetic, Atomicity, WeightedProduct>::GenericAccumulator;
struct WeightedSumAccumulator
: GenericAccumulator<std::pair<Arithmetic, Arithmetic>, Arithmetic, Atomicity, WeightedProduct> {
using GenericAccumulator<std::pair<Arithmetic, Arithmetic>, Arithmetic, Atomicity,
WeightedProduct>::GenericAccumulator;
Arithmetic sum() const { return this->value(); }
};
......@@ -87,8 +92,10 @@ namespace Gaudi::Accumulators {
* @see Gaudi::Accumulators for detailed documentation
*/
template <atomicity Atomicity, typename Arithmetic = double>
struct WeightedSquareAccumulator : GenericAccumulator<std::pair<Arithmetic, Arithmetic>, Arithmetic, Atomicity, WeightedSquare> {
using GenericAccumulator<std::pair<Arithmetic, Arithmetic>, Arithmetic, Atomicity, WeightedSquare>::GenericAccumulator;
struct WeightedSquareAccumulator
: GenericAccumulator<std::pair<Arithmetic, Arithmetic>, Arithmetic, Atomicity, WeightedSquare> {
using GenericAccumulator<std::pair<Arithmetic, Arithmetic>, Arithmetic, Atomicity,
WeightedSquare>::GenericAccumulator;
Arithmetic sum2() const { return this->value(); };
};
......@@ -98,7 +105,8 @@ namespace Gaudi::Accumulators {
* @see Gaudi::Accumulators for detailed documentation
*/
template <atomicity Atomicity, typename Arithmetic>
using WeightedAveragingAccumulator = AveragingAccumulatorBase<Atomicity, Arithmetic, WeightedCountAccumulator, WeightedSumAccumulator>;
using WeightedAveragingAccumulator =
AveragingAccumulatorBase<Atomicity, Arithmetic, WeightedCountAccumulator, WeightedSumAccumulator>;
/**
* WeightedSigmaAccumulator. A SigmaAccumulator is an Accumulator able to compute an average and variance/rms
......@@ -106,15 +114,20 @@ namespace Gaudi::Accumulators {
* @see Gaudi::Accumulators for detailed documentation
*/
template <atomicity Atomicity, typename Arithmetic>
using WeightedSigmaAccumulator = SigmaAccumulatorBase<Atomicity, Arithmetic, WeightedAveragingAccumulator, WeightedSquareAccumulator>;
using WeightedSigmaAccumulator =
SigmaAccumulatorBase<Atomicity, Arithmetic, WeightedAveragingAccumulator, WeightedSquareAccumulator>;
/**
* Definition of an Histogram Axis
*/
template <typename Arithmetic>
struct Axis {
Axis( unsigned int _nBins, Arithmetic _minValue, Arithmetic _maxValue, const std::string& _title="" )
: nBins( _nBins ), minValue( _minValue ), maxValue( _maxValue ), title(_title), ratio( _nBins / ( _maxValue - _minValue ) ){};
Axis( unsigned int _nBins, Arithmetic _minValue, Arithmetic _maxValue, const std::string& _title = "" )
: nBins( _nBins )
, minValue( _minValue )
, maxValue( _maxValue )
, title( _title )
, ratio( _nBins / ( _maxValue - _minValue ) ){};
/// number of bins for this Axis
unsigned int nBins;
/// min and max values on this axis
......@@ -127,11 +140,12 @@ namespace Gaudi::Accumulators {
*/
Arithmetic ratio;
};
/// automatic conversion of the Axis type to json
template <typename Arithmetic>
void to_json(nlohmann::json& j, const Axis<Arithmetic>& axis) {
j = nlohmann::json{{"nBins", axis.nBins}, {"minValue", axis.minValue}, {"maxValue", axis.maxValue}, {"title", axis.title}};
void to_json( nlohmann::json& j, const Axis<Arithmetic>& axis ) {
j = nlohmann::json{
{"nBins", axis.nBins}, {"minValue", axis.minValue}, {"maxValue", axis.maxValue}, {"title", axis.title}};
}
/// small class used as InputType for regular Histograms
......@@ -145,13 +159,13 @@ namespace Gaudi::Accumulators {
localIndex = ( localIndex < 0 )
? 0
: ( ( (unsigned int)localIndex >= axis[dim].nBins ) ? axis[dim].nBins + 1
: (unsigned int)( localIndex + 1 ) );
: (unsigned int)( localIndex + 1 ) );
// compute global index. Bins are stored in a row first manner
index = ( dim > 0 ? ( axis[dim-1].nBins + 2 ) : 0 ) * index + localIndex;
index = ( dim > 0 ? ( axis[dim - 1].nBins + 2 ) : 0 ) * index + localIndex;
}
return index;
}
auto forInternalCounter() { return this->operator[](ND-1); }
auto forInternalCounter() { return this->operator[]( ND - 1 ); }
};
/// specialization of HistoInputType for ND == 1 in order to have simpler syntax
......@@ -159,14 +173,15 @@ namespace Gaudi::Accumulators {
template <typename Arithmetic>
class HistoInputType<Arithmetic, 1> {
public:
HistoInputType(Arithmetic a) : value(a) {}
HistoInputType( Arithmetic a ) : value( a ) {}
unsigned int computeIndex( const std::array<Axis<Arithmetic>, 1>& axis ) const {
int index = std::floor( ( value - axis[0].minValue ) * axis[0].ratio ) + 1;
return index < 0 ? 0 : ( (unsigned int)index > axis[0].nBins ? axis[0].nBins + 1 : (unsigned int)index );
}
Arithmetic& operator[](int index) { return value; }
operator Arithmetic() const { return value; }
auto forInternalCounter() { return value; }
Arithmetic& operator[]( int index ) { return value; }
operator Arithmetic() const { return value; }
auto forInternalCounter() { return value; }
private:
Arithmetic value;
};
......@@ -178,7 +193,7 @@ namespace Gaudi::Accumulators {
unsigned int computeIndex( const std::array<Axis<Arithmetic>, NIndex>& axis ) const {
return this->first.computeIndex( axis );
}
auto forInternalCounter() { return std::pair(this->first.forInternalCounter(), this->second); }
auto forInternalCounter() { return std::pair( this->first.forInternalCounter(), this->second ); }
};
/**
......@@ -204,13 +219,16 @@ namespace Gaudi::Accumulators {
public:
using BaseAccumulator = BaseAccumulatorT<Atomicity, Arithmetic>;
template <std::size_t... Is>
HistogramingAccumulatorInternal( std::initializer_list<Axis<Arithmetic>> axis, std::index_sequence<Is...> ) :
m_axis{{ *(axis.begin() + Is)... }}, m_totNBins{computeTotNBins()}, m_value( new BaseAccumulator[m_totNBins] ) {
HistogramingAccumulatorInternal( std::initializer_list<Axis<Arithmetic>> axis, std::index_sequence<Is...> )
: m_axis{{*( axis.begin() + Is )...}}
, m_totNBins{computeTotNBins()}
, m_value( new BaseAccumulator[m_totNBins] ) {
reset();
}
template <atomicity ato>
HistogramingAccumulatorInternal( construct_empty_t,
const HistogramingAccumulatorInternal<ato, InputType, Arithmetic, ND, BaseAccumulatorT>& other )
HistogramingAccumulatorInternal(
construct_empty_t,
const HistogramingAccumulatorInternal<ato, InputType, Arithmetic, ND, BaseAccumulatorT>& other )
: m_axis( other.m_axis ), m_totNBins{computeTotNBins()}, m_value( new BaseAccumulator[m_totNBins] ) {
reset();
}
......@@ -219,7 +237,7 @@ namespace Gaudi::Accumulators {
return *this;
}
void reset() {
for ( unsigned int index = 0; index < m_totNBins; index++ ) accumulator(index).reset();
for ( unsigned int index = 0; index < m_totNBins; index++ ) accumulator( index ).reset();
}
template <atomicity ato>
void mergeAndReset( HistogramingAccumulatorInternal<ato, InputType, Arithmetic, ND, BaseAccumulatorT>&& other ) {
......@@ -231,20 +249,20 @@ namespace Gaudi::Accumulators {
protected:
auto& axis() const { return m_axis; }
auto nBins( unsigned int i ) const { return m_axis[i].nBins; }
auto minValue( unsigned int i ) const { return m_axis[i].minValue; }
auto maxValue( unsigned int i ) const { return m_axis[i].maxValue; }
auto ratio( unsigned int i ) const { return m_axis[i].ratio; }
auto binValue( unsigned int i ) const { return accumulator( i ).value(); }
auto nEntries( unsigned int i ) const { return accumulator( i ).nEntries(); }
auto totNBins() const { return m_totNBins; }
auto nBins( unsigned int i ) const { return m_axis[i].nBins; }
auto minValue( unsigned int i ) const { return m_axis[i].minValue; }
auto maxValue( unsigned int i ) const { return m_axis[i].maxValue; }
auto ratio( unsigned int i ) const { return m_axis[i].ratio; }
auto binValue( unsigned int i ) const { return accumulator( i ).value(); }
auto nEntries( unsigned int i ) const { return accumulator( i ).nEntries(); }
auto totNBins() const { return m_totNBins; }
private:
BaseAccumulator& accumulator( unsigned int index ) const {
assert( index < m_totNBins );
return m_value[index];
}
unsigned int computeTotNBins() const {
unsigned int computeTotNBins() const {
unsigned int nTotBins = 1;
for ( unsigned int i = 0; i < ND::value; i++ ) { nTotBins *= ( m_axis[i].nBins + 2 ); }
return nTotBins;
......@@ -263,7 +281,8 @@ namespace Gaudi::Accumulators {
* Actually only an alias to HistogramingAccumulatorInternal with proper template parameters
*/
template <atomicity Atomicity, typename Arithmetic, typename ND>
using HistogramingAccumulator = HistogramingAccumulatorInternal<Atomicity, HistoInputType<Arithmetic, ND::value>, Arithmetic, ND, CountAccumulator>;
using HistogramingAccumulator = HistogramingAccumulatorInternal<Atomicity, HistoInputType<Arithmetic, ND::value>,
Arithmetic, ND, CountAccumulator>;
/**
* Class implementing a weighted histogram accumulator
......@@ -271,7 +290,9 @@ namespace Gaudi::Accumulators {
* Actually only an alias to HistogramingAccumulatorInternal with proper template parameters
*/
template <atomicity Atomicity, typename Arithmetic, typename ND>
using WeightedHistogramingAccumulator = HistogramingAccumulatorInternal<Atomicity, WeightedHistoInputType<Arithmetic, ND::value>, Arithmetic, ND, WeightedCountAccumulator>;
using WeightedHistogramingAccumulator =
HistogramingAccumulatorInternal<Atomicity, WeightedHistoInputType<Arithmetic, ND::value>, Arithmetic, ND,
WeightedCountAccumulator>;
/**
* Class implementing a profile histogram accumulator
......@@ -279,7 +300,9 @@ namespace Gaudi::Accumulators {
* Actually only an alias to HistogramingAccumulatorInternal with proper template parameters
*/
template <atomicity Atomicity, typename Arithmetic, typename ND>
using ProfileHistogramingAccumulator = HistogramingAccumulatorInternal<Atomicity, HistoInputType<Arithmetic, ND::value+1, ND::value>, Arithmetic, ND, SigmaAccumulator>;
using ProfileHistogramingAccumulator =
HistogramingAccumulatorInternal<Atomicity, HistoInputType<Arithmetic, ND::value + 1, ND::value>, Arithmetic, ND,
SigmaAccumulator>;
/**
* Class implementing a weighted profile histogram accumulator
......@@ -287,7 +310,9 @@ namespace Gaudi::Accumulators {
* Actually only an alias to HistogramingAccumulatorInternal with proper template parameters
*/
template <atomicity Atomicity, typename Arithmetic, typename ND>
using WeightedProfileHistogramingAccumulator = HistogramingAccumulatorInternal<Atomicity, WeightedHistoInputType<Arithmetic, ND::value+1, ND::value>, Arithmetic, ND, WeightedSigmaAccumulator>;
using WeightedProfileHistogramingAccumulator =
HistogramingAccumulatorInternal<Atomicity, WeightedHistoInputType<Arithmetic, ND::value + 1, ND::value>,
Arithmetic, ND, WeightedSigmaAccumulator>;
/**
* A base counter dealing with Histograms
......@@ -324,27 +349,27 @@ namespace Gaudi::Accumulators {
* All these types have the same fields, namely :
* dimension(integer), title(string), empty(bool), nEntries(integer), axis(array), bins(array)
* where :
* + axis is an array of tuples, one per dimension, with content (nBins(integer), minValue(number), maxValue(number), title(string))
* + axis is an array of tuples, one per dimension, with content (nBins(integer), minValue(number),
* maxValue(number), title(string))
* + bins is an array of values. The length of the array is the product of (nBins+2) for all axis
* the +2 is because the bin 0 is the one for values below minValue and bin nBins+1 is the one for values above maxValue
* bins are stored row first, so we iterate first on highest dimension
* For each bin the value is either a number (for non profile histograms) or a triplet (for profile histograms)
* containing (nEntries(integer), sum(number), sum2(number))
* the +2 is because the bin 0 is the one for values below minValue and bin nBins+1 is the one for values above
* maxValue bins are stored row first, so we iterate first on highest dimension For each bin the value is either a
* number (for non profile histograms) or a triplet (for profile histograms) containing (nEntries(integer),
* sum(number), sum2(number))
*/
template <unsigned int ND, atomicity Atomicity, typename Arithmetic, const char* Type,
template<atomicity, typename, typename> typename Accumulator>
template <atomicity, typename, typename> typename Accumulator>
class HistogramingCounterBase
: public BufferableCounter<Atomicity, Accumulator, Arithmetic, std::integral_constant<int, ND>> {
: public BufferableCounter<Atomicity, Accumulator, Arithmetic, std::integral_constant<int, ND>> {
public:
using Parent =
BufferableCounter<Atomicity, Accumulator, Arithmetic, std::integral_constant<int, ND>>;
using Parent = BufferableCounter<Atomicity, Accumulator, Arithmetic, std::integral_constant<int, ND>>;
template <typename OWNER>
HistogramingCounterBase( OWNER* owner, std::string const& name, std::string const& title,
std::initializer_list<Axis<Arithmetic>> axis )
: Parent( owner, name, Type, axis, std::make_index_sequence<ND>{} ), m_title( title ) {}
: Parent( owner, name, Type, axis, std::make_index_sequence<ND>{} ), m_title( title ) {}
template <typename OWNER>
HistogramingCounterBase( OWNER* owner, std::string const& name, std::string const& title, Axis<Arithmetic> axis )
: HistogramingCounterBase( owner, name, title, {axis} ) {}
: HistogramingCounterBase( owner, name, title, {axis} ) {}
using Parent::print;
template <typename stream>
stream& printImpl( stream& o, bool /*tableFormat*/ ) const {
......@@ -362,11 +387,11 @@ namespace Gaudi::Accumulators {
// get all bin values and compute total nbEntries
using Acc = Accumulator<Atomicity, Arithmetic, std::integral_constant<int, ND>>;
std::vector<typename Acc::BaseAccumulator::OutputType> bins;
bins.reserve(this->totNBins());
bins.reserve( this->totNBins() );
unsigned int totNEntries{0};
for (unsigned int i = 0; i < this->totNBins(); i++) {
bins.push_back(this->binValue(i));
totNEntries += this->nEntries(i);
for ( unsigned int i = 0; i < this->totNBins(); i++ ) {
bins.push_back( this->binValue( i ) );
totNEntries += this->nEntries( i );
}
// build json
return {{"type", Type},
......@@ -374,33 +399,37 @@ namespace Gaudi::Accumulators {
{"dimension", ND},
{"empty", totNEntries == Arithmetic{}},
{"nEntries", totNEntries},
{"axis", this->axis() },
{"bins", bins }};
{"axis", this->axis()},
{"bins", bins}};
}
private:
std::string const m_title;
};
namespace {
static const char histogramString[] = "histogram:Histogram";
static const char weightedHistogramString[] = "histogram:WeightedHistogram";
static const char profilehistogramString[] = "histogram:ProfileHistogram";
static const char histogramString[] = "histogram:Histogram";
static const char weightedHistogramString[] = "histogram:WeightedHistogram";
static const char profilehistogramString[] = "histogram:ProfileHistogram";
static const char weightedProfilehistogramString[] = "histogram:WeightedProfileHistogram";
}
} // namespace
/// standard histograming counter. See HistogramingCounterBase for details
template <unsigned int ND, atomicity Atomicity = atomicity::full, typename Arithmetic = double>
using Histogram = HistogramingCounterBase<ND, Atomicity, Arithmetic, histogramString, HistogramingAccumulator>;
/// standard histograming counter with weight. See HistogramingCounterBase for details
template <unsigned int ND, atomicity Atomicity = atomicity::full, typename Arithmetic = double>
using WeightedHistogram = HistogramingCounterBase<ND, Atomicity, Arithmetic, weightedHistogramString, WeightedHistogramingAccumulator>;
using WeightedHistogram =
HistogramingCounterBase<ND, Atomicity, Arithmetic, weightedHistogramString, WeightedHistogramingAccumulator>;
/// profile histograming counter. See HistogramingCounterBase for details
template <unsigned int ND, atomicity Atomicity = atomicity::full, typename Arithmetic = double>
using ProfileHistogram = HistogramingCounterBase<ND, Atomicity, Arithmetic, profilehistogramString, ProfileHistogramingAccumulator>;
using ProfileHistogram =
HistogramingCounterBase<ND, Atomicity, Arithmetic, profilehistogramString, ProfileHistogramingAccumulator>;
/// weighted profile histograming counter. See HistogramingCounterBase for details
template <unsigned int ND, atomicity Atomicity = atomicity::full, typename Arithmetic = double>
using WeightedProfileHistogram = HistogramingCounterBase<ND, Atomicity, Arithmetic, weightedProfilehistogramString, WeightedProfileHistogramingAccumulator>;
using WeightedProfileHistogram = HistogramingCounterBase<ND, Atomicity, Arithmetic, weightedProfilehistogramString,
WeightedProfileHistogramingAccumulator>;
} // namespace Gaudi::Accumulators
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment