diff --git a/Muon/MuonMonitors/src/MuonChamberMonitor.cpp b/Muon/MuonMonitors/src/MuonChamberMonitor.cpp index d7bf62fb4a203454d4f3cc2fcdaeb24ab193a4b5..db5052f6c2b3d633f80198f93f3b9ee417178c9c 100644 --- a/Muon/MuonMonitors/src/MuonChamberMonitor.cpp +++ b/Muon/MuonMonitors/src/MuonChamberMonitor.cpp @@ -12,7 +12,8 @@ #include "DetDesc/DetectorElement.h" #include "Event/State.h" #include "Event/Track_v3.h" -#include "Gaudi/Accumulators/Histogram.h" +#include "Gaudi/Accumulators/HistogramArray.h" +#include "Gaudi/Accumulators/StaticHistogram.h" #include "LHCbMath/FastMaths.h" #include "TrackInterfaces/ITrackExtrapolator.h" #include "TrackKernel/TrackFunctors.h" @@ -59,22 +60,25 @@ namespace { enum ArrayType { Quadrant, Station, Region, StationRegion }; + std::string quadrantName( unsigned int q ) { return fmt::format( "Q{}", q + 1 ); } + std::string stationName( unsigned int s ) { return fmt::format( "M{}", s + 2 ); } + std::string regionName( unsigned int r ) { return fmt::format( "R{}", r + 1 ); } std::vector HistNameWriter( ArrayType type ) { std::vector labels; switch ( type ) { case ArrayType::Quadrant: - for ( unsigned int q = 0; q < 4; q++ ) labels.push_back( fmt::format( "Q{}", q + 1 ) ); + for ( unsigned int q = 0; q < 4; q++ ) labels.push_back( quadrantName( q ) ); break; case ArrayType::Station: - for ( unsigned int s = 0; s < 4; s++ ) labels.push_back( fmt::format( "M{}", s + 2 ) ); + for ( unsigned int s = 0; s < 4; s++ ) labels.push_back( stationName( s ) ); break; case ArrayType::Region: - for ( unsigned int r = 0; r < 4; r++ ) labels.push_back( fmt::format( "R{}", r + 1 ) ); + for ( unsigned int r = 0; r < 4; r++ ) labels.push_back( regionName( r ) ); break; case ArrayType::StationRegion: for ( unsigned int s = 0; s < 4; s++ ) { - for ( unsigned int r = 0; r < 4; r++ ) { labels.push_back( fmt::format( "M{}R{}", s + 2, r + 1 ) ); } + for ( unsigned int r = 0; r < 4; r++ ) { labels.push_back( stationName( s ) + regionName( r ) ); } } break; } @@ -217,59 +221,35 @@ namespace LHCb { // Histograms struct Histograms { // Activity histograms - mutable Gaudi::Accumulators::Histogram<1> m_tagsP; - mutable Gaudi::Accumulators::Histogram<1> m_tagsPT; - mutable Gaudi::Accumulators::Histogram<1> m_tagPsRapidity; - mutable Gaudi::Accumulators::Histogram<1> m_ntags; - - mutable Gaudi::Accumulators::Histogram<1> m_probesP; - mutable Gaudi::Accumulators::Histogram<1> m_probesPT; - mutable Gaudi::Accumulators::Histogram<1> m_probePsRapidity; - mutable Gaudi::Accumulators::Histogram<2> m_probeExtrap; - - mutable Gaudi::Accumulators::Histogram<1> m_denStation; - mutable Gaudi::Accumulators::Histogram<1> m_numStation; - mutable Gaudi::Accumulators::Histogram<1> m_denStationRegion; - mutable Gaudi::Accumulators::Histogram<1> m_numStationRegion; - - mutable Gaudi::Accumulators::Histogram<2> m_errXY2; - mutable std::array, 4> m_Chi2StationX; - mutable std::array, 4> m_Chi2StationY; - mutable std::array, 144> m_hTimeODE; - - mutable Gaudi::Accumulators::Histogram<2> m_HitsInExtrap; - mutable Gaudi::Accumulators::Histogram<2> m_HitsInBkg; - mutable Gaudi::Accumulators::Histogram<2> m_HitsInExtrapSub; - mutable Gaudi::Accumulators::Histogram<2> m_edgeEffect; - - mutable std::array, 16> m_denChamb; - mutable std::array, 16> m_numChamb; - mutable std::array, 16> m_denChamb2D; - mutable std::array, 16> m_numChamb2D; - - // Builder for array of 1D histos with different ranges - template - static std::array, sizeof...( IDXs )> - histoArrayBuilder( const MuonChamberMonitor* owner, ArrayType type, const std::string& name, - const std::string& title, std::tuple xbins, - std::index_sequence ) { - std::vector labels = HistNameWriter( type ); - return { { { owner, - name + labels[IDXs], - title + labels[IDXs], - { std::get<0>( xbins ), std::get<1>( xbins ), std::get<2>( xbins ) } }... } }; - } - - template - static std::array, sizeof...( IDXs )> histoArrayBuilder( - const MuonChamberMonitor* owner, ArrayType type, const std::string& name, const std::string& title, - std::array, sizeof...( IDXs )> xbins, std::index_sequence ) { - std::vector labels = HistNameWriter( type ); - return { { { owner, - name + labels[IDXs], - title + labels[IDXs], - { std::get<0>( xbins[IDXs] ), std::get<1>( xbins[IDXs] ), std::get<2>( xbins[IDXs] ) } }... } }; - } + mutable Gaudi::Accumulators::StaticHistogram<1> m_tagsP; + mutable Gaudi::Accumulators::StaticHistogram<1> m_tagsPT; + mutable Gaudi::Accumulators::StaticHistogram<1> m_tagPsRapidity; + mutable Gaudi::Accumulators::StaticHistogram<1> m_ntags; + + mutable Gaudi::Accumulators::StaticHistogram<1> m_probesP; + mutable Gaudi::Accumulators::StaticHistogram<1> m_probesPT; + mutable Gaudi::Accumulators::StaticHistogram<1> m_probePsRapidity; + mutable Gaudi::Accumulators::StaticHistogram<2> m_probeExtrap; + + mutable Gaudi::Accumulators::StaticHistogram<1> m_denStation; + mutable Gaudi::Accumulators::StaticHistogram<1> m_numStation; + mutable Gaudi::Accumulators::StaticHistogram<1> m_denStationRegion; + mutable Gaudi::Accumulators::StaticHistogram<1> m_numStationRegion; + + mutable Gaudi::Accumulators::StaticHistogram<2> m_errXY2; + mutable Gaudi::Accumulators::HistogramArray, 4> m_Chi2StationX; + mutable Gaudi::Accumulators::HistogramArray, 4> m_Chi2StationY; + mutable Gaudi::Accumulators::HistogramArray, 144> m_hTimeODE; + + mutable Gaudi::Accumulators::StaticHistogram<2> m_HitsInExtrap; + mutable Gaudi::Accumulators::StaticHistogram<2> m_HitsInBkg; + mutable Gaudi::Accumulators::StaticHistogram<2> m_HitsInExtrapSub; + mutable Gaudi::Accumulators::StaticHistogram<2> m_edgeEffect; + + mutable Gaudi::Accumulators::HistogramArray, 16> m_denChamb; + mutable Gaudi::Accumulators::HistogramArray, 16> m_numChamb; + mutable std::array, 16> m_denChamb2D; + mutable std::array, 16> m_numChamb2D; // Builder for array of 1D histos with known labels and fixed ranges template @@ -285,7 +265,7 @@ namespace LHCb { // Builder for array of 2D histos with different ranges template - static std::array, sizeof...( IDXs )> histoArrayBuilder( + static std::array, sizeof...( IDXs )> histoArrayBuilder( const MuonChamberMonitor* owner, ArrayType type, const std::string& name, const std::string& title, std::array, sizeof...( IDXs )> xbins, std::array, sizeof...( IDXs )> ybins, std::index_sequence ) { @@ -297,33 +277,6 @@ namespace LHCb { { std::get<0>( ybins[IDXs] ), std::get<1>( ybins[IDXs] ), std::get<2>( ybins[IDXs] ) } }... } }; } - // Builder for array of 2D histos with fixed ranges - template - static std::array, sizeof...( IDXs )> - histoArrayBuilder( const MuonChamberMonitor* owner, ArrayType type, const std::string& name, - const std::string& title, std::tuple xbins, - std::tuple ybins, std::index_sequence ) { - std::vector labels = HistNameWriter( type ); - return { { { owner, - name + labels[IDXs], - title + labels[IDXs], - { std::get<0>( xbins ), std::get<1>( xbins ), std::get<2>( xbins ) }, - { std::get<0>( ybins ), std::get<1>( ybins ), std::get<2>( ybins ) } }... } }; - } - - // Builder for array of 2D histos with known labels and fixed range - template - static std::array, sizeof...( IDXs )> - histoArrayBuilder( const MuonChamberMonitor* owner, const std::string& name, const std::string& title, - std::vector labels, std::tuple xbins, - std::tuple ybins, std::index_sequence ) { - return { { { owner, - name + labels[IDXs], - title + labels[IDXs], - { std::get<0>( xbins ), std::get<1>( xbins ), std::get<2>( xbins ) }, - { std::get<0>( ybins ), std::get<1>( ybins ), std::get<2>( ybins ) } }... } }; - } - Histograms( const MuonChamberMonitor* owner, const GeomCache& geometryinfo ) : m_tagsP{ owner, "tags_P", "Momentum of tag particles", { 1000, 0.0, 100000 } } , m_tagsPT{ owner, "tags_PT", "Trnsverse momentum of tag particles", { 100, 0.5, 10000 } } @@ -358,12 +311,19 @@ namespace LHCb { { nRegions * nMuonStations, -0.5, nRegions * nMuonStations - 0.5, "", HistNameWriter( ArrayType::StationRegion ) } } , m_errXY2{ owner, "errXY2", "MS error XY2", { 300, 0.0, 30.0 }, { 300, 0.0, 30.0 } } - , m_Chi2StationX{ histoArrayBuilder( owner, ArrayType::Station, "chi2X_", "Chi2X of closest hit in station_", - { 500, 0., 1000. }, std::make_index_sequence<4>() ) } - , m_Chi2StationY{ histoArrayBuilder( owner, ArrayType::Station, "chi2Y_", "Chi2Y of closest hit in station_", - { 500, 0., 1000. }, std::make_index_sequence<4>() ) } - , m_hTimeODE{ histoArrayBuilder( owner, "TDCTimeByODE/", "TDC time in ODE ", geometryinfo.m_ODEnames, - { 16, -12.5, 12.5 }, std::make_index_sequence<144>() ) } + , m_Chi2StationX{ owner, + []( unsigned int idx ) { return "chi2X_" + stationName( idx ); }, + []( unsigned int idx ) { return "Chi2X of closest hit in station_" + stationName( idx ); }, + { 500, 0.0, 1000.0 } } + , m_Chi2StationY{ owner, + []( unsigned int idx ) { return "chi2Y_" + stationName( idx ); }, + []( unsigned int idx ) { return "Chi2Y of closest hit in station_" + stationName( idx ); }, + { 500, 0.0, 1000.0 } } + , m_hTimeODE{ + owner, + [&geometryinfo]( unsigned int idx ) { return "TDCTimeByODE/" + geometryinfo.m_ODEnames[idx]; }, + [&geometryinfo]( unsigned int idx ) { return "TDC time in ODE " + geometryinfo.m_ODEnames[idx]; }, + { 16, -12.5, 12.5 } } , m_HitsInExtrap{ owner, "HitsInExtrap", "All hits in chi2 area", @@ -389,10 +349,24 @@ namespace LHCb { HistNameWriter( ArrayType::StationRegion ) }, { 4, -1.0, 3.0 } } - , m_denChamb{ histoArrayBuilder( owner, ArrayType::StationRegion, "denChamb_", "Denominator chambers_", - { 200, 0.0, 200.0 }, std::make_index_sequence<16>() ) } - , m_numChamb{ histoArrayBuilder( owner, ArrayType::StationRegion, "numChamb_", "Numerator chambers_", - { 200, 0.0, 200.0 }, std::make_index_sequence<16>() ) } + , m_denChamb{ owner, + []( unsigned int idx ) { + return "denChamb_" + stationName( idx / nRegions ) + regionName( idx % nRegions ); + }, + []( unsigned int idx ) { + return "Denominator chambers_M{}R{}" + stationName( idx / nRegions ) + + regionName( idx % nRegions ); + }, + { 200, 0.0, 200.0 } } + , m_numChamb{ owner, + []( unsigned int idx ) { + return "numChamb_" + stationName( idx / nRegions ) + regionName( idx % nRegions ); + }, + []( unsigned int idx ) { + return "Numerator chambers_M{}R{}" + stationName( idx / nRegions ) + + regionName( idx % nRegions ); + }, + { 200, 0.0, 200.0 } } , m_denChamb2D{ histoArrayBuilder( owner, ArrayType::StationRegion, "denChamb2D_", "Denominator chambers 2D_", geometryinfo.m_chambersInRegion.first, geometryinfo.m_chambersInRegion.second, std::make_index_sequence<16>() ) } @@ -542,7 +516,7 @@ namespace LHCb { chamberMatched = false; ++m_histos->m_edgeEffect[{ candMuon.m_idReg[s], 0 }]; } - unsigned int chitRegId = s * nMuonStations + candMuon.m_chitReg[s]; + unsigned int chitRegId = s * nRegions + candMuon.m_chitReg[s]; ++m_histos->m_denStation[s]; ++m_histos->m_denStationRegion[chitRegId]; if ( chamberMatched ) { diff --git a/Muon/MuonPIDChecker/src/MuonPIDChecker.cpp b/Muon/MuonPIDChecker/src/MuonPIDChecker.cpp index a121840abfbed21fe29cfe81ce71654c6c6b78fb..ff33f19c068ebde726be7fdea8a7679de3f5f678 100644 --- a/Muon/MuonPIDChecker/src/MuonPIDChecker.cpp +++ b/Muon/MuonPIDChecker/src/MuonPIDChecker.cpp @@ -23,8 +23,8 @@ #include "Detector/Muon/MuonConstants.h" -#include "Gaudi/Accumulators/Histogram.h" #include "Gaudi/Accumulators/HistogramArray.h" +#include "Gaudi/Accumulators/StaticHistogram.h" #include #include @@ -135,14 +135,14 @@ namespace LHCb { mutable Gaudi::Accumulators::MsgCounter m_extrapolateFailed{ this, "getTrackInfo:: Failed to extrapolate track" }; - using OptHisto1D = std::optional>; - using OptProfHisto1D = std::optional>; - using OptHisto1DArray = - std::optional, Detector::Muon::nRegions>>; + using OptHisto1D = std::optional>; + using OptProfHisto1D = std::optional>; + using OptHisto1DArray = std::optional< + Gaudi::Accumulators::HistogramArray, Detector::Muon::nRegions>>; using OptProfHisto1DArray = std::optional< - Gaudi::Accumulators::HistogramArray, Detector::Muon::nStations>>; + Gaudi::Accumulators::HistogramArray, Detector::Muon::nStations>>; using OptHisto2DArray = std::optional< - Gaudi::Accumulators::HistogramArray, Detector::Muon::nStations>>; + Gaudi::Accumulators::HistogramArray, Detector::Muon::nStations>>; // Histograms for HistosOutput level >= 1 mutable OptHisto1D m_hNIMLtracks; mutable OptHisto1D m_hNIMtracks; diff --git a/Muon/MuonTrackMonitor/src/MuonTrackAligMonitor.cpp b/Muon/MuonTrackMonitor/src/MuonTrackAligMonitor.cpp index d05aae32df9390cea94b5a5f52c3a4b6fc0f4a14..d554da32be53ed6ecc4bda16deeacf5af8840c07 100644 --- a/Muon/MuonTrackMonitor/src/MuonTrackAligMonitor.cpp +++ b/Muon/MuonTrackMonitor/src/MuonTrackAligMonitor.cpp @@ -20,8 +20,8 @@ #include "TrackInterfaces/ITrackExtrapolator.h" #include "TrackKernel/TrackFunctors.h" -#include "Gaudi/Accumulators/Histogram.h" #include "Gaudi/Accumulators/HistogramArray.h" +#include "Gaudi/Accumulators/StaticHistogram.h" #include "LHCbAlgs/Consumer.h" #include @@ -48,11 +48,11 @@ namespace LHCb { MuonZM1 const& ) const override; private: - using OptHisto1D = std::optional>; - using OptProfHisto1D = std::optional>; + using OptHisto1D = std::optional>; + using OptProfHisto1D = std::optional>; using OptHisto1DArray = std::optional< - Gaudi::Accumulators::HistogramArray, Detector::Muon::nStations>>; - using OptHisto2D = std::optional>; + Gaudi::Accumulators::HistogramArray, Detector::Muon::nStations>>; + using OptHisto2D = std::optional>; mutable OptHisto1D m_h_p, m_h_chi2; mutable OptHisto1D m_p_resxx, m_p_resxy, m_p_resxtx, m_p_resxty, m_p_restxx, m_p_restxy, m_p_restxtx, m_p_restxty, m_p_resyx, m_p_resyy, m_p_resytx, m_p_resyty, m_p_restyx, m_p_restyy, m_p_restytx, m_p_restyty, m_resxhsL, diff --git a/Phys/ParticleMatching/src/KSVelo2LongEfficiencyMonitor.cpp b/Phys/ParticleMatching/src/KSVelo2LongEfficiencyMonitor.cpp index a6c56a6a3bb1c584b50613e0131266bcbe4a9263..ea4af124b95937c7d6e180b526f457d5a92ff13d 100644 --- a/Phys/ParticleMatching/src/KSVelo2LongEfficiencyMonitor.cpp +++ b/Phys/ParticleMatching/src/KSVelo2LongEfficiencyMonitor.cpp @@ -33,74 +33,69 @@ public: : Consumer( name, pSvc, { KeyValue{ "Particles", "" }, KeyValue{ "Table", "" } } ) {} StatusCode initialize() override { - auto sc = Consumer::initialize(); - if ( sc.isFailure() ) return sc; - using Axis1D = Gaudi::Accumulators::Axis; - m_efficiency_vs_p.emplace( this, "EfficiencyVsP", m_histodef_eff_p.value().title(), - Axis1D{ static_cast( m_histodef_eff_p.value().bins() ), - m_histodef_eff_p.value().lowEdge(), m_histodef_eff_p.value().highEdge() } ); - m_efficiency_vs_pt.emplace( this, "EfficiencyVsPt", m_histodef_eff_pt.value().title(), - Axis1D{ static_cast( m_histodef_eff_pt.value().bins() ), - m_histodef_eff_pt.value().lowEdge(), m_histodef_eff_pt.value().highEdge() } ); - m_efficiency_vs_eta.emplace( this, "EfficiencyVsEta", m_histodef_eff_eta.value().title(), - Axis1D{ static_cast( m_histodef_eff_eta.value().bins() ), - m_histodef_eff_eta.value().lowEdge(), - m_histodef_eff_eta.value().highEdge() } ); - m_efficiency_vs_phi.emplace( this, "EfficiencyVsPhi", m_histodef_eff_phi.value().title(), - Axis1D{ static_cast( m_histodef_eff_phi.value().bins() ), - m_histodef_eff_phi.value().lowEdge(), - m_histodef_eff_phi.value().highEdge() } ); - - m_efficiency_vs_p_den.emplace( this, "EfficiencyVsP_den", m_histodef_eff_p.value().title() + "_den", - Axis1D{ static_cast( m_histodef_eff_p.value().bins() ), - m_histodef_eff_p.value().lowEdge(), m_histodef_eff_p.value().highEdge() } ); - m_efficiency_vs_pt_den.emplace( this, "EfficiencyVsPt_den", m_histodef_eff_pt.value().title() + "_den", - Axis1D{ static_cast( m_histodef_eff_pt.value().bins() ), - m_histodef_eff_pt.value().lowEdge(), - m_histodef_eff_pt.value().highEdge() } ); - m_efficiency_vs_eta_den.emplace( this, "EfficiencyVsEta_den", m_histodef_eff_eta.value().title() + "_den", - Axis1D{ static_cast( m_histodef_eff_eta.value().bins() ), - m_histodef_eff_eta.value().lowEdge(), - m_histodef_eff_eta.value().highEdge() } ); - m_efficiency_vs_phi_den.emplace( this, "EfficiencyVsPhi_den", m_histodef_eff_phi.value().title() + "_den", - Axis1D{ static_cast( m_histodef_eff_phi.value().bins() ), - m_histodef_eff_phi.value().lowEdge(), - m_histodef_eff_phi.value().highEdge() } ); - - m_efficiency_vs_p_num.emplace( this, "EfficiencyVsP_num", m_histodef_eff_p.value().title() + "_num", - Axis1D{ static_cast( m_histodef_eff_p.value().bins() ), - m_histodef_eff_p.value().lowEdge(), m_histodef_eff_p.value().highEdge() } ); - m_efficiency_vs_pt_num.emplace( this, "EfficiencyVsPt_num", m_histodef_eff_pt.value().title() + "_num", - Axis1D{ static_cast( m_histodef_eff_pt.value().bins() ), - m_histodef_eff_pt.value().lowEdge(), - m_histodef_eff_pt.value().highEdge() } ); - m_efficiency_vs_eta_num.emplace( this, "EfficiencyVsEta_num", m_histodef_eff_eta.value().title() + "_num", - Axis1D{ static_cast( m_histodef_eff_eta.value().bins() ), - m_histodef_eff_eta.value().lowEdge(), - m_histodef_eff_eta.value().highEdge() } ); - m_efficiency_vs_phi_num.emplace( this, "EfficiencyVsPhi_num", m_histodef_eff_phi.value().title() + "_num", - Axis1D{ static_cast( m_histodef_eff_phi.value().bins() ), - m_histodef_eff_phi.value().lowEdge(), - m_histodef_eff_phi.value().highEdge() } ); - - m_efficiency_vs_eta_p.emplace( this, "EfficiencyVsEtaP", m_histodef_eff_eta.value().title(), - Axis1D{ static_cast( m_histodef_eff_eta.value().bins() / 2 ), + return Consumer::initialize().andThen( [&] { + m_efficiency_vs_p.setTitle( m_histodef_eff_p.value().title() ); + m_efficiency_vs_p.setAxis<0>( { static_cast( m_histodef_eff_p.value().bins() ), + m_histodef_eff_p.value().lowEdge(), m_histodef_eff_p.value().highEdge() } ); + m_efficiency_vs_pt.setTitle( m_histodef_eff_pt.value().title() ); + m_efficiency_vs_pt.setAxis<0>( { static_cast( m_histodef_eff_pt.value().bins() ), + m_histodef_eff_pt.value().lowEdge(), m_histodef_eff_pt.value().highEdge() } ); + m_efficiency_vs_eta.setTitle( m_histodef_eff_eta.value().title() ); + m_efficiency_vs_eta.setAxis<0>( { static_cast( m_histodef_eff_eta.value().bins() ), + m_histodef_eff_eta.value().lowEdge(), m_histodef_eff_eta.value().highEdge() } ); + m_efficiency_vs_phi.setAxis<0>( { static_cast( m_histodef_eff_phi.value().bins() ), + m_histodef_eff_phi.value().lowEdge(), m_histodef_eff_phi.value().highEdge() } ); + + m_efficiency_vs_p_den.setTitle( m_histodef_eff_p.value().title() + "_den" ); + m_efficiency_vs_p_den.setAxis<0>( { static_cast( m_histodef_eff_p.value().bins() ), + m_histodef_eff_p.value().lowEdge(), m_histodef_eff_p.value().highEdge() } ); + m_efficiency_vs_pt_den.setTitle( m_histodef_eff_pt.value().title() + "_den" ); + m_efficiency_vs_pt_den.setAxis<0>( { static_cast( m_histodef_eff_pt.value().bins() ), + m_histodef_eff_pt.value().lowEdge(), + m_histodef_eff_pt.value().highEdge() } ); + m_efficiency_vs_eta_den.setTitle( m_histodef_eff_eta.value().title() + "_den" ); + m_efficiency_vs_eta_den.setAxis<0>( { static_cast( m_histodef_eff_eta.value().bins() ), + m_histodef_eff_eta.value().lowEdge(), + m_histodef_eff_eta.value().highEdge() } ); + m_efficiency_vs_phi_den.setTitle( m_histodef_eff_phi.value().title() + "_den" ); + m_efficiency_vs_phi_den.setAxis<0>( { static_cast( m_histodef_eff_phi.value().bins() ), + m_histodef_eff_phi.value().lowEdge(), + m_histodef_eff_phi.value().highEdge() } ); + + m_efficiency_vs_p_num.setTitle( m_histodef_eff_p.value().title() + "_num" ); + m_efficiency_vs_p_num.setAxis<0>( { static_cast( m_histodef_eff_p.value().bins() ), + m_histodef_eff_p.value().lowEdge(), m_histodef_eff_p.value().highEdge() } ); + m_efficiency_vs_pt_num.setTitle( m_histodef_eff_pt.value().title() + "_num" ); + m_efficiency_vs_pt_num.setAxis<0>( { static_cast( m_histodef_eff_pt.value().bins() ), + m_histodef_eff_pt.value().lowEdge(), + m_histodef_eff_pt.value().highEdge() } ); + m_efficiency_vs_eta_num.setTitle( m_histodef_eff_eta.value().title() + "_num" ); + m_efficiency_vs_eta_num.setAxis<0>( { static_cast( m_histodef_eff_eta.value().bins() ), + m_histodef_eff_eta.value().lowEdge(), + m_histodef_eff_eta.value().highEdge() } ); + m_efficiency_vs_phi_num.setTitle( m_histodef_eff_phi.value().title() + "_num" ); + m_efficiency_vs_phi_num.setAxis<0>( { static_cast( m_histodef_eff_phi.value().bins() ), + m_histodef_eff_phi.value().lowEdge(), + m_histodef_eff_phi.value().highEdge() } ); + + m_efficiency_vs_eta_p.setTitle( m_histodef_eff_eta.value().title() ); + m_efficiency_vs_eta_p.setAxis<0>( { static_cast( m_histodef_eff_eta.value().bins() / 2 ), + m_histodef_eff_eta.value().lowEdge(), + m_histodef_eff_eta.value().highEdge() } ); + m_efficiency_vs_eta_p.setAxis<1>( { static_cast( m_histodef_eff_p.value().bins() / 2 ), + m_histodef_eff_p.value().lowEdge(), m_histodef_eff_p.value().highEdge() } ); + m_efficiency_vs_eta_pt.setTitle( m_histodef_eff_eta.value().title() ); + m_efficiency_vs_eta_pt.setAxis<0>( { static_cast( m_histodef_eff_eta.value().bins() / 2 ), m_histodef_eff_eta.value().lowEdge(), - m_histodef_eff_eta.value().highEdge() }, - Axis1D{ static_cast( m_histodef_eff_p.value().bins() / 2 ), - m_histodef_eff_p.value().lowEdge(), m_histodef_eff_p.value().highEdge() } ); - m_efficiency_vs_eta_pt.emplace( - this, "EfficiencyVsEtaPt", m_histodef_eff_eta.value().title(), - Axis1D{ static_cast( m_histodef_eff_eta.value().bins() / 2 ), - m_histodef_eff_eta.value().lowEdge(), m_histodef_eff_eta.value().highEdge() }, - Axis1D{ static_cast( m_histodef_eff_pt.value().bins() / 2 ), m_histodef_eff_pt.value().lowEdge(), - m_histodef_eff_pt.value().highEdge() } ); - m_mass_unmatched_vs_momentum.emplace( this, "MassVsMomentum", "MassVsMomentum", - Axis1D{ static_cast( m_histodef_eff_p.value().bins() ), - m_histodef_eff_p.value().lowEdge(), - m_histodef_eff_p.value().highEdge() }, - Axis1D{ 200, 400., 600. } ); - return sc; + m_histodef_eff_eta.value().highEdge() } ); + m_efficiency_vs_eta_pt.setAxis<1>( { static_cast( m_histodef_eff_pt.value().bins() / 2 ), + m_histodef_eff_pt.value().lowEdge(), + m_histodef_eff_pt.value().highEdge() } ); + m_mass_unmatched_vs_momentum.setAxis<0>( { static_cast( m_histodef_eff_p.value().bins() ), + m_histodef_eff_p.value().lowEdge(), + m_histodef_eff_p.value().highEdge() } ); + m_mass_unmatched_vs_momentum.setAxis<1>( { 200, 400., 600. } ); + } ); } void operator()( const LHCb::Particle::Range& particles, const WeightedRelationTable& matching_table ) const override { @@ -118,7 +113,7 @@ public: } auto probe_momentum = particle->momentum() - tag->momentum(); - ++( *m_mass_unmatched_vs_momentum )[{ probe_momentum.P() / 1000., particle->momentum().M() }]; + ++m_mass_unmatched_vs_momentum[{ probe_momentum.P() / 1000., particle->momentum().M() }]; double mass_window_size = m_signal_mass_range.value().second - m_signal_mass_range.value().first; bool is_signal = particle->momentum().M() > m_signal_mass_range.value().first && @@ -133,10 +128,10 @@ public: m_probe_p[probe_momentum.P()] += weight; m_probe_pt[probe_momentum.Pt()] += weight; m_probe_eta[probe_momentum.Eta()] += weight; - ( *m_efficiency_vs_p_den )[probe_momentum.P() / 1000.] += weight; - ( *m_efficiency_vs_pt_den )[probe_momentum.Pt() / 1000.] += weight; - ( *m_efficiency_vs_eta_den )[probe_momentum.Eta()] += weight; - ( *m_efficiency_vs_phi_den )[probe_momentum.Phi()] += weight; + m_efficiency_vs_p_den[probe_momentum.P() / 1000.] += weight; + m_efficiency_vs_pt_den[probe_momentum.Pt() / 1000.] += weight; + m_efficiency_vs_eta_den[probe_momentum.Eta()] += weight; + m_efficiency_vs_phi_den[probe_momentum.Phi()] += weight; float matched = 0.; auto const& matches = matching_table.relations( probe ); int n_fthits = 0; @@ -166,18 +161,18 @@ public: m_efficiency += weight * matched; // no background subtraction here if ( is_signal ) { - ( *m_efficiency_vs_p )[probe_momentum.P() / 1000.] += matched; - ( *m_efficiency_vs_pt )[probe_momentum.Pt() / 1000.] += matched; - ( *m_efficiency_vs_eta )[probe_momentum.Eta()] += matched; - ( *m_efficiency_vs_phi )[probe_momentum.Phi()] += matched; - ( *m_efficiency_vs_eta_p )[{ probe_momentum.Eta(), probe_momentum.P() / 1000. }] += matched; - ( *m_efficiency_vs_eta_pt )[{ probe_momentum.Eta(), probe_momentum.Pt() / 1000. }] += matched; + m_efficiency_vs_p[probe_momentum.P() / 1000.] += matched; + m_efficiency_vs_pt[probe_momentum.Pt() / 1000.] += matched; + m_efficiency_vs_eta[probe_momentum.Eta()] += matched; + m_efficiency_vs_phi[probe_momentum.Phi()] += matched; + m_efficiency_vs_eta_p[{ probe_momentum.Eta(), probe_momentum.P() / 1000. }] += matched; + m_efficiency_vs_eta_pt[{ probe_momentum.Eta(), probe_momentum.Pt() / 1000. }] += matched; } if ( matched > 0.0 ) { - ( *m_efficiency_vs_p_num )[probe_momentum.P() / 1000.] += weight; - ( *m_efficiency_vs_pt_num )[probe_momentum.Pt() / 1000.] += weight; - ( *m_efficiency_vs_eta_num )[probe_momentum.Eta()] += weight; - ( *m_efficiency_vs_phi_num )[probe_momentum.Phi()] += weight; + m_efficiency_vs_p_num[probe_momentum.P() / 1000.] += weight; + m_efficiency_vs_pt_num[probe_momentum.Pt() / 1000.] += weight; + m_efficiency_vs_eta_num[probe_momentum.Eta()] += weight; + m_efficiency_vs_phi_num[probe_momentum.Phi()] += weight; m_fthits[n_fthits] += weight; } } @@ -203,7 +198,7 @@ private: mutable Gaudi::Accumulators::Histogram<1> m_fthits{ this, "n_fthits", "n_fthits", { 10, 5.5, 15.5 } }; - mutable std::optional> m_mass_unmatched_vs_momentum; + mutable Gaudi::Accumulators::Histogram<2> m_mass_unmatched_vs_momentum{ this, "MassVsMomentum", "MassVsMomentum" }; Gaudi::Property m_histodef_eff_p{ this, "HistogramDefEffP", { "Efficiency versus p [GeV]", 2., 50., 24 }, "Histogram definition" }; @@ -217,23 +212,23 @@ private: { "Efficiency versus phi", -std::numbers::pi, std::numbers::pi, 24 }, "Histogram definition" }; - mutable std::optional> m_efficiency_vs_p; - mutable std::optional> m_efficiency_vs_pt; - mutable std::optional> m_efficiency_vs_eta; - mutable std::optional> m_efficiency_vs_phi; + mutable Gaudi::Accumulators::ProfileHistogram<1> m_efficiency_vs_p{ this, "EfficiencyVsP" }; + mutable Gaudi::Accumulators::ProfileHistogram<1> m_efficiency_vs_pt{ this, "EfficiencyVsPt" }; + mutable Gaudi::Accumulators::ProfileHistogram<1> m_efficiency_vs_eta{ this, "EfficiencyVsEta" }; + mutable Gaudi::Accumulators::ProfileHistogram<1> m_efficiency_vs_phi{ this, "EfficiencyVsPhi" }; - mutable std::optional> m_efficiency_vs_p_den; - mutable std::optional> m_efficiency_vs_pt_den; - mutable std::optional> m_efficiency_vs_eta_den; - mutable std::optional> m_efficiency_vs_phi_den; + mutable Gaudi::Accumulators::Histogram<1> m_efficiency_vs_p_den{ this, "EfficiencyVsP_den" }; + mutable Gaudi::Accumulators::Histogram<1> m_efficiency_vs_pt_den{ this, "EfficiencyVsPt_den" }; + mutable Gaudi::Accumulators::Histogram<1> m_efficiency_vs_eta_den{ this, "EfficiencyVsEta_den" }; + mutable Gaudi::Accumulators::Histogram<1> m_efficiency_vs_phi_den{ this, "EfficiencyVsPhi_den" }; - mutable std::optional> m_efficiency_vs_p_num; - mutable std::optional> m_efficiency_vs_pt_num; - mutable std::optional> m_efficiency_vs_eta_num; - mutable std::optional> m_efficiency_vs_phi_num; + mutable Gaudi::Accumulators::Histogram<1> m_efficiency_vs_p_num{ this, "EfficiencyVsP_num" }; + mutable Gaudi::Accumulators::Histogram<1> m_efficiency_vs_pt_num{ this, "EfficiencyVsPt_num" }; + mutable Gaudi::Accumulators::Histogram<1> m_efficiency_vs_eta_num{ this, "EfficiencyVsEta_num" }; + mutable Gaudi::Accumulators::Histogram<1> m_efficiency_vs_phi_num{ this, "EfficiencyVsPhi_num" }; - mutable std::optional> m_efficiency_vs_eta_p; - mutable std::optional> m_efficiency_vs_eta_pt; + mutable Gaudi::Accumulators::ProfileHistogram<2> m_efficiency_vs_eta_p{ this, "EfficiencyVsEtaP" }; + mutable Gaudi::Accumulators::ProfileHistogram<2> m_efficiency_vs_eta_pt{ this, "EfficiencyVsEtaPt" }; Gaudi::Property m_min_match_fraction{ this, "MinMatchFraction", 0.7f }; // Range when a candidate is accepted as the momentum using two long tracks is in the Ks signal mass range. diff --git a/Tr/TrackMonitors/src/BeamSpotMonitor.cpp b/Tr/TrackMonitors/src/BeamSpotMonitor.cpp index 0444745b22ff00a05af4782aec52c8f94e84c625..d3248a466002ffb674191f0214a27742342132da 100644 --- a/Tr/TrackMonitors/src/BeamSpotMonitor.cpp +++ b/Tr/TrackMonitors/src/BeamSpotMonitor.cpp @@ -267,18 +267,7 @@ private: "How to handle updates that exceed any of the configured InconceivableAbsDeltaMap thresholds. Allowed values " "are 'WarnUpdate', 'WarnSkip', and 'ExceptionThrow'" }; - /// Histogram limits - Gaudi::Property m_histPVXMin{ this, "HistPVXMin", -2.5 * Gaudi::Units::mm }; - Gaudi::Property m_histPVXMax{ this, "HistPVXMax", 2.5 * Gaudi::Units::mm }; - Gaudi::Property m_histPVYMin{ this, "HistPVYMin", -2. * Gaudi::Units::mm }; - Gaudi::Property m_histPVYMax{ this, "HistPVYMax", 2. * Gaudi::Units::mm }; - Gaudi::Property m_histPVZMin{ this, "HistPVZMin", -200. * Gaudi::Units::mm }; - Gaudi::Property m_histPVZMax{ this, "HistPVZMax", 200. * Gaudi::Units::mm }; - Gaudi::Property m_histPVZMin_wide{ this, "HistPVZMin_Wide", -1.5e3 * Gaudi::Units::mm, - "Wide z window for PV plot" }; - Gaudi::Property m_histPVZMax_wide{ this, "HistPVZMax_Wide", 1.5e3 * Gaudi::Units::mm, - "Wide z window for PV plot" }; - + // Limits for conditions histos Gaudi::Property m_hist2DPVXMin{ this, "Hist2DPVXMin", 0.8 * Gaudi::Units::mm }; Gaudi::Property m_hist2DPVXMax{ this, "Hist2DPVXMax", 1.4 * Gaudi::Units::mm }; Gaudi::Property m_hist2DPVYMin{ this, "Hist2DPVYMin", -0.1 * Gaudi::Units::mm }; @@ -286,25 +275,6 @@ private: Gaudi::Property m_hist2DPVZMin{ this, "Hist2DPVZMin", -200. * Gaudi::Units::mm }; Gaudi::Property m_hist2DPVZMax{ this, "Hist2DPVZMax", 200. * Gaudi::Units::mm }; - Gaudi::Property m_histPVXYMin{ this, "HistPVXYMin", -0.1 * Gaudi::Units::mm2 }; - Gaudi::Property m_histPVXYMax{ this, "HistPVXYMax", 0.1 * Gaudi::Units::mm2 }; - Gaudi::Property m_histPVYZMin{ this, "HistPVYZMin", -20. * Gaudi::Units::mm2 }; - Gaudi::Property m_histPVYZMax{ this, "HistPVYZMax", 20. * Gaudi::Units::mm2 }; - Gaudi::Property m_histPVZXMin{ this, "HistPVZXMin", -10.0 * Gaudi::Units::mm2 }; - Gaudi::Property m_histPVZXMax{ this, "HistPVZXMax", 10.0 * Gaudi::Units::mm2 }; - - // Limits for conditions histos - Gaudi::Property m_histIRCondPosXMin{ this, "HistIRCondPosXMin", -2. * Gaudi::Units::mm }; - Gaudi::Property m_histIRCondPosXMax{ this, "HistIRCondPosXMax", 2. * Gaudi::Units::mm }; - Gaudi::Property m_histIRCondPosYMin{ this, "HistIRCondPosYMin", -2. * Gaudi::Units::mm }; - Gaudi::Property m_histIRCondPosYMax{ this, "HistIRCondPosYMax", 2. * Gaudi::Units::mm }; - Gaudi::Property m_histIRCondPosZMin{ this, "HistIRCondPosZMin", -200. * Gaudi::Units::mm }; - Gaudi::Property m_histIRCondPosZMax{ this, "HistIRCondPosZMax", 200. * Gaudi::Units::mm }; - - Gaudi::Property m_hist2DCondDelPosXHW{ this, "Hist2DCondDelPosXHalfWidth", 0.1 * Gaudi::Units::mm }; - Gaudi::Property m_hist2DCondDelPosYHW{ this, "Hist2DCondDelPosYHalfWidth", 0.1 * Gaudi::Units::mm }; - Gaudi::Property m_hist2DCondDelPosZHW{ this, "Hist2DCondDelPosZHalfWidth", 100. * Gaudi::Units::mm }; - Gaudi::Property m_histIRCondSpreadXXMin{ this, "HistIRCondSpreadXXMin", 0. * Gaudi::Units::mm2 }; Gaudi::Property m_histIRCondSpreadXXMax{ this, "HistIRCondSpreadXXMax", 0.5 * Gaudi::Units::mm2 }; Gaudi::Property m_histIRCondSpreadXYMin{ this, "HistIRCondSpreadXYMin", -0.2 * Gaudi::Units::mm2 }; @@ -343,47 +313,133 @@ private: this, "NumTracks", "Number of tracks per primary vertex;Number of tracks;Entries", { 101, -0.5, 100.5 } }; // Histograms for individual PVs - mutable std::optional> m_histPVPosX; - mutable std::optional> m_histPVPosY; - mutable std::optional> m_histPVPosZ; - mutable std::optional> m_histPVPosZWide; - - mutable std::optional> m_histPVPosYvX; - mutable std::optional> m_histPVPosXvZ; - mutable std::optional> m_histPVPosYvZ; - - mutable std::optional> m_histPVPosCovXY; - mutable std::optional> m_histPVPosCovYZ; - mutable std::optional> m_histPVPosCovZX; + mutable Gaudi::Accumulators::Histogram<1> m_histPVPosX{ this, + "PVPosX", + "Primary vertex X position;PV X [mm];Entries", + { 200, -2.5 * Gaudi::Units::mm, 2.5 * Gaudi::Units::mm } }; + mutable Gaudi::Accumulators::Histogram<1> m_histPVPosY{ this, + "PVPosY", + "Primary vertex Y position;PV Y [mm];Entries", + { 200, -2 * Gaudi::Units::mm, 2 * Gaudi::Units::mm } }; + mutable Gaudi::Accumulators::Histogram<1> m_histPVPosZ{ this, + "PVPosZ", + "Primary vertex Z position;PV Z [mm];Entries", + { 200, -200. * Gaudi::Units::mm, 200. * Gaudi::Units::mm } }; + mutable Gaudi::Accumulators::Histogram<1> m_histPVPosZWide{ + this, + "PVPosZWide", + "Primary vertex Z position (wide);PV Z [mm];Entries", + { 200, -1.5e3 * Gaudi::Units::mm, 1.5e3 * Gaudi::Units::mm } }; + + mutable Gaudi::Accumulators::Histogram<2> m_histPVPosYvX{ this, + "PVPosYvX", + "Primary vertex position Y vs. X;PV X [mm];PV Y [mm]", + { 100, m_hist2DPVXMin, m_hist2DPVXMax }, + { 100, m_hist2DPVYMin, m_hist2DPVYMax } }; + mutable Gaudi::Accumulators::Histogram<2> m_histPVPosXvZ{ this, + "PVPosXvZ", + "Primary vertex position X vs. Z;PV Z [mm];PV X [mm]", + { 100, -200. * Gaudi::Units::mm, 200. * Gaudi::Units::mm }, + { 100, m_hist2DPVXMin, m_hist2DPVXMax } }; + mutable Gaudi::Accumulators::Histogram<2> m_histPVPosYvZ{ this, + "PVPosYvZ", + "Primary vertex position Y vs. Z;PV Z [mm];PV Y [mm]", + { 100, -200. * Gaudi::Units::mm, 200. * Gaudi::Units::mm }, + { 100, m_hist2DPVYMin, m_hist2DPVYMax } }; + + mutable Gaudi::Accumulators::Histogram<1> m_histPVPosCovXY{ + this, + "PVCovXY", + "Interaction region covariance X-Y;PV (X - X_mean)*(Y - Y_mean) [mm2];Entries", + { 200, -0.1 * Gaudi::Units::mm2, 0.1 * Gaudi::Units::mm2 } }; + mutable Gaudi::Accumulators::Histogram<1> m_histPVPosCovYZ{ + this, + "PVCovYZ", + "Interaction region covariance Y-Z;PV (Y - Y_mean)*(Z - Z_mean) [mm2];Entries", + { 200, -20. * Gaudi::Units::mm2, 20. * Gaudi::Units::mm2 } }; + mutable Gaudi::Accumulators::Histogram<1> m_histPVPosCovZX{ + this, + "PVCovZX", + "Interaction region covariance Z-X;PV (Z - Z_mean)*(X - X_mean) [mm2];Entries", + { 200, -10.0 * Gaudi::Units::mm2, 10.0 * Gaudi::Units::mm2 } }; // Histograms for individual PVs relative to conditions - mutable std::optional> m_histPVDelPosYvX; - mutable std::optional> m_histPVDelPosXvZ; - mutable std::optional> m_histPVDelPosYvZ; - - // Histograms for conditions (published and unpublished) - mutable std::optional> m_histIRCondPosX; - mutable std::optional> m_histIRCondPosY; - mutable std::optional> m_histIRCondPosZ; - - mutable std::optional> m_histIRCondSpreadXX; - mutable std::optional> m_histIRCondSpreadXY; - mutable std::optional> m_histIRCondSpreadYY; - mutable std::optional> m_histIRCondSpreadZX; - mutable std::optional> m_histIRCondSpreadYZ; - mutable std::optional> m_histIRCondSpreadZZ; + // Axis limits are not independent properties---based on limits for raw 2D PVs + mutable Gaudi::Accumulators::Histogram<2> m_histPVDelPosYvX{ + this, "PVDelPosYvX", "Primary vertex position relative to conditions Y vs. X;PV X [mm];PV Y [mm]" }; + mutable Gaudi::Accumulators::Histogram<2> m_histPVDelPosXvZ{ + this, "PVDelPosXvZ", "Primary vertex position relative to conditions X vs. Z;PV Z [mm];PV X [mm]" }; + mutable Gaudi::Accumulators::Histogram<2> m_histPVDelPosYvZ{ + this, "PVDelPosYvZ", "Primary vertex position relative to conditions Y vs. Z;PV Z [mm];PV Y [mm]" }; + + // Histoitions (published and unpublished) + mutable Gaudi::Accumulators::Histogram<1> m_histIRCondPosX{ + this, + "CondPosX", + "Conditions IR Position X (published and unpublished);IR position[0] (x) [mm];Entries", + { 200, -2. * Gaudi::Units::mm, 2. * Gaudi::Units::mm } }; + mutable Gaudi::Accumulators::Histogram<1> m_histIRCondPosY{ + this, + "CondPosY", + "Conditions IR Position Y (published and unpublished);IR position[1] (y) [mm];Entries", + { 200, -2. * Gaudi::Units::mm, 2. * Gaudi::Units::mm } }; + mutable Gaudi::Accumulators::Histogram<1> m_histIRCondPosZ{ + this, + "CondPosZ", + "Conditions IR Position Z (published and unpublished);IR position[2] (z) [mm];Entries", + { 200, -200. * Gaudi::Units::mm, 200. * Gaudi::Units::mm } }; + + mutable Gaudi::Accumulators::Histogram<1> m_histIRCondSpreadXX{ + this, "CondSpreadXX", "Conditions IR Spread XX (published and unpublished);IR spread[0] (xx) [mm2];Entries" }; + mutable Gaudi::Accumulators::Histogram<1> m_histIRCondSpreadXY{ + this, "CondSpreadXY", "Conditions IR Spread XY (published and unpublished);IR spread[1] (xy) [mm2];Entries" }; + mutable Gaudi::Accumulators::Histogram<1> m_histIRCondSpreadYY{ + this, "CondSpreadYY", "Conditions IR Spread YY (published and unpublished);IR spread[2] (yy) [mm2];Entries" }; + mutable Gaudi::Accumulators::Histogram<1> m_histIRCondSpreadZX{ + this, "CondSpreadZX", "Conditions IR Spread ZX (published and unpublished);IR spread[3] (xz) [mm2];Entries" }; + mutable Gaudi::Accumulators::Histogram<1> m_histIRCondSpreadYZ{ + this, "CondSpreadYZ", "Conditions IR Spread YZ (published and unpublished);IR spread[4] (yz) [mm2];Entries" }; + mutable Gaudi::Accumulators::Histogram<1> m_histIRCondSpreadZZ{ + this, "CondSpreadZZ", "Conditions IR Spread ZZ (published and unpublished);IR spread[5] (zz) [mm2];Entries" }; // Histograms for conditions differences relative to cached conditions - mutable std::optional> m_histIRCondDelPosYvX; - mutable std::optional> m_histIRCondDelPosXvZ; - mutable std::optional> m_histIRCondDelPosYvZ; + mutable Gaudi::Accumulators::Histogram<2> m_histIRCondDelPosYvX{ + this, + "CondDelPosYvX", + "Conditions IR Position relative to published Y vs. X;PV X [mm];PV Y [mm]", + { 100, -0.1 * Gaudi::Units::mm, 0.1 * Gaudi::Units::mm }, + { 100, -0.1 * Gaudi::Units::mm, 0.1 * Gaudi::Units::mm } }; + mutable Gaudi::Accumulators::Histogram<2> m_histIRCondDelPosXvZ{ + this, + "CondDelPosXvZ", + "Conditions IR Position relative to published X vs. Z;PV Z [mm];PV X [mm]", + { 100, -100. * Gaudi::Units::mm, 100. * Gaudi::Units::mm }, + { 100, -0.1 * Gaudi::Units::mm, 0.1 * Gaudi::Units::mm } }; + mutable Gaudi::Accumulators::Histogram<2> m_histIRCondDelPosYvZ{ + this, + "CondDelPosYvZ", + "Conditions IR Position relative to published Y vs. Z;PV Z [mm];PV Y [mm]", + { 100, -100. * Gaudi::Units::mm, 100. * Gaudi::Units::mm }, + { 100, -0.1 * Gaudi::Units::mm, 0.1 * Gaudi::Units::mm } }; - mutable std::optional> m_histIRCondDelSpreadXX; - mutable std::optional> m_histIRCondDelSpreadXY; - mutable std::optional> m_histIRCondDelSpreadYY; - mutable std::optional> m_histIRCondDelSpreadZX; - mutable std::optional> m_histIRCondDelSpreadYZ; - mutable std::optional> m_histIRCondDelSpreadZZ; + mutable Gaudi::Accumulators::Histogram<1> m_histIRCondDelSpreadXX{ + this, "CondDelSpreadXX", + "Conditions IR Spread relative to published XX (published and unpublished);IR spread[0] (xx) [mm2];Entries" }; + mutable Gaudi::Accumulators::Histogram<1> m_histIRCondDelSpreadXY{ + this, "CondDelSpreadXY", + "Conditions IR Spread relative to published XY (published and unpublished);IR spread[1] (xy) [mm2];Entries" }; + mutable Gaudi::Accumulators::Histogram<1> m_histIRCondDelSpreadYY{ + this, "CondDelSpreadYY", + "Conditions IR Spread relative to published YY (published and unpublished);IR spread[2] (yy) [mm2];Entries" }; + mutable Gaudi::Accumulators::Histogram<1> m_histIRCondDelSpreadZX{ + this, "CondDelSpreadZX", + "Conditions IR Spread relative to published ZX (published and unpublished);IR spread[3] (xz) [mm2];Entries" }; + mutable Gaudi::Accumulators::Histogram<1> m_histIRCondDelSpreadYZ{ + this, "CondDelSpreadYZ", + "Conditions IR Spread relative to published YZ (published and unpublished);IR spread[4] (yz) [mm2];Entries" }; + mutable Gaudi::Accumulators::Histogram<1> m_histIRCondDelSpreadZZ{ + this, "CondDelSpreadZZ", + "Conditions IR Spread relative to published ZZ (published and unpublished);IR spread[5] (zz) [mm2];Entries" }; // Warning counters //--------------------------------------------------------------------------- @@ -497,130 +553,49 @@ StatusCode BeamSpotMonitor::initialize() { /// Initialize histograms that depende on properties void BeamSpotMonitor::init_configurable_histos() const { - using axis1D = Gaudi::Accumulators::Axis; - - // Histograms for individual PVs - m_histPVPosX.emplace( this, "PVPosX", "Primary vertex X position;PV X [mm];Entries", - axis1D{ 200, m_histPVXMin, m_histPVXMax } ); - - m_histPVPosY.emplace( this, "PVPosY", "Primary vertex Y position;PV Y [mm];Entries", - axis1D{ 200, m_histPVYMin, m_histPVYMax } ); - m_histPVPosZ.emplace( this, "PVPosZ", "Primary vertex Z position;PV Z [mm];Entries", - axis1D{ 200, m_histPVZMin, m_histPVZMax } ); - m_histPVPosZWide.emplace( this, "PVPosZWide", "Primary vertex Z position (wide);PV Z [mm];Entries", - axis1D{ 200, m_histPVZMin_wide, m_histPVZMax_wide } ); - - m_histPVPosYvX.emplace( this, "PVPosYvX", "Primary vertex position Y vs. X;PV X [mm];PV Y [mm]", - axis1D{ 100, m_hist2DPVXMin, m_hist2DPVXMax }, - axis1D{ 100, m_hist2DPVYMin, m_hist2DPVYMax } ); - m_histPVPosXvZ.emplace( this, "PVPosXvZ", "Primary vertex position X vs. Z;PV Z [mm];PV X [mm]", - axis1D{ 100, m_hist2DPVZMin, m_hist2DPVZMax }, - axis1D{ 100, m_hist2DPVXMin, m_hist2DPVXMax } ); - m_histPVPosYvZ.emplace( this, "PVPosYvZ", "Primary vertex position Y vs. Z;PV Z [mm];PV Y [mm]", - axis1D{ 100, m_hist2DPVZMin, m_hist2DPVZMax }, - axis1D{ 100, m_hist2DPVYMin, m_hist2DPVYMax } ); - - m_histPVPosCovXY.emplace( this, "PVCovXY", - "Interaction region covariance X-Y;PV (X - X_mean)*(Y - Y_mean) [mm2];Entries", - axis1D{ 200, m_histPVXYMin, m_histPVXYMax } ); - m_histPVPosCovYZ.emplace( this, "PVCovYZ", - "Interaction region covariance Y-Z;PV (Y - Y_mean)*(Z - Z_mean) [mm2];Entries", - axis1D{ 200, m_histPVYZMin, m_histPVYZMax } ); - m_histPVPosCovZX.emplace( this, "PVCovZX", - "Interaction region covariance Z-X;PV (Z - Z_mean)*(X - X_mean) [mm2];Entries", - axis1D{ 200, m_histPVZXMin, m_histPVZXMax } ); - // Histograms for individual PVs relative to conditions // Axis limits are not independent properties---based on limits for raw 2D PVs - m_histPVDelPosYvX.emplace( - this, "PVDelPosYvX", "Primary vertex position relative to conditions Y vs. X;PV X [mm];PV Y [mm]", - axis1D{ 100, -( m_hist2DPVXMax - m_hist2DPVXMin ) / 2, ( m_hist2DPVXMax - m_hist2DPVXMin ) / 2 }, - axis1D{ 100, -( m_hist2DPVYMax - m_hist2DPVYMin ) / 2, ( m_hist2DPVYMax - m_hist2DPVYMin ) / 2 } ); - m_histPVDelPosXvZ.emplace( - this, "PVDelPosXvZ", "Primary vertex position relative to conditions X vs. Z;PV Z [mm];PV X [mm]", - axis1D{ 100, -( m_hist2DPVZMax - m_hist2DPVZMin ) / 2, ( m_hist2DPVZMax - m_hist2DPVZMin ) / 2 }, - axis1D{ 100, -( m_hist2DPVXMax - m_hist2DPVXMin ) / 2, ( m_hist2DPVXMax - m_hist2DPVXMin ) / 2 } ); - m_histPVDelPosYvZ.emplace( - this, "PVDelPosYvZ", "Primary vertex position relative to conditions Y vs. Z;PV Z [mm];PV Y [mm]", - axis1D{ 100, -( m_hist2DPVZMax - m_hist2DPVZMin ) / 2, ( m_hist2DPVZMax - m_hist2DPVZMin ) / 2 }, - axis1D{ 100, -( m_hist2DPVYMax - m_hist2DPVYMin ) / 2, ( m_hist2DPVYMax - m_hist2DPVYMin ) / 2 } ); - - // Histograms for conditions (published and unpublished) - m_histIRCondPosX.emplace( this, "CondPosX", - "Conditions IR Position X (published and unpublished);IR position[0] (x) [mm];Entries", - axis1D{ 200, m_histIRCondPosXMin, m_histIRCondPosXMax } ); - m_histIRCondPosY.emplace( this, "CondPosY", - "Conditions IR Position Y (published and unpublished);IR position[1] (y) [mm];Entries", - axis1D{ 200, m_histIRCondPosYMin, m_histIRCondPosYMax } ); - m_histIRCondPosZ.emplace( this, "CondPosZ", - "Conditions IR Position Z (published and unpublished);IR position[2] (z) [mm];Entries", - axis1D{ 200, m_histIRCondPosZMin, m_histIRCondPosZMax } ); - - m_histIRCondSpreadXX.emplace( this, "CondSpreadXX", - "Conditions IR Spread XX (published and unpublished);IR spread[0] (xx) [mm2];Entries", - axis1D{ 200, m_histIRCondSpreadXXMin, m_histIRCondSpreadXXMax } ); - m_histIRCondSpreadXY.emplace( this, "CondSpreadXY", - "Conditions IR Spread XY (published and unpublished);IR spread[1] (xy) [mm2];Entries", - axis1D{ 200, m_histIRCondSpreadXYMin, m_histIRCondSpreadXYMax } ); - m_histIRCondSpreadYY.emplace( this, "CondSpreadYY", - "Conditions IR Spread YY (published and unpublished);IR spread[2] (yy) [mm2];Entries", - axis1D{ 200, m_histIRCondSpreadYYMin, m_histIRCondSpreadYYMax } ); - m_histIRCondSpreadZX.emplace( this, "CondSpreadZX", - "Conditions IR Spread ZX (published and unpublished);IR spread[3] (xz) [mm2];Entries", - axis1D{ 200, m_histIRCondSpreadZXMin, m_histIRCondSpreadZXMax } ); - m_histIRCondSpreadYZ.emplace( this, "CondSpreadYZ", - "Conditions IR Spread YZ (published and unpublished);IR spread[4] (yz) [mm2];Entries", - axis1D{ 200, m_histIRCondSpreadYZMin, m_histIRCondSpreadYZMax } ); - m_histIRCondSpreadZZ.emplace( this, "CondSpreadZZ", - "Conditions IR Spread ZZ (published and unpublished);IR spread[5] (zz) [mm2];Entries", - axis1D{ 200, m_histIRCondSpreadZZMin, m_histIRCondSpreadZZMax } ); - - // Histograms for conditions differences relative to cached conditions - m_histIRCondDelPosYvX.emplace( this, "CondDelPosYvX", - "Conditions IR Position relative to published Y vs. X;PV X [mm];PV Y [mm]", - axis1D{ 100, -m_hist2DCondDelPosXHW, m_hist2DCondDelPosXHW }, - axis1D{ 100, -m_hist2DCondDelPosYHW, m_hist2DCondDelPosYHW } ); - m_histIRCondDelPosXvZ.emplace( this, "CondDelPosXvZ", - "Conditions IR Position relative to published X vs. Z;PV Z [mm];PV X [mm]", - axis1D{ 100, -m_hist2DCondDelPosZHW, m_hist2DCondDelPosZHW }, - axis1D{ 100, -m_hist2DCondDelPosXHW, m_hist2DCondDelPosXHW } ); - m_histIRCondDelPosYvZ.emplace( this, "CondDelPosYvZ", - "Conditions IR Position relative to published Y vs. Z;PV Z [mm];PV Y [mm]", - axis1D{ 100, -m_hist2DCondDelPosZHW, m_hist2DCondDelPosZHW }, - axis1D{ 100, -m_hist2DCondDelPosYHW, m_hist2DCondDelPosYHW } ); + m_histPVPosYvX.setAxis<0>( { 100, m_hist2DPVXMin, m_hist2DPVXMax } ); + m_histPVPosYvX.setAxis<1>( { 100, m_hist2DPVYMin, m_hist2DPVYMax } ); + m_histPVPosXvZ.setAxis<0>( { 100, m_hist2DPVZMin, m_hist2DPVZMax } ); + m_histPVPosXvZ.setAxis<1>( { 100, m_hist2DPVXMin, m_hist2DPVXMax } ); + m_histPVPosYvZ.setAxis<0>( { 100, m_hist2DPVZMin, m_hist2DPVZMax } ); + m_histPVPosYvZ.setAxis<1>( { 100, m_hist2DPVYMin, m_hist2DPVYMax } ); + + m_histPVDelPosYvX.setAxis<0>( + { 100, -( m_hist2DPVXMax - m_hist2DPVXMin ) / 2, ( m_hist2DPVXMax - m_hist2DPVXMin ) / 2 } ); + m_histPVDelPosYvX.setAxis<1>( + { 100, -( m_hist2DPVYMax - m_hist2DPVYMin ) / 2, ( m_hist2DPVYMax - m_hist2DPVYMin ) / 2 } ); + m_histPVDelPosXvZ.setAxis<0>( + { 100, -( m_hist2DPVZMax - m_hist2DPVZMin ) / 2, ( m_hist2DPVZMax - m_hist2DPVZMin ) / 2 } ); + m_histPVDelPosXvZ.setAxis<1>( + { 100, -( m_hist2DPVXMax - m_hist2DPVXMin ) / 2, ( m_hist2DPVXMax - m_hist2DPVXMin ) / 2 } ); + m_histPVDelPosYvZ.setAxis<0>( + { 100, -( m_hist2DPVZMax - m_hist2DPVZMin ) / 2, ( m_hist2DPVZMax - m_hist2DPVZMin ) / 2 } ); + m_histPVDelPosYvZ.setAxis<1>( + { 100, -( m_hist2DPVYMax - m_hist2DPVYMin ) / 2, ( m_hist2DPVYMax - m_hist2DPVYMin ) / 2 } ); + + m_histIRCondSpreadXX.setAxis<0>( { 200, m_histIRCondSpreadXXMin, m_histIRCondSpreadXXMax } ); + m_histIRCondSpreadXY.setAxis<0>( { 200, m_histIRCondSpreadXYMin, m_histIRCondSpreadXYMax } ); + m_histIRCondSpreadYY.setAxis<0>( { 200, m_histIRCondSpreadYYMin, m_histIRCondSpreadYYMax } ); + m_histIRCondSpreadZX.setAxis<0>( { 200, m_histIRCondSpreadZXMin, m_histIRCondSpreadZXMax } ); + m_histIRCondSpreadYZ.setAxis<0>( { 200, m_histIRCondSpreadYZMin, m_histIRCondSpreadYZMax } ); + m_histIRCondSpreadZZ.setAxis<0>( { 200, m_histIRCondSpreadZZMin, m_histIRCondSpreadZZMax } ); // Spread Delta histo axis limits are not independent properties atm // They are based on the limits for absolute conditions histos - m_histIRCondDelSpreadXX.emplace( - this, "CondDelSpreadXX", - "Conditions IR Spread relative to published XX (published and unpublished);IR spread[0] (xx) [mm2];Entries", - axis1D{ 100, -( m_histIRCondSpreadXXMax - m_histIRCondSpreadXXMin ) / 2, - ( m_histIRCondSpreadXXMax - m_histIRCondSpreadXXMin ) / 2 } ); - m_histIRCondDelSpreadXY.emplace( - this, "CondDelSpreadXY", - "Conditions IR Spread relative to published XY (published and unpublished);IR spread[1] (xy) [mm2];Entries", - axis1D{ 100, -( m_histIRCondSpreadXYMax - m_histIRCondSpreadXYMin ) / 2, - ( m_histIRCondSpreadXYMax - m_histIRCondSpreadXYMin ) / 2 } ); - m_histIRCondDelSpreadYY.emplace( - this, "CondDelSpreadYY", - "Conditions IR Spread relative to published YY (published and unpublished);IR spread[2] (yy) [mm2];Entries", - axis1D{ 100, -( m_histIRCondSpreadYYMax - m_histIRCondSpreadYYMin ) / 2, - ( m_histIRCondSpreadYYMax - m_histIRCondSpreadYYMin ) / 2 } ); - m_histIRCondDelSpreadZX.emplace( - this, "CondDelSpreadZX", - "Conditions IR Spread relative to published ZX (published and unpublished);IR spread[3] (xz) [mm2];Entries", - axis1D{ 100, -( m_histIRCondSpreadZXMax - m_histIRCondSpreadZXMin ) / 2, - ( m_histIRCondSpreadZXMax - m_histIRCondSpreadZXMin ) / 2 } ); - m_histIRCondDelSpreadYZ.emplace( - this, "CondDelSpreadYZ", - "Conditions IR Spread relative to published YZ (published and unpublished);IR spread[4] (yz) [mm2];Entries", - axis1D{ 100, -( m_histIRCondSpreadYZMax - m_histIRCondSpreadYZMin ) / 2, - ( m_histIRCondSpreadYZMax - m_histIRCondSpreadYZMin ) / 2 } ); - m_histIRCondDelSpreadZZ.emplace( - this, "CondDelSpreadZZ", - "Conditions IR Spread relative to published ZZ (published and unpublished);IR spread[5] (zz) [mm2];Entries", - axis1D{ 100, -( m_histIRCondSpreadZZMax - m_histIRCondSpreadZZMin ) / 2, - ( m_histIRCondSpreadZZMax - m_histIRCondSpreadZZMin ) / 2 } ); + m_histIRCondDelSpreadXX.setAxis<0>( { 100, -( m_histIRCondSpreadXXMax - m_histIRCondSpreadXXMin ) / 2, + ( m_histIRCondSpreadXXMax - m_histIRCondSpreadXXMin ) / 2 } ); + m_histIRCondDelSpreadXY.setAxis<0>( { 100, -( m_histIRCondSpreadXYMax - m_histIRCondSpreadXYMin ) / 2, + ( m_histIRCondSpreadXYMax - m_histIRCondSpreadXYMin ) / 2 } ); + m_histIRCondDelSpreadYY.setAxis<0>( { 100, -( m_histIRCondSpreadYYMax - m_histIRCondSpreadYYMin ) / 2, + ( m_histIRCondSpreadYYMax - m_histIRCondSpreadYYMin ) / 2 } ); + m_histIRCondDelSpreadZX.setAxis<0>( { 100, -( m_histIRCondSpreadZXMax - m_histIRCondSpreadZXMin ) / 2, + ( m_histIRCondSpreadZXMax - m_histIRCondSpreadZXMin ) / 2 } ); + m_histIRCondDelSpreadYZ.setAxis<0>( { 100, -( m_histIRCondSpreadYZMax - m_histIRCondSpreadYZMin ) / 2, + ( m_histIRCondSpreadYZMax - m_histIRCondSpreadYZMin ) / 2 } ); + m_histIRCondDelSpreadZZ.setAxis<0>( { 100, -( m_histIRCondSpreadZZMax - m_histIRCondSpreadZZMin ) / 2, + ( m_histIRCondSpreadZZMax - m_histIRCondSpreadZZMin ) / 2 } ); } //============================================================================= @@ -644,31 +619,25 @@ void BeamSpotMonitor::operator()( LHCb::ODIN const& odin, PVView const& pvcontai m_pvZXProdCtr += pv->position().z() * pv->position().x(); ++m_pvNTracks[pv->tracks().size()]; - ++m_histPVPosX.value()[pv->position().x()]; - ++m_histPVPosY.value()[pv->position().y()]; - ++m_histPVPosZ.value()[pv->position().z()]; - ++m_histPVPosZWide.value()[pv->position().z()]; + ++m_histPVPosX[pv->position().x()]; + ++m_histPVPosY[pv->position().y()]; + ++m_histPVPosZ[pv->position().z()]; + ++m_histPVPosZWide[pv->position().z()]; - ++m_histPVPosYvX.value()[{ pv->position().x(), pv->position().y() }]; - ++m_histPVPosXvZ.value()[{ pv->position().z(), pv->position().x() }]; - ++m_histPVPosYvZ.value()[{ pv->position().z(), pv->position().y() }]; + ++m_histPVPosYvX[{ pv->position().x(), pv->position().y() }]; + ++m_histPVPosXvZ[{ pv->position().z(), pv->position().x() }]; + ++m_histPVPosYvZ[{ pv->position().z(), pv->position().y() }]; if ( m_cache.nPVs > 0 ) { - ++m_histPVDelPosYvX - .value()[{ pv->position().x() - m_cache.position[0], pv->position().y() - m_cache.position[1] }]; - ++m_histPVDelPosXvZ - .value()[{ pv->position().z() - m_cache.position[2], pv->position().x() - m_cache.position[0] }]; - ++m_histPVDelPosYvZ - .value()[{ pv->position().z() - m_cache.position[2], pv->position().y() - m_cache.position[1] }]; + ++m_histPVDelPosYvX[{ pv->position().x() - m_cache.position[0], pv->position().y() - m_cache.position[1] }]; + ++m_histPVDelPosXvZ[{ pv->position().z() - m_cache.position[2], pv->position().x() - m_cache.position[0] }]; + ++m_histPVDelPosYvZ[{ pv->position().z() - m_cache.position[2], pv->position().y() - m_cache.position[1] }]; } // Must be incremented after accumulators to avoid excursion on first PV. - ++m_histPVPosCovXY - .value()[( pv->position().x() - m_pvXPosCtr.mean() ) * ( pv->position().y() - m_pvYPosCtr.mean() )]; - ++m_histPVPosCovYZ - .value()[( pv->position().y() - m_pvYPosCtr.mean() ) * ( pv->position().z() - m_pvZPosCtr.mean() )]; - ++m_histPVPosCovZX - .value()[( pv->position().z() - m_pvZPosCtr.mean() ) * ( pv->position().x() - m_pvXPosCtr.mean() )]; + ++m_histPVPosCovXY[( pv->position().x() - m_pvXPosCtr.mean() ) * ( pv->position().y() - m_pvYPosCtr.mean() )]; + ++m_histPVPosCovYZ[( pv->position().y() - m_pvYPosCtr.mean() ) * ( pv->position().z() - m_pvZPosCtr.mean() )]; + ++m_histPVPosCovZX[( pv->position().z() - m_pvZPosCtr.mean() ) * ( pv->position().x() - m_pvXPosCtr.mean() )]; } } @@ -757,34 +726,31 @@ void BeamSpotMonitor::cache_counters() const { void BeamSpotMonitor::reset_accumulators( const unsigned curRunNumber ) const { // Book histograms before resetting if ( m_pvXPosCtr.nEntries() >= m_minPVsForCalib ) { - ++m_histIRCondPosX.value()[m_pvXPosCtr.mean()]; - ++m_histIRCondPosY.value()[m_pvYPosCtr.mean()]; - ++m_histIRCondPosZ.value()[m_pvZPosCtr.mean()]; + ++m_histIRCondPosX[m_pvXPosCtr.mean()]; + ++m_histIRCondPosY[m_pvYPosCtr.mean()]; + ++m_histIRCondPosZ[m_pvZPosCtr.mean()]; - ++m_histIRCondSpreadXX.value()[m_pvXPosCtr.unbiased_sample_variance()]; - ++m_histIRCondSpreadXY.value()[calculate_spread_offdiag( m_pvXPosCtr, m_pvYPosCtr, m_pvXYProdCtr )]; - ++m_histIRCondSpreadYY.value()[m_pvYPosCtr.unbiased_sample_variance()]; - ++m_histIRCondSpreadZX.value()[calculate_spread_offdiag( m_pvZPosCtr, m_pvXPosCtr, m_pvZXProdCtr )]; - ++m_histIRCondSpreadYZ.value()[calculate_spread_offdiag( m_pvYPosCtr, m_pvZPosCtr, m_pvYZProdCtr )]; - ++m_histIRCondSpreadZZ.value()[m_pvZPosCtr.unbiased_sample_variance()]; + ++m_histIRCondSpreadXX[m_pvXPosCtr.unbiased_sample_variance()]; + ++m_histIRCondSpreadXY[calculate_spread_offdiag( m_pvXPosCtr, m_pvYPosCtr, m_pvXYProdCtr )]; + ++m_histIRCondSpreadYY[m_pvYPosCtr.unbiased_sample_variance()]; + ++m_histIRCondSpreadZX[calculate_spread_offdiag( m_pvZPosCtr, m_pvXPosCtr, m_pvZXProdCtr )]; + ++m_histIRCondSpreadYZ[calculate_spread_offdiag( m_pvYPosCtr, m_pvZPosCtr, m_pvYZProdCtr )]; + ++m_histIRCondSpreadZZ[m_pvZPosCtr.unbiased_sample_variance()]; if ( m_cache.nPVs > 0 ) { - ++m_histIRCondDelPosYvX - .value()[{ m_pvXPosCtr.mean() - m_cache.position[0], m_pvYPosCtr.mean() - m_cache.position[1] }]; - ++m_histIRCondDelPosXvZ - .value()[{ m_pvZPosCtr.mean() - m_cache.position[2], m_pvXPosCtr.mean() - m_cache.position[0] }]; - ++m_histIRCondDelPosYvZ - .value()[{ m_pvZPosCtr.mean() - m_cache.position[2], m_pvYPosCtr.mean() - m_cache.position[1] }]; - - ++m_histIRCondDelSpreadXX.value()[m_pvXPosCtr.unbiased_sample_variance() - m_cache.spread[0]]; - ++m_histIRCondDelSpreadXY - .value()[calculate_spread_offdiag( m_pvXPosCtr, m_pvYPosCtr, m_pvXYProdCtr ) - m_cache.spread[1]]; - ++m_histIRCondDelSpreadYY.value()[m_pvYPosCtr.unbiased_sample_variance() - m_cache.spread[2]]; - ++m_histIRCondDelSpreadZX - .value()[calculate_spread_offdiag( m_pvZPosCtr, m_pvXPosCtr, m_pvZXProdCtr ) - m_cache.spread[3]]; - ++m_histIRCondDelSpreadYZ - .value()[calculate_spread_offdiag( m_pvYPosCtr, m_pvZPosCtr, m_pvYZProdCtr ) - m_cache.spread[4]]; - ++m_histIRCondDelSpreadZZ.value()[m_pvZPosCtr.unbiased_sample_variance() - m_cache.spread[5]]; + ++m_histIRCondDelPosYvX[{ m_pvXPosCtr.mean() - m_cache.position[0], m_pvYPosCtr.mean() - m_cache.position[1] }]; + ++m_histIRCondDelPosXvZ[{ m_pvZPosCtr.mean() - m_cache.position[2], m_pvXPosCtr.mean() - m_cache.position[0] }]; + ++m_histIRCondDelPosYvZ[{ m_pvZPosCtr.mean() - m_cache.position[2], m_pvYPosCtr.mean() - m_cache.position[1] }]; + + ++m_histIRCondDelSpreadXX[m_pvXPosCtr.unbiased_sample_variance() - m_cache.spread[0]]; + ++m_histIRCondDelSpreadXY[calculate_spread_offdiag( m_pvXPosCtr, m_pvYPosCtr, m_pvXYProdCtr ) - + m_cache.spread[1]]; + ++m_histIRCondDelSpreadYY[m_pvYPosCtr.unbiased_sample_variance() - m_cache.spread[2]]; + ++m_histIRCondDelSpreadZX[calculate_spread_offdiag( m_pvZPosCtr, m_pvXPosCtr, m_pvZXProdCtr ) - + m_cache.spread[3]]; + ++m_histIRCondDelSpreadYZ[calculate_spread_offdiag( m_pvYPosCtr, m_pvZPosCtr, m_pvYZProdCtr ) - + m_cache.spread[4]]; + ++m_histIRCondDelSpreadZZ[m_pvZPosCtr.unbiased_sample_variance() - m_cache.spread[5]]; } } diff --git a/Tr/TrackMonitors/src/VPHitEfficiencyMonitor.cpp b/Tr/TrackMonitors/src/VPHitEfficiencyMonitor.cpp index 009dcd23a63623a01f00e54f43a76cbdbae9030d..5b9bc8ba001b2650c59cc77b6744986f66215eb9 100644 --- a/Tr/TrackMonitors/src/VPHitEfficiencyMonitor.cpp +++ b/Tr/TrackMonitors/src/VPHitEfficiencyMonitor.cpp @@ -22,7 +22,7 @@ #include "GaudiKernel/Vector3DTypes.h" #include "Kernel/HitPattern.h" #include "LHCbAlgs/Consumer.h" -#include +#include #include "TrackInterfaces/ITrackExtrapolator.h" #include "TrackInterfaces/ITrackInterpolator.h" @@ -57,17 +57,17 @@ private: AIDA::IHistogram2D* hitPass = nullptr; AIDA::IHistogram2D* hitTotal = nullptr; - mutable Gaudi::Accumulators::ProfileHistogram<1> m_hitEfficiency{ + mutable Gaudi::Accumulators::StaticProfileHistogram<1> m_hitEfficiency{ this, "hitEfficiencyASIC", "hit efficiency per ASIC", { 3, -0.5, 2.5 } }; - mutable Gaudi::Accumulators::ProfileHistogram<1> m_hotEfficiency{ + mutable Gaudi::Accumulators::StaticProfileHistogram<1> m_hotEfficiency{ this, "hotEfficiencyASIC", "hot efficiency per ASIC", { 3, -0.5, 2.5 } }; // Definitions change when changing expert_mode - mutable std::optional> m_hitEfficiencyPerRowColumn; - mutable std::optional> m_hotEfficiencyPerRowColumn; - mutable std::optional> m_xyResiduals; - mutable std::optional> m_xyResidualsProfile; + mutable std::optional> m_hitEfficiencyPerRowColumn; + mutable std::optional> m_hotEfficiencyPerRowColumn; + mutable std::optional> m_xyResiduals; + mutable std::optional> m_xyResidualsProfile; // Normalized residuals - mutable Gaudi::Accumulators::Histogram<2> m_resCorrected{ + mutable Gaudi::Accumulators::StaticHistogram<2> m_resCorrected{ this, "resCorrected", "resCorrected", { 200, -10, 10 }, { 200, -10, 10 } }; mutable Gaudi::Accumulators::SummingCounter<> m_interPolationError{ this, "Could not interpolate" }; diff --git a/Tr/TrackMonitors/src/VertexCompare.cpp b/Tr/TrackMonitors/src/VertexCompare.cpp index 9999182ece965c923344065adaf824046002363f..aec8862a5788bcee0e69ba922414fa5d9946b3e2 100644 --- a/Tr/TrackMonitors/src/VertexCompare.cpp +++ b/Tr/TrackMonitors/src/VertexCompare.cpp @@ -29,13 +29,23 @@ #include "MCInterfaces/IForcedBDecayTool.h" #include "VPDet/DeVP.h" #include -#include +#include #include +#include #include #include using Vertices = LHCb::Event::PV::PrimaryVertexContainer; using VertexType = Vertices::value_type; +#include + +namespace { + constexpr auto ntrack_bins = std::array{ 3.5, 15.5, 30.5, 45.5, 58.5, 70.5 }; + std::string formatHistoTitle( std::string_view title, std::size_t idx ) { + return fmt::format( "{}, ntracks > {} & {} m_produceHistogram{ this, "produceHistogram", true }; Gaudi::Property m_produceNtuple{ this, "produceNtuple", true }; Gaudi::Property m_monitoring{ this, "monitoring", false }; @@ -245,49 +253,46 @@ private: mutable Gaudi::Accumulators::StatAccumulator m_stat_pullz; mutable Gaudi::Accumulators::SumAccumulator m_stat_pullz_fourth_sum; - struct monitoringHistos { - mutable std::array, 5> m_histo_nTracksBins_dx; - mutable std::array, 5> m_histo_nTracksBins_dy; - mutable std::array, 5> m_histo_nTracksBins_dz; - mutable Gaudi::Accumulators::Histogram<1> m_histo_pullx_Monitoring; - mutable Gaudi::Accumulators::Histogram<1> m_histo_pully_Monitoring; - mutable Gaudi::Accumulators::Histogram<1> m_histo_pullz_Monitoring; - - template - static std::array, sizeof...( IDXs )> - histo1DArrayBuilder( const VertexCompare* owner, const std::string& name, Gaudi::Histo1DDef def, - std::index_sequence ) { - return { { { owner, - name + std::to_string( IDXs ), - def.title() + ", ntracks > " + std::to_string( ntrack_bins[IDXs] ) + " & " + - std::to_string( ntrack_bins[IDXs + 1] ) + " ( def.bins() ), def.lowEdge(), def.highEdge() } }... } }; - } - monitoringHistos( const VertexCompare* owner ) - : m_histo_nTracksBins_dx{ histo1DArrayBuilder( owner, "dx_Monitoring_ntracks_bin", - Gaudi::Histo1DDef{ "dx, mm", -0.15, 0.15, 50 }, - std::make_index_sequence<5>() ) } - , m_histo_nTracksBins_dy{ histo1DArrayBuilder( owner, "dy_Monitoring_ntracks_bin", - Gaudi::Histo1DDef{ "dy, mm", -0.15, 0.15, 50 }, - std::make_index_sequence<5>() ) } - , m_histo_nTracksBins_dz{ histo1DArrayBuilder( owner, "dz_Monitoring_ntracks_bin", - Gaudi::Histo1DDef{ "dz, mm", -1.5, 1.5, 50 }, - std::make_index_sequence<5>() ) } + struct MonitoringHistos { + static constexpr size_t s_nTrackBins = 5; + mutable Gaudi::Accumulators::HistogramArray, s_nTrackBins> + m_histo_nTracksBins_dx; + mutable Gaudi::Accumulators::HistogramArray, s_nTrackBins> + m_histo_nTracksBins_dy; + mutable Gaudi::Accumulators::HistogramArray, s_nTrackBins> + m_histo_nTracksBins_dz; + mutable Gaudi::Accumulators::StaticHistogram<1> m_histo_pullx_Monitoring; + mutable Gaudi::Accumulators::StaticHistogram<1> m_histo_pully_Monitoring; + mutable Gaudi::Accumulators::StaticHistogram<1> m_histo_pullz_Monitoring; + + MonitoringHistos( const VertexCompare* owner ) + : m_histo_nTracksBins_dx{ owner, + []( size_t idx ) { return fmt::format( "dx_Monitoring_ntracks_bin{}", idx ); }, + []( size_t idx ) { return formatHistoTitle( "dx, mm", idx ); }, + { 50, -0.15, 0.15 } } + , m_histo_nTracksBins_dy{ owner, + []( size_t idx ) { return fmt::format( "dy_Monitoring_ntracks_bin{}", idx ); }, + []( size_t idx ) { return formatHistoTitle( "dy, mm", idx ); }, + { 50, -0.15, 0.15 } } + , m_histo_nTracksBins_dz{ owner, + []( size_t idx ) { return fmt::format( "dz_Monitoring_ntracks_bin{}", idx ); }, + []( size_t idx ) { return formatHistoTitle( "dz, mm", idx ); }, + { 50, -1.5, 1.5 } } , m_histo_pullx_Monitoring{ owner, "pullx_Monitoring", "pull x", { 20, -5, 5 } } , m_histo_pully_Monitoring{ owner, "pully_Monitoring", "pull y", { 20, -5, 5 } } , m_histo_pullz_Monitoring{ owner, "pullz_Monitoring", "pull z", { 20, -5, 5 } } {} }; - std::unique_ptr m_monitoringHistos; - - mutable std::optional> m_nTracks1; - mutable std::optional> m_nTracks2; - mutable std::optional> m_histo_dx; - mutable std::optional> m_histo_dy; - mutable std::optional> m_histo_dz; - mutable std::optional> m_histo_pullx; - mutable std::optional> m_histo_pully; - mutable std::optional> m_histo_pullz; - mutable std::optional> m_nTracks_dif; + std::optional m_monitoringHistos; + + mutable std::optional> m_nTracks1; + mutable std::optional> m_nTracks2; + mutable std::optional> m_histo_dx; + mutable std::optional> m_histo_dy; + mutable std::optional> m_histo_dz; + mutable std::optional> m_histo_pullx; + mutable std::optional> m_histo_pully; + mutable std::optional> m_histo_pullz; + mutable std::optional> m_nTracks_dif; mutable Gaudi::Accumulators::Counter<> m_nVtx{ this, "Number of pairs of vertices in processed events" }; mutable Gaudi::Accumulators::Counter<> m_nRec1{ this, "Number of vertices in input1" }; @@ -315,7 +320,7 @@ DECLARE_COMPONENT_WITH_ID( VertexCompare, "VertexCompare" ) StatusCode VertexCompare::initialize() { return Consumer::initialize().andThen( [&]() { - if ( m_monitoring.value() ) m_monitoringHistos = std::make_unique( this ); + if ( m_monitoring.value() ) m_monitoringHistos.emplace( this ); // define range of new histograms from properties using axis1D = Gaudi::Accumulators::Axis::AxisArithmeticType>; @@ -492,19 +497,20 @@ void VertexCompare::operator()( Vertices const& recoVtx1, Vertices const& recoVt double pully = dy / erry; double pullz = dz / errz; if ( m_monitoring.value() ) { - if ( dz < 2 && size_diff < 3 && pv_rank < 2 && ( ntracks1 + ntracks2 ) / 2 > ntrack_bins[0] ) { - int binCount = 0; + if ( dz < 2 && size_diff < 3 && pv_rank < 2 && float( ntracks1 + ntracks2 ) / 2 > ntrack_bins[0] ) { + unsigned int binCount = 0; for ( size_t i = 1; i < ntrack_bins.size(); ++i ) { if ( std::lround( ( ntracks1 + ntracks2 ) / 2 ) <= ntrack_bins[i] ) { break; } binCount++; } - auto& monitoringHistos = *m_monitoringHistos.get(); - ++monitoringHistos.m_histo_nTracksBins_dx[binCount][dx]; - ++monitoringHistos.m_histo_nTracksBins_dy[binCount][dy]; - ++monitoringHistos.m_histo_nTracksBins_dz[binCount][dz]; - ++monitoringHistos.m_histo_pullx_Monitoring[pullx]; - ++monitoringHistos.m_histo_pully_Monitoring[pully]; - ++monitoringHistos.m_histo_pullz_Monitoring[pullz]; + if ( binCount < MonitoringHistos::s_nTrackBins ) { + ++m_monitoringHistos.value().m_histo_nTracksBins_dx[binCount][dx]; + ++m_monitoringHistos.value().m_histo_nTracksBins_dy[binCount][dy]; + ++m_monitoringHistos.value().m_histo_nTracksBins_dz[binCount][dz]; + ++m_monitoringHistos.value().m_histo_pullx_Monitoring[pullx]; + ++m_monitoringHistos.value().m_histo_pully_Monitoring[pully]; + ++m_monitoringHistos.value().m_histo_pullz_Monitoring[pullz]; + } } } if ( m_produceHistogram.value() || m_monitoring.value() ) {