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') )