diff --git a/Event/PhysEvent/CMakeLists.txt b/Event/PhysEvent/CMakeLists.txt
index feda598ce4ed5d05e1a5d8833e4b19efd89c55fb..8b79cd897b4fdf1cf575f1809bd5c4e5736db3ad 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 8c09528c234bc19d33e736a8157b7ebf00904e3c..fbd23e3103404970ba77575dffcb811882afa609 100644
--- a/Event/PhysEvent/include/Event/Tagger.h
+++ b/Event/PhysEvent/include/Event/Tagger.h
@@ -12,7 +12,6 @@
// Include files
#include "GaudiKernel/SmartRefVector.h"
-#include "GaudiKernel/VectorMap.h"
#include <Event/Particle.h>
#include <algorithm>
#include <ostream>
@@ -33,7 +32,7 @@ namespace LHCb {
*
*/
- class Tagger {
+ class Tagger final {
public:
/// The type of tagger which has produced this decision
enum TaggerType {
@@ -55,6 +54,7 @@ namespace LHCb {
OS_Charm = 15,
SS_PionBDT = 16,
Inclusive_Tagger = 17,
+ Development_Tagger = 18,
OSMuon = 10100,
OSMuonLatest = 10101,
OSMuonLatestB2OC = 10102,
@@ -93,31 +93,22 @@ namespace LHCb {
SSLambdaDev = 20499,
InclusiveTagger = 30100,
InclusiveTaggerDev = 30199,
+ DevelopmentTagger = 40100,
+ 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 );
/// 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;
@@ -125,6 +116,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;
@@ -171,260 +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 const GaudiUtils::VectorMap<std::string, TaggerType>& s_TaggerTypeTypMap();
+ 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, 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::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";
- default:
- return s << "ERROR wrong value " << int( e ) << " for enum LHCb::Tagger::TaggerType";
- }
+ inline std::ostream& operator<<( std::ostream& s, Tagger::TaggerType e );
+
+ // -----------------------------------------------------------------------------
+ // end of class
+ // -----------------------------------------------------------------------------
+
+ // Including forward declarations
+
+ 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;
}
-} // namespace LHCb
+ inline unsigned short int Tagger::type() const { return m_type; }
+
+ inline void Tagger::setType( unsigned short int value ) { m_type = value; }
+
+ inline void Tagger::setType( TaggerType value ) { m_type = static_cast<unsigned short>( value ); }
+
+ inline short int Tagger::decision() const { return m_decision; }
+
+ inline void Tagger::setDecision( short int value ) { m_decision = value; }
-// -----------------------------------------------------------------------------
-// end of class
-// -----------------------------------------------------------------------------
-
-// Including forward declarations
-
-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 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},
- {"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},
- {"IFT", InclusiveTagger},
- {"IFTDev", InclusiveTaggerDev}};
- 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;
-}
-
-inline const std::string& LHCb::Tagger::TaggerTypeToString( int 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;
-}
-
-inline unsigned short int LHCb::Tagger::type() const { return m_type; }
-
-inline void LHCb::Tagger::setType( unsigned short int value ) { m_type = value; }
-
-inline short int LHCb::Tagger::decision() const { return m_decision; }
-
-inline void LHCb::Tagger::setDecision( short int value ) { m_decision = value; }
-
-inline float LHCb::Tagger::omega() const { return m_omega; }
-
-inline void LHCb::Tagger::setOmega( float value ) { m_omega = value; }
-
-inline float LHCb::Tagger::mvaValue() const { return m_mvaValue; }
-
-inline void LHCb::Tagger::setMvaValue( float value ) { m_mvaValue = value; }
-
-inline float LHCb::Tagger::charge() const { return m_charge; }
-
-inline void LHCb::Tagger::setCharge( float value ) { m_charge = value; }
-
-inline const SmartRefVector<LHCb::Particle>& LHCb::Tagger::taggerParts() const { return m_taggerParts; }
-
-inline void LHCb::Tagger::setTaggerParts( const SmartRefVector<LHCb::Particle>& value ) { m_taggerParts = value; }
-
-inline void LHCb::Tagger::addToTaggerParts( const SmartRef<LHCb::Particle>& value ) {
- m_taggerParts.push_back( value );
-}
-
-inline void LHCb::Tagger::addToTaggerParts( const LHCb::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 LHCb::Tagger::clearTaggerParts() { m_taggerParts.clear(); }
+ inline float Tagger::omega() const { return m_omega; }
+
+ inline void Tagger::setOmega( float value ) { m_omega = value; }
+
+ inline float Tagger::mvaValue() const { return m_mvaValue; }
+
+ inline void Tagger::setMvaValue( float value ) { m_mvaValue = value; }
+
+ inline float Tagger::charge() const { return m_charge; }
+
+ inline void Tagger::setCharge( float value ) { m_charge = value; }
+
+ inline const SmartRefVector<Particle>& Tagger::taggerParts() const { return m_taggerParts; }
+
+ inline void Tagger::setTaggerParts( const SmartRefVector<Particle>& value ) { m_taggerParts = value; }
+
+ inline void Tagger::addToTaggerParts( const SmartRef<Particle>& value ) { m_taggerParts.push_back( value ); }
+
+ inline void Tagger::addToTaggerParts( const Particle* value ) { m_taggerParts.push_back( value ); }
+
+ 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 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 0000000000000000000000000000000000000000..cb3f738bd3d556c85c2b9694cf5d471fc429f1c2
--- /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;
+}