From 0b6e515f223a6ff55eada6d751587f26a8d47d31 Mon Sep 17 00:00:00 2001
From: Vukan Jevtic <vukan.jevtic@cern.ch>
Date: Wed, 19 Mar 2025 13:23:16 +0100
Subject: [PATCH 1/3] New enums for DevelopmentTagger flavour tagger
---
Event/PhysEvent/include/Event/Tagger.h | 16 ++++++++++++++--
1 file changed, 14 insertions(+), 2 deletions(-)
diff --git a/Event/PhysEvent/include/Event/Tagger.h b/Event/PhysEvent/include/Event/Tagger.h
index 8c09528c234..b8c2919daf2 100644
--- a/Event/PhysEvent/include/Event/Tagger.h
+++ b/Event/PhysEvent/include/Event/Tagger.h
@@ -55,6 +55,7 @@ namespace LHCb {
OS_Charm = 15,
SS_PionBDT = 16,
Inclusive_Tagger = 17,
+ Development_Tagger = 18,
OSMuon = 10100,
OSMuonLatest = 10101,
OSMuonLatestB2OC = 10102,
@@ -93,6 +94,8 @@ namespace LHCb {
SSLambdaDev = 20499,
InclusiveTagger = 30100,
InclusiveTaggerDev = 30199,
+ DevelopmentTagger = 40100,
+ DevelopmentTaggerDev = 40199,
};
/// Copy Constructor
@@ -220,6 +223,8 @@ namespace LHCb {
return s << "SS_PionBDT";
case LHCb::Tagger::Inclusive_Tagger:
return s << "InclusiveTagger";
+ case LHCb::Tagger::Development_Tagger:
+ return s << "DevelopmentTagger";
case LHCb::Tagger::OSMuon:
return s << "OSMuon";
case LHCb::Tagger::OSMuonLatest:
@@ -296,6 +301,10 @@ namespace LHCb {
return s << "IFT";
case LHCb::Tagger::InclusiveTaggerDev:
return s << "IFTDev";
+ case LHCb::Tagger::DevelopmentTagger:
+ return s << "DevTagger";
+ case LHCb::Tagger::DevelopmentTaggerDev:
+ return s << "DevTaggerDev";
default:
return s << "ERROR wrong value " << int( e ) << " for enum LHCb::Tagger::TaggerType";
}
@@ -339,6 +348,7 @@ inline const GaudiUtils::VectorMap<std::string, LHCb::Tagger::TaggerType>& LHCb:
{"OS_Charm", OS_Charm},
{"SS_PionBDT", SS_PionBDT},
{"InclusiveTagger", Inclusive_Tagger},
+ {"DevelopmentTagger", Development_Tagger},
{"OSMuon", OSMuon},
{"OSMuonLatest", OSMuonLatest},
{"OSMuonLatestB2OC", OSMuonLatestB2OC},
@@ -375,8 +385,10 @@ inline const GaudiUtils::VectorMap<std::string, LHCb::Tagger::TaggerType>& LHCb:
{"SSLambda", SSLambda},
{"SSLambdaLatest", SSLambdaLatest},
{"SSLambdaDev", SSLambdaDev},
- {"IFT", InclusiveTagger},
- {"IFTDev", InclusiveTaggerDev}};
+ {"InclusiveTagger", InclusiveTagger},
+ {"InclusiveTaggerDev", InclusiveTaggerDev},
+ {"DevelopmentTagger", DevelopmentTagger},
+ {"DevelopmentTaggerDev", DevelopmentTaggerDev}};
return m;
}
--
GitLab
From 0019e85d47b6a56ccc2e2bbad93ab903e79f02ac Mon Sep 17 00:00:00 2001
From: Vukan Jevtic <vukan.jevtic@cern.ch>
Date: Fri, 21 Mar 2025 22:18:34 +0100
Subject: [PATCH 2/3] Modernized Tagger.h, hopefully fixed lb-dev linking
---
Event/PhysEvent/include/Event/Tagger.h | 271 +++++++------------------
1 file changed, 76 insertions(+), 195 deletions(-)
diff --git a/Event/PhysEvent/include/Event/Tagger.h b/Event/PhysEvent/include/Event/Tagger.h
index b8c2919daf2..d96573b75ad 100644
--- a/Event/PhysEvent/include/Event/Tagger.h
+++ b/Event/PhysEvent/include/Event/Tagger.h
@@ -12,11 +12,11 @@
// Include files
#include "GaudiKernel/SmartRefVector.h"
-#include "GaudiKernel/VectorMap.h"
#include <Event/Particle.h>
#include <algorithm>
#include <ostream>
#include <string>
+#include <unordered_map>
#include <vector>
// Forward declarations
@@ -120,7 +120,7 @@ namespace LHCb {
static LHCb::Tagger::TaggerType TaggerTypeToType( const std::string& aName );
/// conversion to string for enum type TaggerType
- static const std::string& TaggerTypeToString( int aEnum );
+ static const std::string& TaggerTypeToString( Tagger::TaggerType aEnum );
/// Retrieve const The type of tagger
unsigned short int type() const;
@@ -128,6 +128,9 @@ namespace LHCb {
/// Update The type of tagger
void setType( unsigned short int value );
+ /// Update The type of tagger
+ void setType( TaggerType value );
+
/// Retrieve const decision of tagger
short int decision() const;
@@ -181,133 +184,72 @@ namespace LHCb {
float m_charge; ///< (weighted) charge of the tagging particle
SmartRefVector<LHCb::Particle> m_taggerParts; ///< Vector of Particle(s) used to build the Tagger
- static const GaudiUtils::VectorMap<std::string, TaggerType>& s_TaggerTypeTypMap();
+ static inline const std::unordered_map<std::string, TaggerType> m_tagger_type_map{
+ {"none", TaggerType::none},
+ {"unknown", TaggerType::unknown},
+ {"OS_Muon", TaggerType::OS_Muon},
+ {"OS_Electron", TaggerType::OS_Electron},
+ {"OS_Kaon", TaggerType::OS_Kaon},
+ {"SS_Kaon", TaggerType::SS_Kaon},
+ {"SS_Pion", TaggerType::SS_Pion},
+ {"jetCharge", TaggerType::jetCharge},
+ {"OS_jetCharge", TaggerType::OS_jetCharge},
+ {"SS_jetCharge", TaggerType::SS_jetCharge},
+ {"VtxCharge", TaggerType::VtxCharge},
+ {"Topology", TaggerType::Topology},
+ {"OS_nnetKaon", TaggerType::OS_nnetKaon},
+ {"SS_nnetKaon", TaggerType::SS_nnetKaon},
+ {"SS_Proton", TaggerType::SS_Proton},
+ {"OS_Charm", TaggerType::OS_Charm},
+ {"SS_PionBDT", TaggerType::SS_PionBDT},
+ {"InclusiveTagger", TaggerType::Inclusive_Tagger},
+ {"DevelopmentTagger", TaggerType::Development_Tagger},
+ {"OSMuon", TaggerType::OSMuon},
+ {"OSMuonLatest", TaggerType::OSMuonLatest},
+ {"OSMuonLatestB2OC", TaggerType::OSMuonLatestB2OC},
+ {"OSMuonLatestB2CC", TaggerType::OSMuonLatestB2CC},
+ {"OSMuonDev", TaggerType::OSMuonDev},
+ {"OSElectron", TaggerType::OSElectron},
+ {"OSElectronLatest", TaggerType::OSElectronLatest},
+ {"OSElectronLatestB2OC", TaggerType::OSElectronLatestB2OC},
+ {"OSElectronLatestB2CC", TaggerType::OSElectronLatestB2CC},
+ {"OSElectronDev", TaggerType::OSElectronDev},
+ {"OSKaon", TaggerType::OSKaon},
+ {"OSKaonLatest", TaggerType::OSKaonLatest},
+ {"OSKaonLatestB2OC", TaggerType::OSKaonLatestB2OC},
+ {"OSKaonLatestB2CC", TaggerType::OSKaonLatestB2CC},
+ {"OSKaonDev", TaggerType::OSKaonDev},
+ {"OSVtxCh", TaggerType::OSVtxCh},
+ {"OSVtxChLatest", TaggerType::OSVtxChLatest},
+ {"OSVtxChDev", TaggerType::OSVtxChDev},
+ {"OSCharm", TaggerType::OSCharm},
+ {"OSCharmLatest", TaggerType::OSCharmLatest},
+ {"OSCharmDev", TaggerType::OSCharmDev},
+ {"OSProton", TaggerType::OSProton},
+ {"OSProtonLatest", TaggerType::OSProtonLatest},
+ {"OSProtonDev", TaggerType::OSProtonDev},
+ {"SSKaon", TaggerType::SSKaon},
+ {"SSKaonLatest", TaggerType::SSKaonLatest},
+ {"SSKaonDev", TaggerType::SSKaonDev},
+ {"SSPion", TaggerType::SSPion},
+ {"SSPionLatest", TaggerType::SSPionLatest},
+ {"SSPionDev", TaggerType::SSPionDev},
+ {"SSProton", TaggerType::SSProton},
+ {"SSProtonLatest", TaggerType::SSProtonLatest},
+ {"SSProtonDev", TaggerType::SSProtonDev},
+ {"SSLambda", TaggerType::SSLambda},
+ {"SSLambdaLatest", TaggerType::SSLambdaLatest},
+ {"SSLambdaDev", TaggerType::SSLambdaDev},
+ {"InclusiveTagger", TaggerType::InclusiveTagger},
+ {"InclusiveTaggerDev", TaggerType::InclusiveTaggerDev},
+ {"DevelopmentTagger", TaggerType::DevelopmentTagger},
+ {"DevelopmentTaggerDev", TaggerType::DevelopmentTaggerDev}};
}; // class Tagger
- inline std::ostream& operator<<( std::ostream& s, LHCb::Tagger::TaggerType e ) {
- switch ( e ) {
- case LHCb::Tagger::none:
- return s << "none";
- case LHCb::Tagger::unknown:
- return s << "unknown";
- case LHCb::Tagger::OS_Muon:
- return s << "OS_Muon";
- case LHCb::Tagger::OS_Electron:
- return s << "OS_Electron";
- case LHCb::Tagger::OS_Kaon:
- return s << "OS_Kaon";
- case LHCb::Tagger::SS_Kaon:
- return s << "SS_Kaon";
- case LHCb::Tagger::SS_Pion:
- return s << "SS_Pion";
- case LHCb::Tagger::jetCharge:
- return s << "jetCharge";
- case LHCb::Tagger::OS_jetCharge:
- return s << "OS_jetCharge";
- case LHCb::Tagger::SS_jetCharge:
- return s << "SS_jetCharge";
- case LHCb::Tagger::VtxCharge:
- return s << "VtxCharge";
- case LHCb::Tagger::Topology:
- return s << "Topology";
- case LHCb::Tagger::OS_nnetKaon:
- return s << "OS_nnetKaon";
- case LHCb::Tagger::SS_nnetKaon:
- return s << "SS_nnetKaon";
- case LHCb::Tagger::SS_Proton:
- return s << "SS_Proton";
- case LHCb::Tagger::OS_Charm:
- return s << "OS_Charm";
- case LHCb::Tagger::SS_PionBDT:
- return s << "SS_PionBDT";
- case LHCb::Tagger::Inclusive_Tagger:
- return s << "InclusiveTagger";
- case LHCb::Tagger::Development_Tagger:
- return s << "DevelopmentTagger";
- case LHCb::Tagger::OSMuon:
- return s << "OSMuon";
- case LHCb::Tagger::OSMuonLatest:
- return s << "OSMuonLatest";
- case LHCb::Tagger::OSMuonLatestB2OC:
- return s << "OSMuonLatestB2OC";
- case LHCb::Tagger::OSMuonLatestB2CC:
- return s << "OSMuonLatestB2CC";
- case LHCb::Tagger::OSMuonDev:
- return s << "OSMuonDev";
- case LHCb::Tagger::OSElectron:
- return s << "OSElectron";
- case LHCb::Tagger::OSElectronLatest:
- return s << "OSElectronLatest";
- case LHCb::Tagger::OSElectronLatestB2OC:
- return s << "OSElectronLatestB2OC";
- case LHCb::Tagger::OSElectronLatestB2CC:
- return s << "OSElectronLatestB2CC";
- case LHCb::Tagger::OSElectronDev:
- return s << "OSElectronDev";
- case LHCb::Tagger::OSKaon:
- return s << "OSKaon";
- case LHCb::Tagger::OSKaonLatest:
- return s << "OSKaonLatest";
- case LHCb::Tagger::OSKaonLatestB2OC:
- return s << "OSKaonLatestB2OC";
- case LHCb::Tagger::OSKaonLatestB2CC:
- return s << "OSKaonLatestB2CC";
- case LHCb::Tagger::OSKaonDev:
- return s << "OSKaonDev";
- case LHCb::Tagger::OSVtxCh:
- return s << "OSVtxCh";
- case LHCb::Tagger::OSVtxChLatest:
- return s << "OSVtxChLatest";
- case LHCb::Tagger::OSVtxChDev:
- return s << "OSVtxChDev";
- case LHCb::Tagger::OSCharm:
- return s << "OSCharm";
- case LHCb::Tagger::OSCharmLatest:
- return s << "OSCharmLatest";
- case LHCb::Tagger::OSCharmDev:
- return s << "OSCharmDev";
- case LHCb::Tagger::OSProton:
- return s << "OSProton";
- case LHCb::Tagger::OSProtonLatest:
- return s << "OSProtonLatest";
- case LHCb::Tagger::OSProtonDev:
- return s << "OSProtonDev";
- case LHCb::Tagger::SSKaon:
- return s << "SSKaon";
- case LHCb::Tagger::SSKaonLatest:
- return s << "SSKaonLatest";
- case LHCb::Tagger::SSKaonDev:
- return s << "SSKaonDev";
- case LHCb::Tagger::SSPion:
- return s << "SSPion";
- case LHCb::Tagger::SSPionLatest:
- return s << "SSPionLatest";
- case LHCb::Tagger::SSPionDev:
- return s << "SSPionDev";
- case LHCb::Tagger::SSProton:
- return s << "SSProton";
- case LHCb::Tagger::SSProtonLatest:
- return s << "SSProtonLatest";
- case LHCb::Tagger::SSProtonDev:
- return s << "SSProtonDev";
- case LHCb::Tagger::SSLambda:
- return s << "SSLambda";
- case LHCb::Tagger::SSLambdaLatest:
- return s << "SSLambdaLatest";
- case LHCb::Tagger::SSLambdaDev:
- return s << "SSLambdaDev";
- case LHCb::Tagger::InclusiveTagger:
- return s << "IFT";
- case LHCb::Tagger::InclusiveTaggerDev:
- return s << "IFTDev";
- case LHCb::Tagger::DevelopmentTagger:
- return s << "DevTagger";
- case LHCb::Tagger::DevelopmentTaggerDev:
- return s << "DevTaggerDev";
- default:
- return s << "ERROR wrong value " << int( e ) << " for enum LHCb::Tagger::TaggerType";
- }
+ inline std::ostream& operator<<( std::ostream& s, Tagger::TaggerType e ) {
+ s << Tagger::TaggerTypeToString( e );
+ return s;
}
} // namespace LHCb
@@ -329,85 +271,24 @@ inline std::ostream& LHCb::Tagger::fillStream( std::ostream& s ) const {
return s;
}
-inline const GaudiUtils::VectorMap<std::string, LHCb::Tagger::TaggerType>& LHCb::Tagger::s_TaggerTypeTypMap() {
- static const GaudiUtils::VectorMap<std::string, TaggerType> m = {{"none", none},
- {"unknown", unknown},
- {"OS_Muon", OS_Muon},
- {"OS_Electron", OS_Electron},
- {"OS_Kaon", OS_Kaon},
- {"SS_Kaon", SS_Kaon},
- {"SS_Pion", SS_Pion},
- {"jetCharge", jetCharge},
- {"OS_jetCharge", OS_jetCharge},
- {"SS_jetCharge", SS_jetCharge},
- {"VtxCharge", VtxCharge},
- {"Topology", Topology},
- {"OS_nnetKaon", OS_nnetKaon},
- {"SS_nnetKaon", SS_nnetKaon},
- {"SS_Proton", SS_Proton},
- {"OS_Charm", OS_Charm},
- {"SS_PionBDT", SS_PionBDT},
- {"InclusiveTagger", Inclusive_Tagger},
- {"DevelopmentTagger", Development_Tagger},
- {"OSMuon", OSMuon},
- {"OSMuonLatest", OSMuonLatest},
- {"OSMuonLatestB2OC", OSMuonLatestB2OC},
- {"OSMuonLatestB2CC", OSMuonLatestB2CC},
- {"OSMuonDev", OSMuonDev},
- {"OSElectron", OSElectron},
- {"OSElectronLatest", OSElectronLatest},
- {"OSElectronLatestB2OC", OSElectronLatestB2OC},
- {"OSElectronLatestB2CC", OSElectronLatestB2CC},
- {"OSElectronDev", OSElectronDev},
- {"OSKaon", OSKaon},
- {"OSKaonLatest", OSKaonLatest},
- {"OSKaonLatestB2OC", OSKaonLatestB2OC},
- {"OSKaonLatestB2CC", OSKaonLatestB2CC},
- {"OSKaonDev", OSKaonDev},
- {"OSVtxCh", OSVtxCh},
- {"OSVtxChLatest", OSVtxChLatest},
- {"OSVtxChDev", OSVtxChDev},
- {"OSCharm", OSCharm},
- {"OSCharmLatest", OSCharmLatest},
- {"OSCharmDev", OSCharmDev},
- {"OSProton", OSProton},
- {"OSProtonLatest", OSProtonLatest},
- {"OSProtonDev", OSProtonDev},
- {"SSKaon", SSKaon},
- {"SSKaonLatest", SSKaonLatest},
- {"SSKaonDev", SSKaonDev},
- {"SSPion", SSPion},
- {"SSPionLatest", SSPionLatest},
- {"SSPionDev", SSPionDev},
- {"SSProton", SSProton},
- {"SSProtonLatest", SSProtonLatest},
- {"SSProtonDev", SSProtonDev},
- {"SSLambda", SSLambda},
- {"SSLambdaLatest", SSLambdaLatest},
- {"SSLambdaDev", SSLambdaDev},
- {"InclusiveTagger", InclusiveTagger},
- {"InclusiveTaggerDev", InclusiveTaggerDev},
- {"DevelopmentTagger", DevelopmentTagger},
- {"DevelopmentTaggerDev", DevelopmentTaggerDev}};
- return m;
-}
-
inline LHCb::Tagger::TaggerType LHCb::Tagger::TaggerTypeToType( const std::string& aName ) {
- auto iter = s_TaggerTypeTypMap().find( aName );
- return iter != s_TaggerTypeTypMap().end() ? iter->second : unknown;
+ auto iter = m_tagger_type_map.find( aName );
+ return iter != m_tagger_type_map.end() ? iter->second : TaggerType::unknown;
}
-inline const std::string& LHCb::Tagger::TaggerTypeToString( int aEnum ) {
+inline const std::string& LHCb::Tagger::TaggerTypeToString( Tagger::TaggerType aEnum ) {
static const std::string s_unknown = "unknown";
- auto iter = std::find_if( s_TaggerTypeTypMap().begin(), s_TaggerTypeTypMap().end(),
- [&]( const std::pair<const std::string, TaggerType>& i ) { return i.second == aEnum; } );
- return iter != s_TaggerTypeTypMap().end() ? iter->first : s_unknown;
+ auto iter = std::find_if( m_tagger_type_map.begin(), m_tagger_type_map.end(),
+ [aEnum]( const auto& pair ) { return pair.second == aEnum; } );
+ return iter != m_tagger_type_map.end() ? iter->first : s_unknown;
}
inline unsigned short int LHCb::Tagger::type() const { return m_type; }
inline void LHCb::Tagger::setType( unsigned short int value ) { m_type = value; }
+inline void LHCb::Tagger::setType( TaggerType value ) { m_type = static_cast<unsigned short>( value ); }
+
inline short int LHCb::Tagger::decision() const { return m_decision; }
inline void LHCb::Tagger::setDecision( short int value ) { m_decision = value; }
--
GitLab
From 231731fc46a9824085e795bb0bc7dbb98e7387e2 Mon Sep 17 00:00:00 2001
From: Vukan Jevtic <vukan.jevtic@cern.ch>
Date: Mon, 24 Mar 2025 17:07:36 +0100
Subject: [PATCH 3/3] Separate implementation of class Tagger.
---
Event/PhysEvent/CMakeLists.txt | 1 +
Event/PhysEvent/include/Event/Tagger.h | 185 +++++++------------------
Event/PhysEvent/src/Tagger.cpp | 93 +++++++++++++
3 files changed, 141 insertions(+), 138 deletions(-)
create mode 100644 Event/PhysEvent/src/Tagger.cpp
diff --git a/Event/PhysEvent/CMakeLists.txt b/Event/PhysEvent/CMakeLists.txt
index feda598ce4e..8b79cd897b4 100644
--- a/Event/PhysEvent/CMakeLists.txt
+++ b/Event/PhysEvent/CMakeLists.txt
@@ -17,6 +17,7 @@ gaudi_add_library(PhysEvent
SOURCES
src/Particle.cpp
src/Vertex.cpp
+ src/Tagger.cpp
LINK
PUBLIC
Gaudi::GaudiKernel
diff --git a/Event/PhysEvent/include/Event/Tagger.h b/Event/PhysEvent/include/Event/Tagger.h
index d96573b75ad..fbd23e31034 100644
--- a/Event/PhysEvent/include/Event/Tagger.h
+++ b/Event/PhysEvent/include/Event/Tagger.h
@@ -16,7 +16,6 @@
#include <algorithm>
#include <ostream>
#include <string>
-#include <unordered_map>
#include <vector>
// Forward declarations
@@ -33,7 +32,7 @@ namespace LHCb {
*
*/
- class Tagger {
+ class Tagger final {
public:
/// The type of tagger which has produced this decision
enum TaggerType {
@@ -98,23 +97,12 @@ namespace LHCb {
DevelopmentTaggerDev = 40199,
};
- /// Copy Constructor
- Tagger( const Tagger& c )
- : m_type( c.type() )
- , m_decision( c.decision() )
- , m_omega( c.omega() )
- , m_mvaValue( c.mvaValue() )
- , m_charge( c.charge() )
- , m_taggerParts( c.taggerParts() ) {}
-
- /// Default Constructor
- Tagger() : m_type( 0 ), m_decision( 0 ), m_omega( 0.50 ), m_mvaValue( 0.0 ), m_charge( 0.0 ) {}
-
- /// Default Destructor
- virtual ~Tagger() {}
+ Tagger() = default;
+ Tagger( const Tagger& c ) = default;
+ ~Tagger() = default;
/// Fill the ASCII output stream
- virtual std::ostream& fillStream( std::ostream& s ) const;
+ std::ostream& fillStream( std::ostream& s ) const;
/// conversion of string to enum for type TaggerType
static LHCb::Tagger::TaggerType TaggerTypeToType( const std::string& aName );
@@ -177,147 +165,68 @@ namespace LHCb {
protected:
private:
- unsigned short int m_type; ///< The type of tagger
- short int m_decision; ///< decision of tagger
- float m_omega; ///< wrong tag fraction of tagger from MC tuning
- float m_mvaValue; ///< raw output of the mva
- float m_charge; ///< (weighted) charge of the tagging particle
- SmartRefVector<LHCb::Particle> m_taggerParts; ///< Vector of Particle(s) used to build the Tagger
-
- static inline const std::unordered_map<std::string, TaggerType> m_tagger_type_map{
- {"none", TaggerType::none},
- {"unknown", TaggerType::unknown},
- {"OS_Muon", TaggerType::OS_Muon},
- {"OS_Electron", TaggerType::OS_Electron},
- {"OS_Kaon", TaggerType::OS_Kaon},
- {"SS_Kaon", TaggerType::SS_Kaon},
- {"SS_Pion", TaggerType::SS_Pion},
- {"jetCharge", TaggerType::jetCharge},
- {"OS_jetCharge", TaggerType::OS_jetCharge},
- {"SS_jetCharge", TaggerType::SS_jetCharge},
- {"VtxCharge", TaggerType::VtxCharge},
- {"Topology", TaggerType::Topology},
- {"OS_nnetKaon", TaggerType::OS_nnetKaon},
- {"SS_nnetKaon", TaggerType::SS_nnetKaon},
- {"SS_Proton", TaggerType::SS_Proton},
- {"OS_Charm", TaggerType::OS_Charm},
- {"SS_PionBDT", TaggerType::SS_PionBDT},
- {"InclusiveTagger", TaggerType::Inclusive_Tagger},
- {"DevelopmentTagger", TaggerType::Development_Tagger},
- {"OSMuon", TaggerType::OSMuon},
- {"OSMuonLatest", TaggerType::OSMuonLatest},
- {"OSMuonLatestB2OC", TaggerType::OSMuonLatestB2OC},
- {"OSMuonLatestB2CC", TaggerType::OSMuonLatestB2CC},
- {"OSMuonDev", TaggerType::OSMuonDev},
- {"OSElectron", TaggerType::OSElectron},
- {"OSElectronLatest", TaggerType::OSElectronLatest},
- {"OSElectronLatestB2OC", TaggerType::OSElectronLatestB2OC},
- {"OSElectronLatestB2CC", TaggerType::OSElectronLatestB2CC},
- {"OSElectronDev", TaggerType::OSElectronDev},
- {"OSKaon", TaggerType::OSKaon},
- {"OSKaonLatest", TaggerType::OSKaonLatest},
- {"OSKaonLatestB2OC", TaggerType::OSKaonLatestB2OC},
- {"OSKaonLatestB2CC", TaggerType::OSKaonLatestB2CC},
- {"OSKaonDev", TaggerType::OSKaonDev},
- {"OSVtxCh", TaggerType::OSVtxCh},
- {"OSVtxChLatest", TaggerType::OSVtxChLatest},
- {"OSVtxChDev", TaggerType::OSVtxChDev},
- {"OSCharm", TaggerType::OSCharm},
- {"OSCharmLatest", TaggerType::OSCharmLatest},
- {"OSCharmDev", TaggerType::OSCharmDev},
- {"OSProton", TaggerType::OSProton},
- {"OSProtonLatest", TaggerType::OSProtonLatest},
- {"OSProtonDev", TaggerType::OSProtonDev},
- {"SSKaon", TaggerType::SSKaon},
- {"SSKaonLatest", TaggerType::SSKaonLatest},
- {"SSKaonDev", TaggerType::SSKaonDev},
- {"SSPion", TaggerType::SSPion},
- {"SSPionLatest", TaggerType::SSPionLatest},
- {"SSPionDev", TaggerType::SSPionDev},
- {"SSProton", TaggerType::SSProton},
- {"SSProtonLatest", TaggerType::SSProtonLatest},
- {"SSProtonDev", TaggerType::SSProtonDev},
- {"SSLambda", TaggerType::SSLambda},
- {"SSLambdaLatest", TaggerType::SSLambdaLatest},
- {"SSLambdaDev", TaggerType::SSLambdaDev},
- {"InclusiveTagger", TaggerType::InclusiveTagger},
- {"InclusiveTaggerDev", TaggerType::InclusiveTaggerDev},
- {"DevelopmentTagger", TaggerType::DevelopmentTagger},
- {"DevelopmentTaggerDev", TaggerType::DevelopmentTaggerDev}};
+ unsigned short int m_type = TaggerType::none; ///< The type of tagger
+ short int m_decision = 0; ///< decision of tagger
+ float m_omega = 0.5; ///< wrong tag fraction of tagger from MC tuning
+ float m_mvaValue = 0; ///< raw output of the mva
+ float m_charge = 0; ///< (weighted) charge of the tagging particle
+ SmartRefVector<LHCb::Particle> m_taggerParts; ///< Vector of Particle(s) used to build the Tagger
}; // class Tagger
- inline std::ostream& operator<<( std::ostream& s, Tagger::TaggerType e ) {
- s << Tagger::TaggerTypeToString( e );
- return s;
- }
-
-} // namespace LHCb
-
-// -----------------------------------------------------------------------------
-// end of class
-// -----------------------------------------------------------------------------
-
-// Including forward declarations
+ inline std::ostream& operator<<( std::ostream& s, Tagger::TaggerType e );
-inline std::ostream& LHCb::Tagger::fillStream( std::ostream& s ) const {
- s << "{ "
- << "type : " << m_type << std::endl
- << "decision : " << m_decision << std::endl
- << "omega : " << m_omega << std::endl
- << "mvaValue : " << m_mvaValue << std::endl
- << "charge : " << m_charge << std::endl
- << " }";
- return s;
-}
+ // -----------------------------------------------------------------------------
+ // end of class
+ // -----------------------------------------------------------------------------
-inline LHCb::Tagger::TaggerType LHCb::Tagger::TaggerTypeToType( const std::string& aName ) {
- auto iter = m_tagger_type_map.find( aName );
- return iter != m_tagger_type_map.end() ? iter->second : TaggerType::unknown;
-}
+ // Including forward declarations
-inline const std::string& LHCb::Tagger::TaggerTypeToString( Tagger::TaggerType aEnum ) {
- static const std::string s_unknown = "unknown";
- auto iter = std::find_if( m_tagger_type_map.begin(), m_tagger_type_map.end(),
- [aEnum]( const auto& pair ) { return pair.second == aEnum; } );
- return iter != m_tagger_type_map.end() ? iter->first : s_unknown;
-}
+ inline std::ostream& LHCb::Tagger::fillStream( std::ostream& s ) const {
+ s << "{ "
+ << "type : " << m_type << std::endl
+ << "decision : " << m_decision << std::endl
+ << "omega : " << m_omega << std::endl
+ << "mvaValue : " << m_mvaValue << std::endl
+ << "charge : " << m_charge << std::endl
+ << " }";
+ return s;
+ }
-inline unsigned short int LHCb::Tagger::type() const { return m_type; }
+ inline unsigned short int Tagger::type() const { return m_type; }
-inline void LHCb::Tagger::setType( unsigned short int value ) { m_type = value; }
+ inline void Tagger::setType( unsigned short int value ) { m_type = value; }
-inline void LHCb::Tagger::setType( TaggerType value ) { m_type = static_cast<unsigned short>( value ); }
+ inline void Tagger::setType( TaggerType value ) { m_type = static_cast<unsigned short>( value ); }
-inline short int LHCb::Tagger::decision() const { return m_decision; }
+ inline short int Tagger::decision() const { return m_decision; }
-inline void LHCb::Tagger::setDecision( short int value ) { m_decision = value; }
+ inline void Tagger::setDecision( short int value ) { m_decision = value; }
-inline float LHCb::Tagger::omega() const { return m_omega; }
+ inline float Tagger::omega() const { return m_omega; }
-inline void LHCb::Tagger::setOmega( float value ) { m_omega = value; }
+ inline void Tagger::setOmega( float value ) { m_omega = value; }
-inline float LHCb::Tagger::mvaValue() const { return m_mvaValue; }
+ inline float Tagger::mvaValue() const { return m_mvaValue; }
-inline void LHCb::Tagger::setMvaValue( float value ) { m_mvaValue = value; }
+ inline void Tagger::setMvaValue( float value ) { m_mvaValue = value; }
-inline float LHCb::Tagger::charge() const { return m_charge; }
+ inline float Tagger::charge() const { return m_charge; }
-inline void LHCb::Tagger::setCharge( float value ) { m_charge = value; }
+ inline void Tagger::setCharge( float value ) { m_charge = value; }
-inline const SmartRefVector<LHCb::Particle>& LHCb::Tagger::taggerParts() const { return m_taggerParts; }
+ inline const SmartRefVector<Particle>& Tagger::taggerParts() const { return m_taggerParts; }
-inline void LHCb::Tagger::setTaggerParts( const SmartRefVector<LHCb::Particle>& value ) { m_taggerParts = value; }
+ inline void Tagger::setTaggerParts( const SmartRefVector<Particle>& value ) { m_taggerParts = value; }
-inline void LHCb::Tagger::addToTaggerParts( const SmartRef<LHCb::Particle>& value ) {
- m_taggerParts.push_back( value );
-}
+ inline void Tagger::addToTaggerParts( const SmartRef<Particle>& value ) { m_taggerParts.push_back( value ); }
-inline void LHCb::Tagger::addToTaggerParts( const LHCb::Particle* value ) { m_taggerParts.push_back( value ); }
+ inline void Tagger::addToTaggerParts( const Particle* value ) { m_taggerParts.push_back( value ); }
-inline void LHCb::Tagger::removeFromTaggerParts( const SmartRef<LHCb::Particle>& value ) {
- auto i = std::remove( m_taggerParts.begin(), m_taggerParts.end(), value );
- m_taggerParts.erase( i, m_taggerParts.end() );
-}
+ inline void Tagger::removeFromTaggerParts( const SmartRef<Particle>& value ) {
+ auto i = std::remove( m_taggerParts.begin(), m_taggerParts.end(), value );
+ m_taggerParts.erase( i, m_taggerParts.end() );
+ }
-inline void LHCb::Tagger::clearTaggerParts() { m_taggerParts.clear(); }
+ inline void Tagger::clearTaggerParts() { m_taggerParts.clear(); }
+} // namespace LHCb
diff --git a/Event/PhysEvent/src/Tagger.cpp b/Event/PhysEvent/src/Tagger.cpp
new file mode 100644
index 00000000000..cb3f738bd3d
--- /dev/null
+++ b/Event/PhysEvent/src/Tagger.cpp
@@ -0,0 +1,93 @@
+/*****************************************************************************\
+* (c) Copyright 2025 CERN for the benefit of the LHCb Collaboration *
+* *
+* This software is distributed under the terms of the GNU General Public *
+* Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING". *
+* *
+* In applying this licence, CERN does not waive the privileges and immunities *
+* granted to it by virtue of its status as an Intergovernmental Organization *
+* or submit itself to any jurisdiction. *
+\*****************************************************************************/
+#include "Event/Tagger.h"
+#include "GaudiKernel/VectorMap.h"
+
+namespace {
+ using TType = LHCb::Tagger::TaggerType;
+ const GaudiUtils::VectorMap<std::string, TType> m_tagger_type_map = {
+ {"none", TType::none},
+ {"unknown", TType::unknown},
+ {"OS_Muon", TType::OS_Muon},
+ {"OS_Electron", TType::OS_Electron},
+ {"OS_Kaon", TType::OS_Kaon},
+ {"SS_Kaon", TType::SS_Kaon},
+ {"SS_Pion", TType::SS_Pion},
+ {"jetCharge", TType::jetCharge},
+ {"OS_jetCharge", TType::OS_jetCharge},
+ {"SS_jetCharge", TType::SS_jetCharge},
+ {"VtxCharge", TType::VtxCharge},
+ {"Topology", TType::Topology},
+ {"OS_nnetKaon", TType::OS_nnetKaon},
+ {"SS_nnetKaon", TType::SS_nnetKaon},
+ {"SS_Proton", TType::SS_Proton},
+ {"OS_Charm", TType::OS_Charm},
+ {"SS_PionBDT", TType::SS_PionBDT},
+ {"InclusiveTagger", TType::Inclusive_Tagger},
+ {"DevelopmentTagger", TType::Development_Tagger},
+ {"OSMuon", TType::OSMuon},
+ {"OSMuonLatest", TType::OSMuonLatest},
+ {"OSMuonLatestB2OC", TType::OSMuonLatestB2OC},
+ {"OSMuonLatestB2CC", TType::OSMuonLatestB2CC},
+ {"OSMuonDev", TType::OSMuonDev},
+ {"OSElectron", TType::OSElectron},
+ {"OSElectronLatest", TType::OSElectronLatest},
+ {"OSElectronLatestB2OC", TType::OSElectronLatestB2OC},
+ {"OSElectronLatestB2CC", TType::OSElectronLatestB2CC},
+ {"OSElectronDev", TType::OSElectronDev},
+ {"OSKaon", TType::OSKaon},
+ {"OSKaonLatest", TType::OSKaonLatest},
+ {"OSKaonLatestB2OC", TType::OSKaonLatestB2OC},
+ {"OSKaonLatestB2CC", TType::OSKaonLatestB2CC},
+ {"OSKaonDev", TType::OSKaonDev},
+ {"OSVtxCh", TType::OSVtxCh},
+ {"OSVtxChLatest", TType::OSVtxChLatest},
+ {"OSVtxChDev", TType::OSVtxChDev},
+ {"OSCharm", TType::OSCharm},
+ {"OSCharmLatest", TType::OSCharmLatest},
+ {"OSCharmDev", TType::OSCharmDev},
+ {"OSProton", TType::OSProton},
+ {"OSProtonLatest", TType::OSProtonLatest},
+ {"OSProtonDev", TType::OSProtonDev},
+ {"SSKaon", TType::SSKaon},
+ {"SSKaonLatest", TType::SSKaonLatest},
+ {"SSKaonDev", TType::SSKaonDev},
+ {"SSPion", TType::SSPion},
+ {"SSPionLatest", TType::SSPionLatest},
+ {"SSPionDev", TType::SSPionDev},
+ {"SSProton", TType::SSProton},
+ {"SSProtonLatest", TType::SSProtonLatest},
+ {"SSProtonDev", TType::SSProtonDev},
+ {"SSLambda", TType::SSLambda},
+ {"SSLambdaLatest", TType::SSLambdaLatest},
+ {"SSLambdaDev", TType::SSLambdaDev},
+ {"InclusiveTagger", TType::InclusiveTagger},
+ {"InclusiveTaggerDev", TType::InclusiveTaggerDev},
+ {"DevelopmentTagger", TType::DevelopmentTagger},
+ {"DevelopmentTaggerDev", TType::DevelopmentTaggerDev}};
+} // namespace
+
+std::ostream& operator<<( std::ostream& s, LHCb::Tagger::TaggerType e ) {
+ s << LHCb::Tagger::TaggerTypeToString( e );
+ return s;
+}
+
+LHCb::Tagger::TaggerType LHCb::Tagger::TaggerTypeToType( const std::string& aName ) {
+ auto iter = m_tagger_type_map.find( aName );
+ return iter != m_tagger_type_map.end() ? iter->second : TaggerType::unknown;
+}
+
+const std::string& LHCb::Tagger::TaggerTypeToString( Tagger::TaggerType aEnum ) {
+ static const std::string s_unknown = "unknown";
+ auto iter = std::find_if( m_tagger_type_map.begin(), m_tagger_type_map.end(),
+ [aEnum]( const auto& pair ) { return pair.second == aEnum; } );
+ return iter != m_tagger_type_map.end() ? iter->first : s_unknown;
+}
--
GitLab