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,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