diff --git a/DataFormats/GsfTrackReco/src/classes_def.xml b/DataFormats/GsfTrackReco/src/classes_def.xml
index 3947c444aae3d..e6e5f304ae685 100644
--- a/DataFormats/GsfTrackReco/src/classes_def.xml
+++ b/DataFormats/GsfTrackReco/src/classes_def.xml
@@ -24,7 +24,8 @@
-
+
+
diff --git a/DataFormats/TrackReco/interface/TrackBase.h b/DataFormats/TrackReco/interface/TrackBase.h
index d93945d9deb4f..26603955bd46c 100644
--- a/DataFormats/TrackReco/interface/TrackBase.h
+++ b/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
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 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 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_;
diff --git a/DataFormats/TrackReco/interface/trackAlgoPriorityOrder.h b/DataFormats/TrackReco/interface/trackAlgoPriorityOrder.h
new file mode 100644
index 0000000000000..a88dda324c50b
--- /dev/null
+++ b/DataFormats/TrackReco/interface/trackAlgoPriorityOrder.h
@@ -0,0 +1,155 @@
+#ifndef DataFormats_TrackReco_trackAlgoPriorityOrder_h
+#define DataFormats_TrackReco_trackAlgoPriorityOrder_h
+
+#include "DataFormats/TrackReco/interface/TrackBase.h"
+
+#include
+
+/**
+ * The trackAlgoPriorityOrder maps an reco::TrackBase::TrackAlgorithm
+ * enumerator to its priority in track list merging. The mapping is
+ * needed because the order of the enumerators themselves does not, in
+ * general, convey useful information.
+ */
+namespace impl {
+
+ /**
+ * This array defines the priority order in merging for the
+ * algorithms. The order is ascending, i.e. the first algorithm has
+ * the highest priority etc. The size of the array should be
+ * reco::TrackBase:algoSize (checked below with static_assert), and
+ * each reco::TrackBase::TrackAlgorithm enumerator should be in the
+ * array exactly once (checked below in findIndex() function).
+ */
+ constexpr reco::TrackBase::TrackAlgorithm algoPriorityOrder[] ={
+ reco::TrackBase::undefAlgorithm,
+ reco::TrackBase::ctf,
+ reco::TrackBase::rs,
+ reco::TrackBase::cosmics,
+ reco::TrackBase::initialStep,
+ reco::TrackBase::detachedTripletStep,
+ reco::TrackBase::lowPtTripletStep,
+ reco::TrackBase::pixelPairStep,
+ reco::TrackBase::mixedTripletStep,
+ reco::TrackBase::pixelLessStep,
+ reco::TrackBase::tobTecStep,
+ reco::TrackBase::jetCoreRegionalStep,
+ reco::TrackBase::conversionStep,
+ reco::TrackBase::muonSeededStepInOut,
+ reco::TrackBase::muonSeededStepOutIn,
+ reco::TrackBase::outInEcalSeededConv,
+ reco::TrackBase::inOutEcalSeededConv,
+ reco::TrackBase::nuclInter,
+ reco::TrackBase::standAloneMuon,
+ reco::TrackBase::globalMuon,
+ reco::TrackBase::cosmicStandAloneMuon,
+ reco::TrackBase::cosmicGlobalMuon,
+ reco::TrackBase::iter1LargeD0,
+ reco::TrackBase::iter2LargeD0,
+ reco::TrackBase::iter3LargeD0,
+ reco::TrackBase::iter4LargeD0,
+ reco::TrackBase::iter5LargeD0,
+ reco::TrackBase::bTagGhostTracks,
+ reco::TrackBase::beamhalo,
+ reco::TrackBase::gsf,
+ reco::TrackBase::hltPixel,
+ reco::TrackBase::hltIter0,
+ reco::TrackBase::hltIter1,
+ reco::TrackBase::hltIter2,
+ reco::TrackBase::hltIter3,
+ reco::TrackBase::hltIter4,
+ reco::TrackBase::hltIterX
+ };
+
+ static_assert(reco::TrackBase::algoSize == sizeof(algoPriorityOrder)/sizeof(unsigned int), "Please update me too after adding new enumerators to reco::TrackBase::TrackAlgorithm");
+
+ /**
+ * Recursive implementation of searching the index of an algorithm in the algoPriorityOrder
+ *
+ * @param algo Algorithm whose index is searched for
+ * @param index Current index
+ *
+ * @return Index of the algorithm; if not found results compile error
+ */
+ constexpr unsigned int findIndex(const reco::TrackBase::TrackAlgorithm algo, const unsigned int index) {
+ return index < sizeof(algoPriorityOrder)/sizeof(unsigned int) ?
+ (algo == algoPriorityOrder[index] ? index : findIndex(algo, index+1)) :
+ throw "Index out of bounds, this means that some reco::TrackBase::TrackAlgorithm enumerator is missing from impl::algoPriorityOrder array.";
+ }
+
+ /**
+ * Find the order priority for a track algorithm
+ *
+ * @param algo algorithm whose index is searched for
+ *
+ * @return Index of the algorithm in impl::algoPriorityOrder array; if not found results compile error
+ *
+ * @see findIndex()
+ */
+ constexpr unsigned int priorityForAlgo(const reco::TrackBase::TrackAlgorithm algo) {
+ return findIndex(algo, 0);
+ }
+
+
+ /**
+ * Helper template to initialize std::array compile-time.
+ *
+ * Idea is that it "loops" over all reco::TrackBase::TrackAlgorithm
+ * enumerators from end to beginning. In each "iteration", the order
+ * priority is obtained from impl::algoPriorityOrder array, and the
+ * priority is added to a parameter pack. When the beginning is
+ * reached (termination condition is a partial specialization, see
+ * below), the std::array is initialized from the parameter pack.
+ * The "looping" is implemented as recursion.
+ *
+ * @tparam T value_type of the std::array
+ * @tparam N Size of the std::array
+ * @tparam I Current index
+ */
+ template
+ struct MakeArray {
+ template
+ constexpr static
+ std::array value(Args&&... args) {
+ return MakeArray::value(priorityForAlgo(static_cast(I-1)), std::forward(args)...);
+ }
+ };
+
+ /**
+ * Partial specialization for the termination condition.
+ */
+ template
+ struct MakeArray {
+ template
+ constexpr static
+ std::array value(Args&&... args) {
+ return std::array{{std::forward(args)...}};
+ }
+ };
+
+
+ /**
+ * Create compile-time an std::array mapping
+ * reco::TrackBase::TrackAlgorithm enumerators to their order
+ * priorities as defined in impl::algoPriorityOrder array.
+ *
+ * @tparam T value_type of the std::array
+ * @tparam N Size of the std::array
+ */
+ template
+ constexpr
+ std::array makeArray() {
+ return MakeArray::value();
+ }
+
+}
+
+/**
+ * Array mapping reco::TrackBase::TrackAlgorithm enumerators to their
+ * order priorities in track list merging.
+ */
+constexpr std::array trackAlgoPriorityOrder = impl::makeArray();
+
+
+#endif // DataFormats_TrackReco_trackAlgoPriorityOrder_h
+
diff --git a/DataFormats/TrackReco/src/TrackBase.cc b/DataFormats/TrackReco/src/TrackBase.cc
index 2e4d3b5129f59..8d251ce439705 100644
--- a/DataFormats/TrackReco/src/TrackBase.cc
+++ b/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) {
diff --git a/DataFormats/TrackReco/src/classes.h b/DataFormats/TrackReco/src/classes.h
index f6d904482f403..6353dfa116035 100644
--- a/DataFormats/TrackReco/src/classes.h
+++ b/DataFormats/TrackReco/src/classes.h
@@ -34,6 +34,7 @@
namespace DataFormats_TrackReco {
struct dictionary {
+ std::bitset ba;
reco::TrackExtraCollection v3;
edm::Wrapper c3;
edm::Ref r3;
diff --git a/DataFormats/TrackReco/src/classes_def.xml b/DataFormats/TrackReco/src/classes_def.xml
index 86e1084d90c4b..06b62de9d84d0 100644
--- a/DataFormats/TrackReco/src/classes_def.xml
+++ b/DataFormats/TrackReco/src/classes_def.xml
@@ -1,4 +1,5 @@
+
@@ -6,7 +7,8 @@
-
+
+
@@ -351,7 +353,8 @@
-
+
+
diff --git a/DataFormats/TrackReco/test/testTrack.cc b/DataFormats/TrackReco/test/testTrack.cc
index 9125403955b8e..82045a07a3059 100644
--- a/DataFormats/TrackReco/test/testTrack.cc
+++ b/DataFormats/TrackReco/test/testTrack.cc
@@ -68,15 +68,46 @@ void testTrack::checkAll() {
CPPUNIT_ASSERT_DOUBLES_EQUAL(t.covariance(3, 4), cov(3, 4), 1e-6);
CPPUNIT_ASSERT_DOUBLES_EQUAL(t.covariance(4, 4), cov(4, 4), 1e-6);
+ auto qual = reco::TrackBase::qualityByName("highPurity");
+ CPPUNIT_ASSERT(qual==reco::TrackBase::highPurity);
t.setQuality(reco::TrackBase::loose);
CPPUNIT_ASSERT(t.quality(reco::TrackBase::loose) == true);
- t.setQuality(reco::TrackBase::loose, false);
+ CPPUNIT_ASSERT(t.quality(reco::TrackBase::highPurity) == false);
+ CPPUNIT_ASSERT(t.quality(reco::TrackBase::confirmed) == false);
+ CPPUNIT_ASSERT(t.quality(reco::TrackBase::goodIterative) == false);
+ t.setQuality(reco::TrackBase::highPurity);
+ CPPUNIT_ASSERT(t.quality(reco::TrackBase::loose) == true);
+ CPPUNIT_ASSERT(t.quality(reco::TrackBase::highPurity) == true);
+ CPPUNIT_ASSERT(t.quality(reco::TrackBase::confirmed) == false);
+ CPPUNIT_ASSERT(t.quality(reco::TrackBase::goodIterative) == true);
+ t.setQuality(reco::TrackBase::confirmed);
+ CPPUNIT_ASSERT(t.quality(reco::TrackBase::loose) == true);
+ CPPUNIT_ASSERT(t.quality(reco::TrackBase::highPurity) == true);
+ CPPUNIT_ASSERT(t.quality(reco::TrackBase::confirmed) == true);
+ CPPUNIT_ASSERT(t.quality(reco::TrackBase::goodIterative) == true);
+ t.setQuality(reco::TrackBase::undefQuality);
CPPUNIT_ASSERT(t.quality(reco::TrackBase::loose) == false);
+ CPPUNIT_ASSERT(t.quality(reco::TrackBase::highPurity) == false);
+ CPPUNIT_ASSERT(t.quality(reco::TrackBase::confirmed) == false);
+ CPPUNIT_ASSERT(t.quality(reco::TrackBase::goodIterative) == false);
+ t.setQuality(reco::TrackBase::loose);
+ t.setQuality(reco::TrackBase::confirmed);
+ CPPUNIT_ASSERT(t.quality(reco::TrackBase::loose) == true);
+ CPPUNIT_ASSERT(t.quality(reco::TrackBase::highPurity) == false);
+ CPPUNIT_ASSERT(t.quality(reco::TrackBase::confirmed) == true);
+ CPPUNIT_ASSERT(t.quality(reco::TrackBase::goodIterative) == false);
+
+ reco::TrackBase::AlgoMask am;
t.setAlgorithm(reco::TrackBase::ctf);
+ am.set(reco::TrackBase::ctf);
CPPUNIT_ASSERT(t.algo() == reco::TrackBase::ctf);
-
- t.setAlgorithm(reco::TrackBase::ctf, false);
- CPPUNIT_ASSERT(t.algo() == reco::TrackBase::undefAlgorithm);
+ CPPUNIT_ASSERT(t.algoMask()==am);
+ am.set(reco::TrackBase::rs);
+ t.setOriginalAlgorithm(reco::TrackBase::rs);
+ CPPUNIT_ASSERT(t.algo() == reco::TrackBase::ctf);
+ CPPUNIT_ASSERT(t.originalAlgo() == reco::TrackBase::rs);
+ CPPUNIT_ASSERT(t.algoMask()==am);
+
}
diff --git a/RecoTracker/FinalTrackSelectors/plugins/TrackListMerger.cc b/RecoTracker/FinalTrackSelectors/plugins/TrackListMerger.cc
index e0f66e62c0fc6..dff9b3db1c7b6 100644
--- a/RecoTracker/FinalTrackSelectors/plugins/TrackListMerger.cc
+++ b/RecoTracker/FinalTrackSelectors/plugins/TrackListMerger.cc
@@ -349,8 +349,10 @@ TrackListMerger::~TrackListMerger() { }
int trackCollNum[rSize];
int trackQuals[rSize];
float trackMVAs[rSize];
+ reco::TrackBase::TrackAlgorithm oriAlgo[rSize];
+ std::vector algoMask(rSize);
for (unsigned int j=0; jqualityMask();
-
+ oriAlgo[i]=track->originalAlgo();
+ algoMask[i]=track->algoMask();
+
reco::TrackRef trkRef=reco::TrackRef(trackHandles[j],iC);
if ( copyMVA_ )
if( (*trackMVAStore).contains(trkRef.id()) ) trackMVAs[i] = (*trackMVAStore)[trkRef];
@@ -415,11 +419,7 @@ TrackListMerger::~TrackListMerger() { }
//cache the id and rechits of valid hits
typedef std::pair IHit;
- #ifdef __clang__
- std::vector> rh1(ngood); // an array of vectors!
- #else
- std::vector rh1[ngood]; // an array of vectors!
- #endif
+ std::vector> rh1(ngood); // "not an array" of vectors!
//const TrackingRecHit* fh1[ngood]; // first hit...
uint8_t algo[ngood];
float score[ngood];
@@ -545,40 +545,37 @@ TrackListMerger::~TrackListMerger() { }
bool dupfound = (collNum != collNum2) ? (noverlap-firstoverlap) > (std::min(nhit1,nhit2)-firstoverlap)*shareFrac_ :
(noverlap-firstoverlap) > (std::min(nhit1,nhit2)-firstoverlap)*indivShareFrac_[collNum];
+ auto seti = [&](unsigned int ii, unsigned int jj) {
+ selected[jj]=0;
+ selected[ii]=10+newQualityMask; // add 10 to avoid the case where mask = 1
+ trkUpdated[ii]=true;
+ if (trackAlgoPriorityOrder[oriAlgo[jj]] < trackAlgoPriorityOrder[oriAlgo[ii]]) oriAlgo[ii] = oriAlgo[jj];
+ algoMask[ii] |= algoMask[jj];
+ algoMask[jj] = algoMask[ii]; // in case we keep discarded
+ };
+
if ( dupfound ) {
float score2 = score[k2];
constexpr float almostSame = 0.01f; // difference rather than ratio due to possible negative values for score
if ( score1 - score2 > almostSame ) {
- selected[j]=0;
- selected[i]=10+newQualityMask; // add 10 to avoid the case where mask = 1
- trkUpdated[i]=true;
+ seti(i,j);
} else if ( score2 - score1 > almostSame ) {
- selected[i]=0;
- selected[j]=10+newQualityMask; // add 10 to avoid the case where mask = 1
- trkUpdated[j]=true;
+ seti(j,i);
}else{
// If tracks from both iterations are virtually identical, choose the one with the best quality or with lower algo
if ((trackQuals[j] & (1< trackRefs(rSize);
std::vector> seedsRefs(rSize);
- #else
- reco::TrackRef trackRefs[rSize];
- edm::RefToBase seedsRefs[rSize];
- #endif
unsigned int nToWrite=0;
for ( unsigned int i=0; iback().setQualityMask(trackQuals[i]);
+ outputTrks->back().setOriginalAlgorithm(oriAlgo[i]);
+ outputTrks->back().setAlgoMask(algoMask[i]);
// if ( beVerb ) std::cout << "selected " << outputTrks->back().pt() << " " << outputTrks->back().qualityMask() << " " << selected[i] << std::endl;
diff --git a/RecoTracker/FinalTrackSelectors/plugins/trackAlgoPriorityOrder.h b/RecoTracker/FinalTrackSelectors/plugins/trackAlgoPriorityOrder.h
index ff6184fea61d1..7174077f831ec 100644
--- a/RecoTracker/FinalTrackSelectors/plugins/trackAlgoPriorityOrder.h
+++ b/RecoTracker/FinalTrackSelectors/plugins/trackAlgoPriorityOrder.h
@@ -1,154 +1 @@
-#ifndef RecoTracker_FinalTrackSelectors_trackAlgoPriorityOrder_h
-#define RecoTracker_FinalTrackSelectors_trackAlgoPriorityOrder_h
-
-#include "DataFormats/TrackReco/interface/TrackBase.h"
-
-#include
-
-/**
- * The trackAlgoPriorityOrder maps an reco::TrackBase::TrackAlgorithm
- * enumerator to its priority in track list merging. The mapping is
- * needed because the order of the enumerators themselves does not, in
- * general, convey useful information.
- */
-namespace impl {
-
- /**
- * This array defines the priority order in merging for the
- * algorithms. The order is ascending, i.e. the first algorithm has
- * the highest priority etc. The size of the array should be
- * reco::TrackBase:algoSize (checked below with static_assert), and
- * each reco::TrackBase::TrackAlgorithm enumerator should be in the
- * array exactly once (checked below in findIndex() function).
- */
- constexpr reco::TrackBase::TrackAlgorithm algoPriorityOrder[] ={
- reco::TrackBase::undefAlgorithm,
- reco::TrackBase::ctf,
- reco::TrackBase::rs,
- reco::TrackBase::cosmics,
- reco::TrackBase::initialStep,
- reco::TrackBase::lowPtTripletStep,
- reco::TrackBase::pixelPairStep,
- reco::TrackBase::detachedTripletStep,
- reco::TrackBase::mixedTripletStep,
- reco::TrackBase::pixelLessStep,
- reco::TrackBase::tobTecStep,
- reco::TrackBase::jetCoreRegionalStep,
- reco::TrackBase::conversionStep,
- reco::TrackBase::muonSeededStepInOut,
- reco::TrackBase::muonSeededStepOutIn,
- reco::TrackBase::outInEcalSeededConv,
- reco::TrackBase::inOutEcalSeededConv,
- reco::TrackBase::nuclInter,
- reco::TrackBase::standAloneMuon,
- reco::TrackBase::globalMuon,
- reco::TrackBase::cosmicStandAloneMuon,
- reco::TrackBase::cosmicGlobalMuon,
- reco::TrackBase::iter1LargeD0,
- reco::TrackBase::iter2LargeD0,
- reco::TrackBase::iter3LargeD0,
- reco::TrackBase::iter4LargeD0,
- reco::TrackBase::iter5LargeD0,
- reco::TrackBase::bTagGhostTracks,
- reco::TrackBase::beamhalo,
- reco::TrackBase::gsf,
- reco::TrackBase::hltPixel,
- reco::TrackBase::hltIter0,
- reco::TrackBase::hltIter1,
- reco::TrackBase::hltIter2,
- reco::TrackBase::hltIter3,
- reco::TrackBase::hltIter4,
- reco::TrackBase::hltIterX
- };
-
- static_assert(reco::TrackBase::algoSize == sizeof(algoPriorityOrder)/sizeof(unsigned int), "Please update me too after adding new enumerators to reco::TrackBase::TrackAlgorithm");
-
- /**
- * Recursive implementation of searching the index of an algorithm in the algoPriorityOrder
- *
- * @param algo Algorithm whose index is searched for
- * @param index Current index
- *
- * @return Index of the algorithm; if not found results compile error
- */
- constexpr unsigned int findIndex(const reco::TrackBase::TrackAlgorithm algo, const unsigned int index) {
- return index < sizeof(algoPriorityOrder)/sizeof(unsigned int) ?
- (algo == algoPriorityOrder[index] ? index : findIndex(algo, index+1)) :
- throw "Index out of bounds, this means that some reco::TrackBase::TrackAlgorithm enumerator is missing from impl::algoPriorityOrder array.";
- }
-
- /**
- * Find the order priority for a track algorithm
- *
- * @param algo algorithm whose index is searched for
- *
- * @return Index of the algorithm in impl::algoPriorityOrder array; if not found results compile error
- *
- * @see findIndex()
- */
- constexpr unsigned int priorityForAlgo(const reco::TrackBase::TrackAlgorithm algo) {
- return findIndex(algo, 0);
- }
-
-
- /**
- * Helper template to initialize std::array compile-time.
- *
- * Idea is that it "loops" over all reco::TrackBase::TrackAlgorithm
- * enumerators from end to beginning. In each "iteration", the order
- * priority is obtained from impl::algoPriorityOrder array, and the
- * priority is added to a parameter pack. When the beginning is
- * reached (termination condition is a partial specialization, see
- * below), the std::array is initialized from the parameter pack.
- * The "looping" is implemented as recursion.
- *
- * @tparam T value_type of the std::array
- * @tparam N Size of the std::array
- * @tparam I Current index
- */
- template
- struct MakeArray {
- template
- constexpr static
- std::array value(Args&&... args) {
- return MakeArray::value(priorityForAlgo(static_cast(I-1)), std::forward(args)...);
- }
- };
-
- /**
- * Partial specialization for the termination condition.
- */
- template
- struct MakeArray {
- template
- constexpr static
- std::array value(Args&&... args) {
- return std::array{{std::forward(args)...}};
- }
- };
-
-
- /**
- * Create compile-time an std::array mapping
- * reco::TrackBase::TrackAlgorithm enumerators to their order
- * priorities as defined in impl::algoPriorityOrder array.
- *
- * @tparam T value_type of the std::array
- * @tparam N Size of the std::array
- */
- template
- constexpr
- std::array makeArray() {
- return MakeArray::value();
- }
-
-}
-
-/**
- * Array mapping reco::TrackBase::TrackAlgorithm enumerators to their
- * order priorities in track list merging.
- */
-constexpr std::array trackAlgoPriorityOrder = impl::makeArray();
-
-
-#endif
+#include "DataFormats/TrackReco/interface/trackAlgoPriorityOrder.h"
diff --git a/RecoTracker/FinalTrackSelectors/python/preDuplicateMergingGeneralTracks_cfi.py b/RecoTracker/FinalTrackSelectors/python/preDuplicateMergingGeneralTracks_cfi.py
index d4c1ea4a7e4e9..8291c41e54ec6 100644
--- a/RecoTracker/FinalTrackSelectors/python/preDuplicateMergingGeneralTracks_cfi.py
+++ b/RecoTracker/FinalTrackSelectors/python/preDuplicateMergingGeneralTracks_cfi.py
@@ -18,7 +18,7 @@
cms.InputTag("muonSeededTracksInOutSelector","MVAVals"),
cms.InputTag("muonSeededTracksOutInSelector","MVAVals"),
),
- setsToMerge = cms.VPSet(cms.PSet(pQual = cms.bool(False), tLists = cms.vint32(0, 1,2))),
+ setsToMerge = cms.VPSet(cms.PSet(pQual = cms.bool(True), tLists = cms.vint32(0, 1,2))),
FoundHitBonus = 100.0,
LostHitPenalty = 1.0,
)
diff --git a/RecoTracker/FinalTrackSelectors/test/BuildFile.xml b/RecoTracker/FinalTrackSelectors/test/BuildFile.xml
new file mode 100644
index 0000000000000..a88d51f3e32d4
--- /dev/null
+++ b/RecoTracker/FinalTrackSelectors/test/BuildFile.xml
@@ -0,0 +1,2 @@
+
+
diff --git a/RecoTracker/FinalTrackSelectors/test/trackAlgoPriorityOrder_t.cpp b/RecoTracker/FinalTrackSelectors/test/trackAlgoPriorityOrder_t.cpp
index e9b730f89b6c2..ac0618c3c89ff 100644
--- a/RecoTracker/FinalTrackSelectors/test/trackAlgoPriorityOrder_t.cpp
+++ b/RecoTracker/FinalTrackSelectors/test/trackAlgoPriorityOrder_t.cpp
@@ -7,7 +7,7 @@ int main(void) {
reco::TrackBase::TrackAlgorithm algo = static_cast(ialgo);
const unsigned int priority = trackAlgoPriorityOrder[algo];
- //std::cout << "Algorithm " << reco::TrackBase::algoName(algo) << " has priority " << priority << std::endl;
+ std::cout << "Algorithm " << reco::TrackBase::algoName(algo) << " has priority " << priority << std::endl;
if(impl::algoPriorityOrder[priority] != algo) {
std::cout << "Priority for algo " << reco::TrackBase::algoName(algo) << " is inconsistent: algo " << algo << " has priority " << priority << ", which maps back to algo " << impl::algoPriorityOrder[priority] << std::endl;
diff --git a/SimTracker/TrackAssociation/plugins/TrackMCQuality.cc b/SimTracker/TrackAssociation/plugins/TrackMCQuality.cc
index 079fbd8099493..1f2c6a468673c 100644
--- a/SimTracker/TrackAssociation/plugins/TrackMCQuality.cc
+++ b/SimTracker/TrackAssociation/plugins/TrackMCQuality.cc
@@ -39,7 +39,7 @@
// class decleration
//
-class TrackMCQuality : public edm::global::EDProducer<> {
+class TrackMCQuality final : public edm::global::EDProducer<> {
public:
explicit TrackMCQuality(const edm::ParameterSet&);
~TrackMCQuality();
@@ -49,9 +49,12 @@ class TrackMCQuality : public edm::global::EDProducer<> {
// ----------member data ---------------------------
- edm::EDGetTokenT label_tr;
+ edm::EDGetTokenT label_assoc;
edm::EDGetTokenT label_tp;
- edm::EDGetTokenT > label_associator;
+ edm::EDGetTokenT > label_tr;
+
+ using Product=std::vector;
+
};
//
@@ -67,11 +70,11 @@ class TrackMCQuality : public edm::global::EDProducer<> {
// constructors and destructor
//
TrackMCQuality::TrackMCQuality(const edm::ParameterSet& pset):
- label_tr(consumes(pset.getParameter< edm::InputTag >("label_tr"))),
- label_tp(consumes(pset.getParameter< edm::InputTag >("label_tp"))),
- label_associator(consumes >(pset.getParameter< edm::InputTag >("associator")))
+ label_assoc(consumes(pset.getParameter< edm::InputTag >("associator"))),
+ label_tp(consumes(pset.getParameter< edm::InputTag >("trackingParticles"))),
+ label_tr(consumes >(pset.getParameter< edm::InputTag >("tracks")))
{
- produces();
+ produces();
}
@@ -91,7 +94,7 @@ TrackMCQuality::produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup
using namespace edm;
Handle associator;
- iEvent.getByToken(label_associator,associator);
+ iEvent.getByToken(label_assoc,associator);
Handle TPCollection ;
iEvent.getByToken(label_tp, TPCollection);
@@ -103,29 +106,29 @@ TrackMCQuality::produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup
TPCollection);
//then loop the track collection
- std::auto_ptr outTracks(new reco::TrackCollection(trackCollection->size()));
+ std::unique_ptr product(new Product(trackCollection->size(),0));
+
for (unsigned int iT=0;iT!=trackCollection->size();++iT){
+ auto & prod = (*product)[iT];
+
edm::RefToBase track(trackCollection, iT);
- bool matched=false;
+
//find it in the map
- if (recSimColl.find(track)!=recSimColl.end()){
- // you can get the data if you want
- std::vector > tp= recSimColl[track];
- matched=true;
- }
- else{
- matched=false;
- }
-
- //copy the track into the new container
- (*outTracks)[iT] = reco::Track(*track);
- if (matched){
- (*outTracks)[iT].setQuality(reco::TrackBase::qualitySize); //is not assigned to any quality. use it as a fake/matched flag
- }
+ if (recSimColl.find(track)==recSimColl.end()) continue;
+
+ auto const & tp = recSimColl[track];
+
+ if (tp.empty()) continue; // can it be?
+ // nSimHits = tp[0].first->numberOfTrackerHits();
+ prod = tp[0].second;
+ // if (tp[0].first->charge() != track->charge()) isChargeMatched = false;
+ if ( (tp[0].first->eventId().event() != 0) || (tp[0].first->eventId().bunchCrossing() != 0) ) prod=-prod;
+
+
}
- iEvent.put(outTracks);
+ iEvent.put(std::move(product));
}
//define this as a plug-in
diff --git a/SimTracker/TrackAssociation/python/TrackMCQuality_cfi.py b/SimTracker/TrackAssociation/python/TrackMCQuality_cfi.py
index 116fe5159f73f..bc53a7e544b08 100644
--- a/SimTracker/TrackAssociation/python/TrackMCQuality_cfi.py
+++ b/SimTracker/TrackAssociation/python/TrackMCQuality_cfi.py
@@ -1,8 +1,8 @@
import FWCore.ParameterSet.Config as cms
-TrackMCQuality = cms.EDProducer("TrackMCQuality",
- label_tr = cms.InputTag('generalTracks'),
- label_tp = cms.InputTag('mix','MergedTrackTruth'),
- associator = cms.string('TrackAssociatorByHits')
+trackMCQuality = cms.EDProducer("TrackMCQuality",
+ tracks = cms.InputTag('generalTracks'),
+ trackingParticles = cms.InputTag('mix','MergedTrackTruth'),
+ associator = cms.InputTag('quickTrackAssociatorByHits')
)