Add mask to keep track of all algos where a track is reconstructed (and also move detachedTripletStep right after initialStep in priority order where it should be) Class TkMCQuality is also modified to produce a vector of "qualities" instead of writing a new track collection with a fake quality bit set.

DataFormats/GsfTrackReco/src/classes_def.xml

@@ -24,7 +24,8 @@
   <class name="edm::Ref<std::vector<reco::GsfTrackExtra>,reco::GsfTrackExtra,edm::refhelper::FindUsingAdvance<std::vector<reco::GsfTrackExtra>,reco::GsfTrackExtra> >"/>
   <class name="edm::RefVector<std::vector<reco::GsfTrackExtra>,reco::GsfTrackExtra,edm::refhelper::FindUsingAdvance<std::vector<reco::GsfTrackExtra>,reco::GsfTrackExtra> >"/>
 
-  <class name="reco::GsfTrack" ClassVersion="14">
+  <class name="reco::GsfTrack" ClassVersion="15">
+   <version ClassVersion="15" checksum="2494468278"/>
    <version ClassVersion="14" checksum="3085391575"/>
    <version ClassVersion="13" checksum="1287963871"/>
    <version ClassVersion="12" checksum="1456169080"/>

DataFormats/TrackReco/interface/TrackBase.h

@@ -48,13 +48,14 @@
  *
  */
 
+#include "DataFormats/TrackReco/interface/HitPattern.h"
+#include "DataFormats/BeamSpot/interface/BeamSpot.h"
 #include "DataFormats/Math/interface/Vector.h"
 #include "DataFormats/Math/interface/Error.h"
 #include "DataFormats/Math/interface/Vector3D.h"
 #include "DataFormats/Math/interface/Point3D.h"
 #include "DataFormats/Math/interface/Error.h"
-#include "DataFormats/TrackReco/interface/HitPattern.h"
-#include "DataFormats/BeamSpot/interface/BeamSpot.h"
+#include <bitset>
 
 namespace reco
 {
@@ -93,6 +94,7 @@ class TrackBase
     /// index type
     typedef unsigned int index;
 
+
     /// track algorithm
     enum TrackAlgorithm {
         undefAlgorithm = 0, ctf = 1, rs = 2, cosmics = 3,
@@ -127,6 +129,10 @@ class TrackBase
         algoSize = 37
     };
 
+    /// algo mask
+    typedef std::bitset<algoSize> AlgoMask;
+
+
     static const std::string algoNames[];
 
     /// track quality
@@ -135,11 +141,12 @@ class TrackBase
         loose = 0,
         tight = 1,
         highPurity = 2,
-        confirmed = 3,
-        goodIterative = 4,
+        confirmed = 3,  // means found by more than one iteration
+        goodIterative = 4,  // meaningless
         looseSetWithPV = 5,
         highPuritySetWithPV = 6,
-        qualitySize = 7
+        discarded = 7, // because a better track found. kept in the collection for reference....
+        qualitySize = 8
     };
 
     static const std::string qualityNames[];
@@ -319,9 +326,20 @@ class TrackBase
     void resetHitPattern();
 
     ///Track algorithm
-    void setAlgorithm(const TrackAlgorithm a, bool set = true);
+    void setAlgorithm(const TrackAlgorithm a);
+
+    void setOriginalAlgorithm(const TrackAlgorithm a);
+
+    void setAlgoMask(AlgoMask a) { algoMask_ = a;}
+
+    AlgoMask algoMask() const { return algoMask_;}
+    unsigned long long algoMaskUL() const { return algoMask().to_ullong();}
+    bool isAlgoInMask(TrackAlgorithm a) const {return algoMask()[a];}
+
 
     TrackAlgorithm algo() const ;
+    TrackAlgorithm originalAlgo() const ;
+
 
     std::string algoName() const;
 
@@ -332,7 +350,7 @@ class TrackBase
     ///Track quality
     bool quality(const TrackQuality) const;
 
-    void setQuality(const TrackQuality, bool set = true);
+    void setQuality(const TrackQuality);
 
     static std::string qualityName(TrackQuality);
 
@@ -364,6 +382,9 @@ class TrackBase
     /// momentum vector at innermost point
     Vector momentum_;
 
+    /// algo mask, bit set for the algo where it was reconstructed + each algo a track was found overlapping by the listmerger
+    std::bitset<algoSize> algoMask_;
+
     /// number of degrees of freedom
     float ndof_;
 
@@ -373,6 +394,10 @@ class TrackBase
     /// track algorithm
     uint8_t algorithm_;
 
+    /// track algorithm
+    uint8_t originalAlgorithm_;
+
+
     /// track quality
     uint8_t quality_;
 
@@ -422,158 +447,36 @@ inline TrackBase::index TrackBase::covIndex(index i, index j)
 
 inline TrackBase::TrackAlgorithm TrackBase::algo() const
 {
-    return (TrackAlgorithm) algorithm_;
-}
-
-inline std::string TrackBase::algoName() const
-{
-    // I'd like to do:
-    // return TrackBase::algoName(algorithm_);
-    // but I cannot define a const static function. Why???
-    switch (algorithm_) {
-    case undefAlgorithm:
-      return "undefAlgorithm";
-      break;
-    case ctf:
-      return "ctf";
-      break;
-    case rs:
-      return "rs";
-      break;
-    case cosmics:
-      return "cosmics";
-      break;
-    case beamhalo:
-      return "beamhalo";
-      break;
-    case initialStep:
-      return "initialStep";
-      break;
-    case lowPtTripletStep:
-      return "lowPtTripletStep";
-      break;
-    case pixelPairStep:
-      return "pixelPairStep";
-      break;
-    case detachedTripletStep:
-      return "detachedTripletStep";
-      break;
-    case mixedTripletStep:
-      return "mixedTripletStep";
-      break;
-    case pixelLessStep:
-      return "pixelLessStep";
-      break;
-    case tobTecStep:
-      return "tobTecStep";
-      break;
-    case jetCoreRegionalStep:
-      return "jetCoreRegionalStep";
-      break;
-    case conversionStep:
-      return "conversionStep";
-      break;
-    case muonSeededStepInOut:
-      return "muonSeededStepInOut";
-      break;
-    case muonSeededStepOutIn:
-      return "muonSeededStepOutIn";
-      break;
-    case outInEcalSeededConv:
-      return "outInEcalSeededConv";
-      break;
-    case inOutEcalSeededConv:
-      return "inOutEcalSeededConv";
-      break;
-    case nuclInter:
-      return "nuclInter";
-      break;
-    case standAloneMuon:
-      return "standAloneMuon";
-      break;
-    case globalMuon:
-      return "globalMuon";
-      break;
-    case cosmicStandAloneMuon:
-      return "cosmicStandAloneMuon";
-      break;
-    case cosmicGlobalMuon:
-      return "cosmicGlobalMuon";
-      break;
-    case iter1LargeD0:
-      return "iter1LargeD0";
-      break;
-    case iter2LargeD0:
-      return "iter2LargeD0";
-      break;
-    case iter3LargeD0:
-      return "iter3LargeD0";
-      break;
-    case iter4LargeD0:
-      return "iter4LargeD0";
-      break;
-    case iter5LargeD0:
-      return "iter5LargeD0";
-      break;
-    case bTagGhostTracks:
-      return "bTagGhostTracks";
-      break;
-    case gsf:
-      return "gsf";
-      break;
-    case hltPixel :
-      return "hltPixel";
-      break;
-    case hltIter0 :
-      return "hltIter0";
-      break;
-    case hltIter1 :
-      return "hltIter1";
-      break;
-    case hltIter2 :
-      return "hltIter2";
-      break;
-    case hltIter3 :
-      return "hltIter3";
-      break;
-    case hltIter4 :
-      return "hltIter4";
-      break;
-    case hltIterX :
-      return "hltIterX";
-      break;
-    default:
-      return "undefAlgorithm";
-      break;
-    }
+    return (TrackAlgorithm) (algorithm_);
+}
+inline TrackBase::TrackAlgorithm TrackBase::originalAlgo() const
+{
+    return (TrackAlgorithm) (originalAlgorithm_);
 }
 
+
+
+inline std::string TrackBase::algoName() const { return TrackBase::algoName(algo()); }
+
 inline bool TrackBase::quality(const TrackBase::TrackQuality q) const
 {
     switch (q) {
     case undefQuality:
-        return (quality_ == 0);
+        return quality_ == 0;
     case goodIterative:
-        return (((quality_ & (1 << TrackBase::confirmed))  >> TrackBase::confirmed) ||
-                ((quality_ & (1 << TrackBase::highPurity)) >> TrackBase::highPurity));
+        return (quality_ & (1 << TrackBase::highPurity)) >> TrackBase::highPurity;
     default:
         return (quality_ & (1 << q)) >> q;
     }
     return false;
 }
 
-inline void TrackBase::setQuality(const TrackBase::TrackQuality q, bool set)
+inline void TrackBase::setQuality(const TrackBase::TrackQuality q)
 {
     if (q == undefQuality) {
         quality_ = 0;
     } else {
-        //regular OR if setting value to true
-        if (set) {
-            quality_ |= (1 << q);
-        } else {
-            // doing "half-XOR" if unsetting value
-            quality_ &= (~(1 << q));
-        }
+        quality_ |= (1 << q);
     }
 }
 
@@ -892,15 +795,21 @@ inline double TrackBase::validFraction() const
 }
 
 //Track algorithm
-inline void TrackBase::setAlgorithm(const TrackBase::TrackAlgorithm a, bool set)
+inline void TrackBase::setAlgorithm(const TrackBase::TrackAlgorithm a)
 {
-    if (set) {
-        algorithm_ = a;
-    } else {
-        algorithm_ = TrackBase::undefAlgorithm;
-    }
+    algorithm_  = a;
+    algoMask_.reset();
+    setOriginalAlgorithm(a);
 }
 
+inline void TrackBase::setOriginalAlgorithm(const TrackBase::TrackAlgorithm a)
+{
+   originalAlgorithm_  = a;
+   algoMask_.set(a);
+}
+
+
+
 inline int TrackBase::qualityMask() const
 {
     return quality_;

DataFormats/TrackReco/src/TrackBase.cc

@@ -53,7 +53,8 @@ std::string const TrackBase::qualityNames[] = {
     "confirmed",
     "goodIterative",
     "looseSetWithPV",
-    "highPuritySetWithPV"
+    "highPuritySetWithPV",
+    "discarded"
 };
 
 TrackBase::TrackBase() :
@@ -63,9 +64,11 @@ TrackBase::TrackBase() :
     ndof_(0),
     charge_(0),
     algorithm_(undefAlgorithm),
+    originalAlgorithm_(undefAlgorithm),
     quality_(0),
     nLoops_(0)
 {
+    algoMask_.set(algorithm_);
     index idx = 0;
     for (index i = 0; i < dimension; ++i) {
         for (index j = 0; j <= i; ++j) {
@@ -83,9 +86,12 @@ TrackBase::TrackBase(double chi2, double ndof, const Point &vertex, const Vector
     ndof_(ndof),
     charge_(charge),
     algorithm_(algorithm),
+    originalAlgorithm_(algorithm),
     quality_(0),
     nLoops_(nloops)
 {
+    algoMask_.set(algorithm_);
+
     index idx = 0;
     for (index i = 0; i < dimension; ++i) {
         for (index j = 0; j <= i; ++j) {

DataFormats/TrackReco/src/classes.h

@@ -34,6 +34,7 @@
 
 namespace DataFormats_TrackReco {
   struct dictionary {
+    std::bitset<reco::TrackBase::algoSize> ba;
     reco::TrackExtraCollection v3;
     edm::Wrapper<reco::TrackExtraCollection> c3;
     edm::Ref<reco::TrackExtraCollection> r3;

DataFormats/TrackReco/src/classes_def.xml

@@ -1,12 +1,14 @@
 <lcgdict>
+  <class name="std::bitset<reco::TrackBase::algoSize>"/>
   <class name="reco::HitPattern" ClassVersion="12">
       <version ClassVersion="12" checksum="3922863495"/>
       <version ClassVersion="11" checksum="1621684703"/>
   </class>
   <class name="reco::TrackResiduals" ClassVersion="10">
    <version ClassVersion="10" checksum="2022291691"/>
   </class>
-  <class name="reco::TrackBase" ClassVersion="14">
+  <class name="reco::TrackBase" ClassVersion="15">
+   <version ClassVersion="15" checksum="1802760569"/>
    <version ClassVersion="14" checksum="3929365050"/>
    <version ClassVersion="13" checksum="1244921154"/>
    <version ClassVersion="12" checksum="2704717983"/>
@@ -351,7 +353,8 @@
   <class name="edm::Ref<std::vector<reco::TrackExtra>,reco::TrackExtra,edm::refhelper::FindUsingAdvance<std::vector<reco::TrackExtra>,reco::TrackExtra> >"/>
   <class name="edm::RefVector<std::vector<reco::TrackExtra>,reco::TrackExtra,edm::refhelper::FindUsingAdvance<std::vector<reco::TrackExtra>,reco::TrackExtra> >"/>
 
-  <class name="reco::Track" ClassVersion="14">
+  <class name="reco::Track" ClassVersion="15">
+   <version ClassVersion="15" checksum="3694119510"/>
    <version ClassVersion="14" checksum="4228121071"/>
    <version ClassVersion="13" checksum="36410295"/>
    <version ClassVersion="12" checksum="1190637787"/>