DevelopmentTagger enum and string conversion

@vchobano @mfuehrin @wendelj Adds enum for the old DevelopmentTagger that is reenabled for future FT WG Run2 Tuple Production.

Note: TaggerTypeToString and TaggerTypeToType are only called in BTaggingTool.cpp in Phys in few places, therefore impact is small.

Modernization was needed because previous static map implementation behaved strangely with lb-checkout LHCb/branch_with_changes Event: Newly implemented tagger types in the string-type mapping were unavailable in Phys/FlavourTagging and only the old ones were found. At the same time, all other methods implemented in Tagger.h behaved as expected. This implementation ties the static map to the Tagger class, which seems to solve this issue.

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
@@ -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
@@ -111,6+114,6 @@
     virtual ~Tagger() {}
 
     /// Fill the ASCII output stream
     virtual 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 +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;
 
@@ -178,127 +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::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 ) {
+    s << Tagger::TaggerTypeToString( e );
+    return s;
   }
 
 } // namespace LHCb
@@ -320,82 +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},
-                                                                   {"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;
+  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; }