diff --git a/CommonTools/Utils/interface/associationMapFilterValues.h b/CommonTools/Utils/interface/associationMapFilterValues.h new file mode 100644 index 0000000000000..ea68f2e81eda4 --- /dev/null +++ b/CommonTools/Utils/interface/associationMapFilterValues.h @@ -0,0 +1,143 @@ +#ifndef CommonTools_Utils_associationMapFilterValues_h +#define CommonTools_Utils_associationMapFilterValues_h + +#include "DataFormats/Common/interface/Ref.h" +#include "DataFormats/Common/interface/RefVector.h" +#include "DataFormats/Common/interface/View.h" +#include "DataFormats/Common/interface/AssociationMapHelpers.h" + +#include + +namespace associationMapFilterValuesHelpers { + // Common implementation + template + void findInsert(T_AssociationMap& ret, const T_Key& key, + const T_ValueIndex& valueIndex, const T_Value& value, + const T_ValueIndices& value_indices) { + if(value_indices.find(valueIndex) != value_indices.end()) { + ret.insert(key, value); + } + } + + // By default no implementation, as it turns out to be very specific for the types + template + struct IfFound; + + // Specialize for Ref and RefToBase, implementation is the same + template + struct IfFound> { + template + static void insert(T_AssociationMap& ret, const T_KeyValue& keyValue, const T_ValueIndices& value_indices) { + findInsert(ret, keyValue.key, keyValue.val.key(), keyValue.val, value_indices); + } + }; + + template + struct IfFound> { + template + static void insert(T_AssociationMap& ret, const T_KeyValue& keyValue, const T_ValueIndices& value_indices) { + findInsert(ret, keyValue.key, keyValue.val.key(), keyValue.val, value_indices); + } + }; + + // Specialize for RefVector + template + struct IfFound> { + template + static void insert(T_AssociationMap& ret, const T_KeyValue& keyValue, const T_ValueIndices& value_indices) { + for(const auto& value: keyValue.val) { + findInsert(ret, keyValue.key, value.key(), value, value_indices); + } + } + }; + + // Specialize for vector> for OneToManyWithQuality + template + struct IfFound, Q> > > { + template + static void insert(T_AssociationMap& ret, const T_KeyValue& keyValue, const T_ValueIndices& value_indices) { + for(const auto& value: keyValue.val) { + findInsert(ret, keyValue.key, value.first.key(), value, value_indices); + } + } + }; + + // Specialize for vector> for OneToManyWithQuality + template + struct IfFound, Q> > > { + template + static void insert(T_AssociationMap& ret, const T_KeyValue& keyValue, const T_ValueIndices& value_indices) { + for(const auto& value: keyValue.val) { + findInsert(ret, keyValue.key, value.first.key(), value, value_indices); + } + } + }; + + // Default implementation for RefVector or vector + template + struct FillIndices { + template + static + void fill(T_Set& set, const T_RefVector& valueRefs, const T_RefProd& refProd) { + for(const auto& ref: valueRefs) { + edm::helpers::checkRef(refProd.val, ref); + set.insert(ref.key()); + } + } + }; + + // Specialize for View + template + struct FillIndices > { + template + static + void fill(T_Set& set, const edm::View& valueView, const T_RefProd& refProd) { + for(size_t i=0; i>, the collection of Refs can be + * RefVector, vector>, vector>, or + * View. More can be supported if needed. + * + * @return A filtered copy of the AssociationMap + * + * Throws if the values of AssociationMap and valueRefs point to + * different collections (similar check as in + * AssociationMap::operator[] for the keys). + */ +template +T_AssociationMap associationMapFilterValues(const T_AssociationMap& map, const T_RefVector& valueRefs) { + T_AssociationMap ret(map.refProd()); + + // First copy the keys of values to a set for faster lookup of their existence in the map + std::unordered_set value_indices; + associationMapFilterValuesHelpers::FillIndices::fill(value_indices, valueRefs, map.refProd()); + + for(const auto& keyValue: map) { + associationMapFilterValuesHelpers::IfFound::insert(ret, keyValue, value_indices); + } + + + return ret; +} + +#endif + diff --git a/CommonTools/Utils/test/BuildFile.xml b/CommonTools/Utils/test/BuildFile.xml index db54775ef7ed4..2163089047c94 100644 --- a/CommonTools/Utils/test/BuildFile.xml +++ b/CommonTools/Utils/test/BuildFile.xml @@ -1,4 +1,4 @@ - + diff --git a/CommonTools/Utils/test/testAssociationMapFilterValues.cc b/CommonTools/Utils/test/testAssociationMapFilterValues.cc new file mode 100644 index 0000000000000..c1ac915e78a75 --- /dev/null +++ b/CommonTools/Utils/test/testAssociationMapFilterValues.cc @@ -0,0 +1,315 @@ +#include "CommonTools/Utils/interface/associationMapFilterValues.h" +#include "DataFormats/Common/interface/AssociationMap.h" + +#include + +class testAssociationMapFilterValues : public CppUnit::TestFixture { + CPPUNIT_TEST_SUITE(testAssociationMapFilterValues); + CPPUNIT_TEST(checkOneToOne); + CPPUNIT_TEST(checkOneToMany); + CPPUNIT_TEST(checkOneToManyQuality); + CPPUNIT_TEST_SUITE_END(); + +public: + void setUp() {} + void tearDown() {} + void checkOneToOne(); + void checkOneToMany(); + void checkOneToManyQuality(); +}; + +CPPUNIT_TEST_SUITE_REGISTRATION( testAssociationMapFilterValues ); + +namespace { + class Base { + public: + explicit Base(double v): v_(v) {} + virtual ~Base() {} + + double value() const { return v_; } + private: + double v_; + }; + + class Derived: public Base { + public: + explicit Derived(double v): Base(v) {} + virtual ~Derived() {} + }; +} + +void testAssociationMapFilterValues::checkOneToOne() { + typedef std::vector CKey; + typedef std::vector CVal; + typedef edm::AssociationMap > Assoc; + + CKey keys{1, 2, 3}; + CVal values{1.0, 2.0, 3.0}; + + auto refprod = Assoc::ref_type(edm::RefProd(&keys), edm::RefProd(&values)); + auto map = Assoc(refprod); + map.insert(edm::Ref(&keys, 0), edm::Ref(&values, 0)); + map.insert(edm::Ref(&keys, 1), edm::Ref(&values, 1)); + map.insert(edm::Ref(&keys, 2), edm::Ref(&values, 2)); + + // vector of Refs + std::vector> keep{edm::Ref(&values, 0), edm::Ref(&values, 2)}; + Assoc filtered = associationMapFilterValues(map, keep); + CPPUNIT_ASSERT( filtered.size() == 2 ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 0)) != filtered.end() ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 1)) == filtered.end() ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 2)) != filtered.end() ); + + // RefVector + edm::RefVector keep2; + keep2.push_back(edm::Ref(&values, 1)); + filtered = associationMapFilterValues(map, keep2); + CPPUNIT_ASSERT( filtered.size() == 1 ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 0)) == filtered.end() ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 1)) != filtered.end() ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 2)) == filtered.end() ); + + // Mostly check that it compiles + edm::View keepView; + filtered = associationMapFilterValues(map, keepView); + CPPUNIT_ASSERT( filtered.size() == 0 ); +} + +void testAssociationMapFilterValues::checkOneToMany() { + // simple data + { + typedef std::vector CKey; + typedef std::vector CVal; + typedef edm::AssociationMap > Assoc; + + CKey keys{1, 2, 3}; + CVal values{1.0, 2.0, 3.0, 4.0}; + + auto refprod = Assoc::ref_type(edm::RefProd(&keys), edm::RefProd(&values)); + auto map = Assoc(refprod); + map.insert(edm::Ref(&keys, 0), edm::Ref(&values, 0)); + map.insert(edm::Ref(&keys, 1), edm::Ref(&values, 1)); + map.insert(edm::Ref(&keys, 2), edm::Ref(&values, 2)); + map.insert(edm::Ref(&keys, 2), edm::Ref(&values, 3)); + + std::vector> keep{edm::Ref(&values, 0), edm::Ref(&values, 2)}; + + Assoc filtered = associationMapFilterValues(map, keep); + CPPUNIT_ASSERT( filtered.size() == 2 ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 0)) != filtered.end() ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 1)) == filtered.end() ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 2)) != filtered.end() ); + } + + // Ref data + { + typedef std::vector CKey; + typedef std::vector Data; + typedef std::vector> CVal; + typedef edm::AssociationMap > Assoc; + + CKey keys{1, 2, 3}; + Data data{1.0, 2.0, 3.0, 4.0}; + CVal values{edm::Ref(&data, 0), edm::Ref(&data, 1), edm::Ref(&data, 2)}; + + auto refprod = Assoc::ref_type(edm::RefProd(&keys), edm::RefProd(&values)); + auto map = Assoc(refprod); + map.insert(edm::Ref(&keys, 0), edm::Ref(&values, 0)); + map.insert(edm::Ref(&keys, 1), edm::Ref(&values, 1)); + map.insert(edm::Ref(&keys, 2), edm::Ref(&values, 1)); + map.insert(edm::Ref(&keys, 2), edm::Ref(&values, 0)); + map.insert(edm::Ref(&keys, 3), edm::Ref(&values, 2)); + + std::vector> keep{edm::Ref(&values, 0), edm::Ref(&values, 2)}; + + Assoc filtered = associationMapFilterValues(map, keep); + CPPUNIT_ASSERT( filtered.size() == 3 ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 0)) != filtered.end() ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 1)) == filtered.end() ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 2)) != filtered.end() ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 3)) != filtered.end() ); + } + + // RefToBase data + { + typedef std::vector CKey; + typedef std::vector Data; + typedef std::vector> CVal; + typedef edm::AssociationMap > Assoc; + + CKey keys{1, 2, 3}; + Data data{Derived(1.0), Derived(2.0), Derived(3.0), Derived(4.0)}; + + CVal values{ + edm::RefToBase(edm::Ref(&data, 0)), + edm::RefToBase(edm::Ref(&data, 1)), + edm::RefToBase(edm::Ref(&data, 2)) + }; + + auto refprod = Assoc::ref_type(edm::RefProd(&keys), edm::RefProd(&values)); + auto map = Assoc(refprod); + map.insert(edm::Ref(&keys, 0), edm::Ref(&values, 0)); + map.insert(edm::Ref(&keys, 1), edm::Ref(&values, 1)); + map.insert(edm::Ref(&keys, 2), edm::Ref(&values, 1)); + map.insert(edm::Ref(&keys, 2), edm::Ref(&values, 0)); + map.insert(edm::Ref(&keys, 3), edm::Ref(&values, 2)); + + std::vector> keep{ + edm::RefToBase(edm::Ref(&data, 0)), + edm::RefToBase(edm::Ref(&data, 2)) + }; + + Assoc filtered = associationMapFilterValues(map, keep); + CPPUNIT_ASSERT( filtered.size() == 3 ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 0)) != filtered.end() ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 1)) == filtered.end() ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 2)) != filtered.end() ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 3)) != filtered.end() ); + } + + // View, mostly check that it compiles + { + typedef std::vector CKey; + typedef edm::View CVal; + typedef edm::AssociationMap > Assoc; + + Assoc map; + edm::View keep; + Assoc filtered = associationMapFilterValues(map, keep); + CPPUNIT_ASSERT( filtered.size() == 0 ); + } +} + +void testAssociationMapFilterValues::checkOneToManyQuality() { + // simple data + { + typedef std::vector CKey; + typedef std::vector CVal; + typedef edm::AssociationMap > Assoc; + + CKey keys{1, 2, 3}; + CVal values{1.0, 2.0, 3.0, 4.0}; + + auto refprod = Assoc::ref_type(edm::RefProd(&keys), edm::RefProd(&values)); + auto map = Assoc(refprod); + map.insert(edm::Ref(&keys, 0), std::make_pair(edm::Ref(&values, 0), 0.1)); + map.insert(edm::Ref(&keys, 1), std::make_pair(edm::Ref(&values, 1), 0.2)); + map.insert(edm::Ref(&keys, 2), std::make_pair(edm::Ref(&values, 2), 0.3)); + map.insert(edm::Ref(&keys, 2), std::make_pair(edm::Ref(&values, 3), 0.4)); + + std::vector> keep{edm::Ref(&values, 0), edm::Ref(&values, 2)}; + + Assoc filtered = associationMapFilterValues(map, keep); + CPPUNIT_ASSERT( filtered.size() == 2 ); + auto found = filtered.find(edm::Ref(&keys, 0)); + CPPUNIT_ASSERT( found != filtered.end() ); + CPPUNIT_ASSERT( found->val.size() == 1 ); + CPPUNIT_ASSERT( found->val[0].second == 0.1 ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 1)) == filtered.end() ); + found = filtered.find(edm::Ref(&keys, 2)); + CPPUNIT_ASSERT( found->val.size() == 1 ); + CPPUNIT_ASSERT( found->val[0].second == 0.3 ); + } + + // Ref data + { + typedef std::vector CKey; + typedef std::vector Data; + typedef std::vector> CVal; + typedef edm::AssociationMap > Assoc; + + CKey keys{1, 2, 3}; + Data data{1.0, 2.0, 3.0, 4.0}; + CVal values{edm::Ref(&data, 0), edm::Ref(&data, 1), edm::Ref(&data, 2)}; + + auto refprod = Assoc::ref_type(edm::RefProd(&keys), edm::RefProd(&values)); + auto map = Assoc(refprod); + map.insert(edm::Ref(&keys, 0), std::make_pair(edm::Ref(&values, 0), 0.1)); + map.insert(edm::Ref(&keys, 1), std::make_pair(edm::Ref(&values, 1), 0.2)); + map.insert(edm::Ref(&keys, 2), std::make_pair(edm::Ref(&values, 1), 0.3)); + map.insert(edm::Ref(&keys, 2), std::make_pair(edm::Ref(&values, 0), 0.4)); + map.insert(edm::Ref(&keys, 3), std::make_pair(edm::Ref(&values, 2), 0.5)); + + std::vector> keep{edm::Ref(&values, 0), edm::Ref(&values, 1)}; + + Assoc filtered = associationMapFilterValues(map, keep); + CPPUNIT_ASSERT( filtered.size() == 3 ); + auto found = filtered.find(edm::Ref(&keys, 0)); + CPPUNIT_ASSERT( found != filtered.end() ); + CPPUNIT_ASSERT( found->val.size() == 1 ); + CPPUNIT_ASSERT( found->val[0].second == 0.1 ); + found = filtered.find(edm::Ref(&keys, 1)); + CPPUNIT_ASSERT( found != filtered.end() ); + CPPUNIT_ASSERT( found->val.size() == 1 ); + CPPUNIT_ASSERT( found->val[0].second == 0.2 ); + found = filtered.find(edm::Ref(&keys, 2)); + CPPUNIT_ASSERT( found != filtered.end() ); + CPPUNIT_ASSERT( found->val.size() == 2 ); + CPPUNIT_ASSERT( found->val[0].second == 0.3 ); + CPPUNIT_ASSERT( found->val[1].second == 0.4 ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 3)) == filtered.end() ); + } + + // RefToBase data + { + typedef std::vector CKey; + typedef std::vector Data; + typedef std::vector> CVal; + typedef edm::AssociationMap > Assoc; + + CKey keys{1, 2, 3}; + Data data{Derived(1.0), Derived(2.0), Derived(3.0), Derived(4.0)}; + + CVal values{ + edm::RefToBase(edm::Ref(&data, 0)), + edm::RefToBase(edm::Ref(&data, 1)), + edm::RefToBase(edm::Ref(&data, 2)) + }; + + auto refprod = Assoc::ref_type(edm::RefProd(&keys), edm::RefProd(&values)); + auto map = Assoc(refprod); + map.insert(edm::Ref(&keys, 0), std::make_pair(edm::Ref(&values, 0), 0.1)); + map.insert(edm::Ref(&keys, 1), std::make_pair(edm::Ref(&values, 1), 0.2)); + map.insert(edm::Ref(&keys, 2), std::make_pair(edm::Ref(&values, 1), 0.3)); + map.insert(edm::Ref(&keys, 2), std::make_pair(edm::Ref(&values, 0), 0.4)); + map.insert(edm::Ref(&keys, 3), std::make_pair(edm::Ref(&values, 1), 0.6)); + map.insert(edm::Ref(&keys, 3), std::make_pair(edm::Ref(&values, 2), 0.5)); + map.insert(edm::Ref(&keys, 3), std::make_pair(edm::Ref(&values, 0), 0.7)); + + std::vector> keep{ + edm::RefToBase(edm::Ref(&data, 2)), + edm::RefToBase(edm::Ref(&data, 1)) + }; + + Assoc filtered = associationMapFilterValues(map, keep); + CPPUNIT_ASSERT( filtered.size() == 3 ); + CPPUNIT_ASSERT( filtered.find(edm::Ref(&keys, 0)) == filtered.end() ); + auto found = filtered.find(edm::Ref(&keys, 1)); + CPPUNIT_ASSERT( found != filtered.end() ); + CPPUNIT_ASSERT( found->val.size() == 1 ); + CPPUNIT_ASSERT( found->val[0].second == 0.2 ); + found = filtered.find(edm::Ref(&keys, 2)); + CPPUNIT_ASSERT( found != filtered.end() ); + CPPUNIT_ASSERT( found->val.size() == 1 ); + CPPUNIT_ASSERT( found->val[0].second == 0.3 ); + found = filtered.find(edm::Ref(&keys, 3)); + CPPUNIT_ASSERT( found != filtered.end() ); + CPPUNIT_ASSERT( found->val.size() == 2 ); + CPPUNIT_ASSERT( found->val[0].first->get()->value() == 2.0 ); + CPPUNIT_ASSERT( found->val[0].second == 0.6 ); + CPPUNIT_ASSERT( found->val[1].first->get()->value() == 3.0 ); + CPPUNIT_ASSERT( found->val[1].second == 0.5 ); + } + + // View, mostly check that it compiles + { + typedef std::vector CKey; + typedef edm::View CVal; + typedef edm::AssociationMap > Assoc; + + Assoc map; + edm::View keep; + Assoc filtered = associationMapFilterValues(map, keep); + CPPUNIT_ASSERT( filtered.size() == 0 ); + } +} diff --git a/FastSimulation/Validation/python/globalValidation_cff.py b/FastSimulation/Validation/python/globalValidation_cff.py index 1c42524a2c88b..4f897ce43e472 100644 --- a/FastSimulation/Validation/python/globalValidation_cff.py +++ b/FastSimulation/Validation/python/globalValidation_cff.py @@ -31,7 +31,7 @@ globalPrevalidation = cms.Sequence( simHitTPAssocProducer - *tracksValidationSelectors + *tracksPreValidationFS *recoMuonAssociationFastSim # resides in other sequence in FullSim #photonPrevalidationSequence # not used by FastSim *produceDenoms diff --git a/FastSimulation/Validation/test/TrackRecoAndValidation_FullSim_cfg.py b/FastSimulation/Validation/test/TrackRecoAndValidation_FullSim_cfg.py index c20e4dc59d14c..57548aa53e505 100644 --- a/FastSimulation/Validation/test/TrackRecoAndValidation_FullSim_cfg.py +++ b/FastSimulation/Validation/test/TrackRecoAndValidation_FullSim_cfg.py @@ -118,7 +118,7 @@ # load tracker seed validator process.load('Validation.RecoTrack.TrackerSeedValidator_cfi') -process.trackerSeedValidator.associators = cms.vstring('trackAssociatorByHitsRecoDenom') +process.trackerSeedValidator.associators = ['quickTrackAssociatorByHits'] process.trackerSeedValidator.label = cms.VInputTag( cms.InputTag("initialStepSeeds"), cms.InputTag("detachedTripletStepSeeds"), @@ -128,7 +128,7 @@ cms.InputTag("pixelLessStepSeeds"), cms.InputTag("tobTecStepSeeds")) # redefine validation paths -process.prevalidation = cms.Sequence(process.tracksValidationSelectors) +process.prevalidation = cms.Sequence(process.tracksPreValidation) process.validation = cms.Sequence(process.trackingTruthValid + process.tracksValidation + process.trackerSeedValidator) # END MODIFICATIONS diff --git a/FastSimulation/Validation/test/TrackRecoAndValidation_cfg.py b/FastSimulation/Validation/test/TrackRecoAndValidation_cfg.py index 779d7992fb6a5..289a2cc039ee5 100644 --- a/FastSimulation/Validation/test/TrackRecoAndValidation_cfg.py +++ b/FastSimulation/Validation/test/TrackRecoAndValidation_cfg.py @@ -117,7 +117,7 @@ # load tracker seed validator process.load('Validation.RecoTrack.TrackerSeedValidator_cfi') process.trackerSeedValidator.TTRHBuilder = "WithoutRefit" -process.trackerSeedValidator.associators = cms.vstring('trackAssociatorByHitsRecoDenom') +process.trackerSeedValidator.associators = ['quickTrackAssociatorByHits'] process.trackerSeedValidator.label = cms.VInputTag( cms.InputTag("initialStepSeeds"), cms.InputTag("detachedTripletStepSeeds"), @@ -127,6 +127,6 @@ cms.InputTag("pixelLessStepSeeds"), cms.InputTag("tobTecStepSeeds")) # redefine validation paths -process.prevalidation = cms.Sequence(process.tracksValidationSelectors) +process.prevalidation = cms.Sequence(process.tracksPreValidation) process.validation = cms.Sequence(process.trackingTruthValid + process.tracksValidationFS + process.trackerSeedValidator) # END MODIFICATIONS diff --git a/SLHCUpgradeSimulations/Geometry/python/Validation_cff.py b/SLHCUpgradeSimulations/Geometry/python/Validation_cff.py index 5c6a16e3ab96f..5ffd5548570bc 100644 --- a/SLHCUpgradeSimulations/Geometry/python/Validation_cff.py +++ b/SLHCUpgradeSimulations/Geometry/python/Validation_cff.py @@ -32,7 +32,7 @@ # cms.InputTag("cutsRecoTracksThirdHpUpg"), # cms.InputTag("cutsRecoTracksFourthHpUpg") ) -trackValidator.associators = cms.vstring('quickTrackAssociatorByHits') +trackValidator.associators = ['quickTrackAssociatorByHits'] trackValidator.UseAssociators = True trackValidator.histoProducerAlgoBlock.nintEta = cms.int32(20) trackValidator.histoProducerAlgoBlock.nintPt = cms.int32(100) diff --git a/SLHCUpgradeSimulations/Geometry/test/GenRecoFull_Fastsim_Longbarrel_cfg.py b/SLHCUpgradeSimulations/Geometry/test/GenRecoFull_Fastsim_Longbarrel_cfg.py index 060eba49e4cf9..0da8f649780ae 100644 --- a/SLHCUpgradeSimulations/Geometry/test/GenRecoFull_Fastsim_Longbarrel_cfg.py +++ b/SLHCUpgradeSimulations/Geometry/test/GenRecoFull_Fastsim_Longbarrel_cfg.py @@ -244,8 +244,8 @@ process.trackValidator.label=cms.VInputTag(cms.InputTag("generalTracks"), cms.InputTag("cutsRecoTracksHp"), cms.InputTag("cutsRecoTracksHpwbtagc"), - cms.InputTag("cutsRecoTracksZeroHp"), - cms.InputTag("cutsRecoTracksFirstHp") + cms.InputTag("cutsRecoTracksInitialStepHp"), + cms.InputTag("cutsRecoTracksLowPtTripletStepHp") ) process.trackValidator.associators = ['trackAssociatorByHits'] #process.trackValidator.associators = cms.vstring('quickTrackAssociatorByHits') @@ -280,8 +280,8 @@ process.slhcTracksValidation = cms.Sequence(process.cutsRecoTracksHp* process.cutsRecoTracksHpwbtagc* - process.cutsRecoTracksZeroHp* - process.cutsRecoTracksFirstHp* + process.cutsRecoTracksInitialStepHp* + process.cutsRecoTracksLowPtTripletStepHp* process.trackAssociatorByHits* process.trackValidator) diff --git a/SLHCUpgradeSimulations/Geometry/test/GenRecoIter_Fastsim_Longbarrel_cfg.py b/SLHCUpgradeSimulations/Geometry/test/GenRecoIter_Fastsim_Longbarrel_cfg.py index 215a3b12184f3..218c321918d34 100644 --- a/SLHCUpgradeSimulations/Geometry/test/GenRecoIter_Fastsim_Longbarrel_cfg.py +++ b/SLHCUpgradeSimulations/Geometry/test/GenRecoIter_Fastsim_Longbarrel_cfg.py @@ -242,8 +242,8 @@ process.trackValidator.label=cms.VInputTag(cms.InputTag("generalTracks"), cms.InputTag("cutsRecoTracksHp"), cms.InputTag("cutsRecoTracksHpwbtagc"), - cms.InputTag("cutsRecoTracksZeroHp"), - cms.InputTag("cutsRecoTracksFirstHp") + cms.InputTag("cutsRecoTracksInitialStepHp"), + cms.InputTag("cutsRecoTracksLowPtTripletStepHp") ) process.trackValidator.associators = ['trackAssociatorByHits'] #process.trackValidator.associators = cms.vstring('quickTrackAssociatorByHits') @@ -278,8 +278,8 @@ process.slhcTracksValidation = cms.Sequence(process.cutsRecoTracksHp* process.cutsRecoTracksHpwbtagc* - process.cutsRecoTracksZeroHp* - process.cutsRecoTracksFirstHp* + process.cutsRecoTracksInitialStepHp* + process.cutsRecoTracksLowPtTripletStepHp* process.trackAssociatorByHits* process.trackValidator) diff --git a/SLHCUpgradeSimulations/Geometry/test/GenRecoIter_Fastsim_Phase1_cfg.py b/SLHCUpgradeSimulations/Geometry/test/GenRecoIter_Fastsim_Phase1_cfg.py index dc69d3761e05b..3fa9c139254e1 100644 --- a/SLHCUpgradeSimulations/Geometry/test/GenRecoIter_Fastsim_Phase1_cfg.py +++ b/SLHCUpgradeSimulations/Geometry/test/GenRecoIter_Fastsim_Phase1_cfg.py @@ -234,10 +234,10 @@ process.trackValidator.label=cms.VInputTag(cms.InputTag("generalTracks"), cms.InputTag("cutsRecoTracksHp"), cms.InputTag("cutsRecoTracksHpwbtagc"), - cms.InputTag("cutsRecoTracksZeroHp"), - cms.InputTag("cutsRecoTracksFirstHp") + cms.InputTag("cutsRecoTracksInitialStepHp"), + cms.InputTag("cutsRecoTracksLowPtTripletStepHp") ) -process.trackValidator.associators = cms.vstring('quickTrackAssociatorByHits') +process.trackValidator.associators = ['quickTrackAssociatorByHits'] process.trackValidator.UseAssociators = True ## options to match with 363 histos for comparison process.trackValidator.histoProducerAlgoBlock.nintEta = cms.int32(20) @@ -269,8 +269,8 @@ process.slhcTracksValidation = cms.Sequence(process.cutsRecoTracksHp* process.cutsRecoTracksHpwbtagc* - process.cutsRecoTracksZeroHp* - process.cutsRecoTracksFirstHp* + process.cutsRecoTracksInitialStepHp* + process.cutsRecoTracksLowPtTripletStepHp* process.quickTrackAssociatorByHits* process.trackValidator) diff --git a/SLHCUpgradeSimulations/Geometry/test/GenRecoIter_Fastsim_Stdgeom_cfg.py b/SLHCUpgradeSimulations/Geometry/test/GenRecoIter_Fastsim_Stdgeom_cfg.py index 2b7ce389a72ae..3e9b09bc7658e 100644 --- a/SLHCUpgradeSimulations/Geometry/test/GenRecoIter_Fastsim_Stdgeom_cfg.py +++ b/SLHCUpgradeSimulations/Geometry/test/GenRecoIter_Fastsim_Stdgeom_cfg.py @@ -227,10 +227,10 @@ process.trackValidator.label=cms.VInputTag(cms.InputTag("generalTracks"), cms.InputTag("cutsRecoTracksHp"), cms.InputTag("cutsRecoTracksHpwbtagc"), - cms.InputTag("cutsRecoTracksZeroHp"), - cms.InputTag("cutsRecoTracksFirstHp") + cms.InputTag("cutsRecoTracksInitialStepHp"), + cms.InputTag("cutsRecoTracksLowPtTripletStepHp") ) -process.trackValidator.associators = cms.vstring('quickTrackAssociatorByHits') +process.trackValidator.associators = ['quickTrackAssociatorByHits'] process.trackValidator.UseAssociators = True ## options to match with 363 histos for comparison process.trackValidator.histoProducerAlgoBlock.nintEta = cms.int32(20) @@ -262,8 +262,8 @@ process.slhcTracksValidation = cms.Sequence(process.cutsRecoTracksHp* process.cutsRecoTracksHpwbtagc* - process.cutsRecoTracksZeroHp* - process.cutsRecoTracksFirstHp* + process.cutsRecoTracksInitialStepHp* + process.cutsRecoTracksLowPtTripletStepHp* process.quickTrackAssociatorByHits* process.trackValidator) diff --git a/SLHCUpgradeSimulations/Geometry/test/RecoIter_Fullsim_Longbarrel_cfg.py b/SLHCUpgradeSimulations/Geometry/test/RecoIter_Fullsim_Longbarrel_cfg.py index 4686b4c646ca4..b86064f95b205 100644 --- a/SLHCUpgradeSimulations/Geometry/test/RecoIter_Fullsim_Longbarrel_cfg.py +++ b/SLHCUpgradeSimulations/Geometry/test/RecoIter_Fullsim_Longbarrel_cfg.py @@ -176,14 +176,14 @@ process.trackValidator.label=cms.VInputTag(cms.InputTag("generalTracks"), cms.InputTag("cutsRecoTracksHp"), cms.InputTag("cutsRecoTracksHpwbtagc"), - cms.InputTag("cutsRecoTracksZeroHp"), - cms.InputTag("cutsRecoTracksFirstHp"), - cms.InputTag("cutsRecoTracksSecondHp"), - cms.InputTag("cutsRecoTracksThirdHp"), - cms.InputTag("cutsRecoTracksFourthHp") + cms.InputTag("cutsRecoTracksInitialStepHp"), + cms.InputTag("cutsRecoTracksLowPtTripletStepHp"), + cms.InputTag("cutsRecoTracksPixelPairStepHp"), + cms.InputTag("cutsRecoTracksDetachedTripletHp"), + cms.InputTag("cutsRecoTracksMixedTripletHp") ) #process.trackValidator.associators = ['trackAssociatorByHits'] -process.trackValidator.associators = cms.vstring('quickTrackAssociatorByHits') +process.trackValidator.associators = ['quickTrackAssociatorByHits'] process.trackValidator.UseAssociators = True ## options to match with 363 histos for comparison process.trackValidator.histoProducerAlgoBlock.nintEta = cms.int32(20) @@ -215,11 +215,11 @@ process.slhcTracksValidation = cms.Sequence(process.cutsRecoTracksHp* process.cutsRecoTracksHpwbtagc* - process.cutsRecoTracksZeroHp* - process.cutsRecoTracksFirstHp* - process.cutsRecoTracksSecondHp* - process.cutsRecoTracksThirdHp* - process.cutsRecoTracksFourthHp* + process.cutsRecoTracksInitialStepHp* + process.cutsRecoTracksLowPtTripletStepHp* + process.cutsRecoTracksPixelPairStepHp* + process.cutsRecoTracksDetachedTripletHp* + process.cutsRecoTracksMixedTripletHp* process.quickTrackAssociatorByHits* process.trackValidator) diff --git a/SLHCUpgradeSimulations/Geometry/test/RecoIter_Fullsim_Phase1_cfg.py b/SLHCUpgradeSimulations/Geometry/test/RecoIter_Fullsim_Phase1_cfg.py index 37995ca3ce825..12a00798eca2e 100644 --- a/SLHCUpgradeSimulations/Geometry/test/RecoIter_Fullsim_Phase1_cfg.py +++ b/SLHCUpgradeSimulations/Geometry/test/RecoIter_Fullsim_Phase1_cfg.py @@ -208,7 +208,7 @@ cms.InputTag("cutsRecoTracksFourthHpUpg") ) #process.trackValidator.associators = ['trackAssociatorByHits'] -process.trackValidator.associators = cms.vstring('quickTrackAssociatorByHits') +process.trackValidator.associators = ['quickTrackAssociatorByHits'] process.trackValidator.UseAssociators = True ## options to match with 363 histos for comparison process.trackValidator.histoProducerAlgoBlock.nintEta = cms.int32(20) diff --git a/SLHCUpgradeSimulations/Geometry/test/RecoIter_Fullsim_stdgeom_cfg.py b/SLHCUpgradeSimulations/Geometry/test/RecoIter_Fullsim_stdgeom_cfg.py index 46edb5d0a8d0c..c8bdea910e1d9 100644 --- a/SLHCUpgradeSimulations/Geometry/test/RecoIter_Fullsim_stdgeom_cfg.py +++ b/SLHCUpgradeSimulations/Geometry/test/RecoIter_Fullsim_stdgeom_cfg.py @@ -201,7 +201,7 @@ cms.InputTag("cutsRecoTracksFourthHpUpg") ) #process.trackValidator.associators = ['trackAssociatorByHits'] -process.trackValidator.associators = cms.vstring('quickTrackAssociatorByHits') +process.trackValidator.associators = ['quickTrackAssociatorByHits'] process.trackValidator.UseAssociators = True ## options to match with 363 histos for comparison process.trackValidator.histoProducerAlgoBlock.nintEta = cms.int32(20) diff --git a/Validation/Configuration/python/globalValidation_cff.py b/Validation/Configuration/python/globalValidation_cff.py index 16d8925c2b04d..f6784dd5b12f4 100644 --- a/Validation/Configuration/python/globalValidation_cff.py +++ b/Validation/Configuration/python/globalValidation_cff.py @@ -42,7 +42,7 @@ # filter/producer "pre-" sequence for globalValidation globalPrevalidation = cms.Sequence( simHitTPAssocProducer - * tracksValidationSelectors + * tracksPreValidation * photonPrevalidationSequence * produceDenoms * prebTagSequenceMC @@ -50,7 +50,7 @@ # filter/producer "pre-" sequence for validation_preprod preprodPrevalidation = cms.Sequence( - tracksValidationSelectors + tracksPreValidation ) globalValidation = cms.Sequence( trackerHitsValidation @@ -103,21 +103,23 @@ #lite pre-validation globalPrevalidationLiteTracking = cms.Sequence(globalPrevalidation) -globalPrevalidationLiteTracking.remove(cutsRecoTracksZero) -globalPrevalidationLiteTracking.remove(cutsRecoTracksZeroHp) -globalPrevalidationLiteTracking.remove(cutsRecoTracksFirst) -globalPrevalidationLiteTracking.remove(cutsRecoTracksFirstHp) -globalPrevalidationLiteTracking.remove(cutsRecoTracksSecond) -globalPrevalidationLiteTracking.remove(cutsRecoTracksSecondHp) -globalPrevalidationLiteTracking.remove(cutsRecoTracksThird) -globalPrevalidationLiteTracking.remove(cutsRecoTracksThirdHp) -globalPrevalidationLiteTracking.remove(cutsRecoTracksFourth) -globalPrevalidationLiteTracking.remove(cutsRecoTracksFourthHp) -globalPrevalidationLiteTracking.remove(cutsRecoTracksFifth) -globalPrevalidationLiteTracking.remove(cutsRecoTracksFifthHp) -globalPrevalidationLiteTracking.remove(cutsRecoTracksSixth) -globalPrevalidationLiteTracking.remove(cutsRecoTracksSixthHp) -globalPrevalidationLiteTracking.remove(cutsRecoTracksNinth) -globalPrevalidationLiteTracking.remove(cutsRecoTracksNinthHp) -globalPrevalidationLiteTracking.remove(cutsRecoTracksTenth) -globalPrevalidationLiteTracking.remove(cutsRecoTracksTenthHp) +globalPrevalidationLiteTracking.remove(cutsRecoTracksInitialStep) +globalPrevalidationLiteTracking.remove(cutsRecoTracksInitialStepHp) +globalPrevalidationLiteTracking.remove(cutsRecoTracksLowPtTripletStep) +globalPrevalidationLiteTracking.remove(cutsRecoTracksLowPtTripletStepHp) +globalPrevalidationLiteTracking.remove(cutsRecoTracksPixelPairStep) +globalPrevalidationLiteTracking.remove(cutsRecoTracksPixelPairStepHp) +globalPrevalidationLiteTracking.remove(cutsRecoTracksDetachedTripletStep) +globalPrevalidationLiteTracking.remove(cutsRecoTracksDetachedTripletStepHp) +globalPrevalidationLiteTracking.remove(cutsRecoTracksMixedTripletStep) +globalPrevalidationLiteTracking.remove(cutsRecoTracksMixedTripletStepHp) +globalPrevalidationLiteTracking.remove(cutsRecoTracksPixelLessStep) +globalPrevalidationLiteTracking.remove(cutsRecoTracksPixelLessStepHp) +globalPrevalidationLiteTracking.remove(cutsRecoTracksTobTecStep) +globalPrevalidationLiteTracking.remove(cutsRecoTracksTobTecStepHp) +globalPrevalidationLiteTracking.remove(cutsRecoTracksJetCoreRegionalStep) +globalPrevalidationLiteTracking.remove(cutsRecoTracksJetCoreRegionalStepHp) +globalPrevalidationLiteTracking.remove(cutsRecoTracksMuonSeededStepInOut) +globalPrevalidationLiteTracking.remove(cutsRecoTracksMuonSeededStepInOutHp) +globalPrevalidationLiteTracking.remove(cutsRecoTracksMuonSeededStepOutIn) +globalPrevalidationLiteTracking.remove(cutsRecoTracksMuonSeededStepOutInHp) diff --git a/Validation/RecoHI/python/TrackValidationHeavyIons_cff.py b/Validation/RecoHI/python/TrackValidationHeavyIons_cff.py index 4c43a18b2996c..103949c8cacb1 100644 --- a/Validation/RecoHI/python/TrackValidationHeavyIons_cff.py +++ b/Validation/RecoHI/python/TrackValidationHeavyIons_cff.py @@ -1,7 +1,8 @@ import FWCore.ParameterSet.Config as cms # track associator settings -from Validation.RecoTrack.TrackValidation_cff import trackAssociatorByHitsRecoDenom +import SimTracker.TrackAssociatorProducers.quickTrackAssociatorByHits_cfi +trackAssociatorByHitsRecoDenom = SimTracker.TrackAssociatorProducers.quickTrackAssociatorByHits_cfi.quickTrackAssociatorByHits.clone() # reco track quality cuts from Validation.RecoTrack.cuts_cff import * @@ -19,6 +20,8 @@ # setup multi-track validator from Validation.RecoTrack.MultiTrackValidator_cff import * hiTrackValidator = multiTrackValidator.clone( + associators = ["trackAssociatorByHitsRecoDenom"], + UseAssociators = True, label_tp_effic = cms.InputTag("primaryChgSimTracks"), label_tp_fake = cms.InputTag("cutsTPFake"), signalOnlyTP = cms.bool(False), diff --git a/Validation/RecoTrack/README.md b/Validation/RecoTrack/README.md new file mode 100644 index 0000000000000..b598421315c0f --- /dev/null +++ b/Validation/RecoTrack/README.md @@ -0,0 +1,14 @@ +Tracking validation +=================== + +The workhorse of the tracking validation is MultiTrackValidator, for +which documentation is available in +https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideMultiTrackValidator. + +There is also a version of MultiTrackValidator for seeds called +TrackerSeedValidator, see +https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideTrackerSeedValidator +for more details. + +The plotting tools are documented in +https://twiki.cern.ch/twiki/bin/view/CMS/TrackingValidationMC. diff --git a/Validation/RecoTrack/interface/MultiTrackValidator.h b/Validation/RecoTrack/interface/MultiTrackValidator.h index 3dbbcda6bdebb..9fc474dda8352 100644 --- a/Validation/RecoTrack/interface/MultiTrackValidator.h +++ b/Validation/RecoTrack/interface/MultiTrackValidator.h @@ -31,13 +31,14 @@ class MultiTrackValidator : public DQMEDAnalyzer, protected MultiTrackValidatorB protected: //these are used by MTVGenPs - edm::InputTag assMapInput; - edm::EDGetTokenT associatormapStR; - edm::EDGetTokenT associatormapRtS; bool UseAssociators; MTVHistoProducerAlgo* histoProducerAlgo_; private: + std::vector> associatorTokens; + std::vector> associatormapStRs; + std::vector> associatormapRtSs; + std::string dirName_; bool useGsf; diff --git a/Validation/RecoTrack/interface/MultiTrackValidatorBase.h b/Validation/RecoTrack/interface/MultiTrackValidatorBase.h index e875dc92a0cc8..256c3d1ee1906 100644 --- a/Validation/RecoTrack/interface/MultiTrackValidatorBase.h +++ b/Validation/RecoTrack/interface/MultiTrackValidatorBase.h @@ -55,7 +55,7 @@ class MultiTrackValidatorBase { //DQMStore* dbe_; // MTV-specific data members - std::vector associators; + std::vector associators; edm::EDGetTokenT label_tp_effic; edm::EDGetTokenT label_tp_fake; edm::EDGetTokenT label_tv; diff --git a/Validation/RecoTrack/interface/MultiTrackValidatorGenPs.h b/Validation/RecoTrack/interface/MultiTrackValidatorGenPs.h index 14f17b4873de3..e17e8db6964d2 100644 --- a/Validation/RecoTrack/interface/MultiTrackValidatorGenPs.h +++ b/Validation/RecoTrack/interface/MultiTrackValidatorGenPs.h @@ -26,6 +26,8 @@ class MultiTrackValidatorGenPs : public MultiTrackValidator { GenParticleCustomSelector gpSelector; edm::EDGetTokenT label_gen_associator; + edm::EDGetTokenT associatormapGtR; + edm::EDGetTokenT associatormapRtG; }; diff --git a/Validation/RecoTrack/interface/TrackerSeedValidator.h b/Validation/RecoTrack/interface/TrackerSeedValidator.h index 439e2cbbf9a51..715521dd041bc 100644 --- a/Validation/RecoTrack/interface/TrackerSeedValidator.h +++ b/Validation/RecoTrack/interface/TrackerSeedValidator.h @@ -32,6 +32,8 @@ class TrackerSeedValidator : public DQMEDAnalyzer, protected MultiTrackValidator void bookHistograms(DQMStore::IBooker&, edm::Run const&, edm::EventSetup const&) override; private: + std::vector> associatorTokens; + std::string builderName; edm::ESHandle theTTRHBuilder; std::string dirName_; diff --git a/Validation/RecoTrack/plugins/MultiTrackValidator.cc b/Validation/RecoTrack/plugins/MultiTrackValidator.cc index d71e1ac709155..8e9d736e679b4 100644 --- a/Validation/RecoTrack/plugins/MultiTrackValidator.cc +++ b/Validation/RecoTrack/plugins/MultiTrackValidator.cc @@ -26,6 +26,7 @@ #include "DataFormats/TrackReco/interface/DeDxData.h" #include "DataFormats/Common/interface/ValueMap.h" #include "DataFormats/Common/interface/Ref.h" +#include "CommonTools/Utils/interface/associationMapFilterValues.h" #include @@ -48,9 +49,6 @@ MultiTrackValidator::MultiTrackValidator(const edm::ParameterSet& pset):MultiTra histoProducerAlgo_ = MTVHistoProducerAlgoFactory::get()->create(histoProducerAlgoName ,psetForHistoProducerAlgo, consumesCollector()); dirName_ = pset.getParameter("dirName"); - assMapInput = pset.getParameter< edm::InputTag >("associatormap"); - associatormapStR = mayConsume(assMapInput); - associatormapRtS = mayConsume(assMapInput); UseAssociators = pset.getParameter< bool >("UseAssociators"); m_dEdx1Tag = mayConsume >(pset.getParameter< edm::InputTag >("dEdx1Tag")); @@ -96,15 +94,16 @@ MultiTrackValidator::MultiTrackValidator(const edm::ParameterSet& pset):MultiTra labelTokenForDrCalculation = consumes >(pset.getParameter("trackCollectionForDrCalculation")); - if (!UseAssociators) { - associators.clear(); - associators.push_back(assMapInput.label()); + if(UseAssociators) { + for (auto const& src: associators) { + associatorTokens.push_back(consumes(src)); + } } else { - for (auto const& associatorName : associators) { - consumes(edm::InputTag(associatorName)); + for (auto const& src: associators) { + associatormapStRs.push_back(consumes(src)); + associatormapRtSs.push_back(consumes(src)); } } - } @@ -127,7 +126,7 @@ void MultiTrackValidator::bookHistograms(DQMStore::IBooker& ibook, edm::Run cons if (dirName.find("Tracks") associator; - if (UseAssociators) { - edm::Handle theAssociator; - for (auto const& associatorName : associators) { - event.getByLabel(associatorName,theAssociator); - associator.push_back( theAssociator.product() ); - } - } - edm::ESHandle parametersDefinerTPHandle; setup.get().get(parametersDefiner,parametersDefinerTPHandle); @@ -271,38 +261,47 @@ void MultiTrackValidator::analyze(const edm::Event& event, const edm::EventSetup reco::SimToRecoCollection simRecCollL; //associate tracks + edm::LogVerbatim("TrackValidator") << "Analyzing " + << label[www] << " with " + << associators[ww] <<"\n"; if(UseAssociators){ - edm::LogVerbatim("TrackValidator") << "Analyzing " - << label[www].process()<<":" - << label[www].label()<<":" - << label[www].instance()<<" with " - << associators[ww].c_str() <<"\n"; + edm::Handle theAssociator; + event.getByToken(associatorTokens[ww], theAssociator); LogTrace("TrackValidator") << "Calling associateRecoToSim method" << "\n"; - recSimCollL = std::move(associator[ww]->associateRecoToSim(trackCollection, + recSimCollL = std::move(theAssociator->associateRecoToSim(trackCollection, TPCollectionHfake)); recSimCollP = &recSimCollL; LogTrace("TrackValidator") << "Calling associateSimToReco method" << "\n"; - simRecCollL = std::move(associator[ww]->associateSimToReco(trackCollection, + simRecCollL = std::move(theAssociator->associateSimToReco(trackCollection, TPCollectionHeff)); simRecCollP = &simRecCollL; } else{ - edm::LogVerbatim("TrackValidator") << "Analyzing " - << label[www].process()<<":" - << label[www].label()<<":" - << label[www].instance()<<" with " - << assMapInput.process()<<":" - << assMapInput.label()<<":" - << assMapInput.instance()<<"\n"; - Handle simtorecoCollectionH; - event.getByToken(associatormapStR,simtorecoCollectionH); + event.getByToken(associatormapStRs[ww], simtorecoCollectionH); simRecCollP = simtorecoCollectionH.product(); + // We need to filter the associations of the current track + // collection only from SimToReco collection, otherwise the + // SimToReco histograms get false entries + simRecCollL = associationMapFilterValues(*simRecCollP, *trackCollection); + simRecCollP = &simRecCollL; + Handle recotosimCollectionH; - event.getByToken(associatormapRtS,recotosimCollectionH); + event.getByToken(associatormapRtSs[ww],recotosimCollectionH); recSimCollP = recotosimCollectionH.product(); + + // In general, we should filter also the RecoToSim collection. + // But, that would require changing the input type of TPs to + // View, and either replace current + // associator interfaces with (View, View) or + // adding the View,View interface (same goes for + // RefToBaseVector,RefToBaseVector). Since there is currently + // no compelling-enough use-case, we do not filter the + // RecoToSim collection here. If an association using a subset + // of the Sim collection is needed, user has to produce such + // an association explicitly. } reco::RecoToSimCollection const & recSimColl = *recSimCollP; diff --git a/Validation/RecoTrack/plugins/MultiTrackValidatorGenPs.cc b/Validation/RecoTrack/plugins/MultiTrackValidatorGenPs.cc index 87a0ecf2e5453..e2173478f0a91 100644 --- a/Validation/RecoTrack/plugins/MultiTrackValidatorGenPs.cc +++ b/Validation/RecoTrack/plugins/MultiTrackValidatorGenPs.cc @@ -48,14 +48,20 @@ MultiTrackValidatorGenPs::MultiTrackValidatorGenPs(const edm::ParameterSet& pset pset.getParameter >("pdgIdGP")); if(UseAssociators) { - for(auto const& name: associators) { - if( name == kTrackAssociatorByChi2) { - label_gen_associator = consumes(edm::InputTag(name)); + for(auto const& src: associators) { + if( src.label() == kTrackAssociatorByChi2) { + label_gen_associator = consumes(src); break; } } } - + else { + for (auto const& src: associators) { + associatormapGtR = consumes(src); + associatormapRtG = consumes(src); + break; + } + } } MultiTrackValidatorGenPs::~MultiTrackValidatorGenPs(){} @@ -100,13 +106,20 @@ void MultiTrackValidatorGenPs::analyze(const edm::Event& event, const edm::Event } const reco::TrackToGenParticleAssociator* trackGenAssociator =nullptr; - if(UseAssociators and not label_gen_associator.isUninitialized()) { + if(UseAssociators) { + if(label_gen_associator.isUninitialized()) { + return; + } + else { edm::Handle trackGenAssociatorH; event.getByToken(label_gen_associator,trackGenAssociatorH); trackGenAssociator = trackGenAssociatorH.product(); + } + } + else if(associatormapGtR.isUninitialized()) { + return; } - if ( not trackGenAssociator) { return ; } int w=0; //counter counting the number of sets of histograms for (unsigned int www=0;www gentorecoCollectionH; - event.getByToken(associatormapStR,gentorecoCollectionH); + event.getByToken(associatormapGtR,gentorecoCollectionH); genRecColl= *(gentorecoCollectionH.product()); Handle recotogenCollectionH; - event.getByToken(associatormapRtS,recotogenCollectionH); + event.getByToken(associatormapRtG,recotogenCollectionH); recGenColl= *(recotogenCollectionH.product()); } diff --git a/Validation/RecoTrack/plugins/TrackerSeedValidator.cc b/Validation/RecoTrack/plugins/TrackerSeedValidator.cc index f8e2c20970c0e..0251b1902c80a 100644 --- a/Validation/RecoTrack/plugins/TrackerSeedValidator.cc +++ b/Validation/RecoTrack/plugins/TrackerSeedValidator.cc @@ -57,9 +57,8 @@ TrackerSeedValidator::TrackerSeedValidator(const edm::ParameterSet& pset):MultiT builderName = pset.getParameter("TTRHBuilder"); for (auto const& associator: associators) { - consumes(edm::InputTag(associator)); + associatorTokens.push_back(consumes(associator)); } - } TrackerSeedValidator::~TrackerSeedValidator(){delete histoProducerAlgo_;} @@ -83,7 +82,7 @@ void TrackerSeedValidator::bookHistograms(DQMStore::IBooker& ibook, edm::Run con // if (dirName.find("Seeds") associator; - edm::Handle theAssociator; - for (auto const& associatorName: associators) { - event.getByLabel(associatorName,theAssociator); - associator.push_back( theAssociator.product() ); - } - edm::ESHandle parametersDefinerTP; setup.get().get(parametersDefiner,parametersDefinerTP); @@ -160,12 +152,16 @@ void TrackerSeedValidator::analyze(const edm::Event& event, const edm::EventSetu int w=0; for (unsigned int ww=0;ww theAssociator; + event.getByToken(associatorTokens[ww], theAssociator); + const reco::TrackToTrackingParticleAssociator *associator = theAssociator.product(); + for (unsigned int www=0;wwwassociateRecoToSim(seedCollection, - TPCollectionHfake); + reco::RecoToSimCollectionSeed recSimColl=associator->associateRecoToSim(seedCollection, + TPCollectionHfake); LogTrace("TrackValidator") << "Calling associateSimToReco method" << "\n"; - reco::SimToRecoCollectionSeed simRecColl=associator[ww]->associateSimToReco(seedCollection, - TPCollectionHeff); + reco::SimToRecoCollectionSeed simRecColl=associator->associateSimToReco(seedCollection, + TPCollectionHeff); // //fill simulation histograms diff --git a/Validation/RecoTrack/python/HLTmultiTrackValidator_cff.py b/Validation/RecoTrack/python/HLTmultiTrackValidator_cff.py index 54b3c94e13267..dad704186e83b 100644 --- a/Validation/RecoTrack/python/HLTmultiTrackValidator_cff.py +++ b/Validation/RecoTrack/python/HLTmultiTrackValidator_cff.py @@ -3,52 +3,42 @@ from Validation.RecoTrack.HLTmultiTrackValidator_cfi import * hltPixelTracksV = hltMultiTrackValidator.clone() hltPixelTracksV.label = cms.VInputTag(cms.InputTag("hltPixelTracks")) -hltPixelTracksV.associatormap = cms.InputTag ( "tpToHLTpixelTrackAssociation" ) hltPixelTracksV.trackCollectionForDrCalculation = cms.InputTag("hltPixelTracks") hltIter0V = hltMultiTrackValidator.clone() hltIter0V.label = cms.VInputTag( cms.InputTag("hltIter0PFlowTrackSelectionHighPurity") ) -hltIter0V.associatormap = cms.InputTag( "tpToHLTiter0HPtracksAssociation" ) hltIter0V.trackCollectionForDrCalculation = cms.InputTag("hltIter0PFlowTrackSelectionHighPurity") hltIter1V = hltMultiTrackValidator.clone() hltIter1V.label = cms.VInputTag( cms.InputTag("hltIter1PFlowTrackSelectionHighPurity") ) -hltIter1V.associatormap = cms.InputTag ( "tpToHLTiter1HPtracksAssociation" ) hltIter1V.trackCollectionForDrCalculation = cms.InputTag("hltIter1PFlowTrackSelectionHighPurity") hltIter1MergedV = hltMultiTrackValidator.clone() hltIter1MergedV.label = cms.VInputTag( cms.InputTag("hltIter1Merged") ) -hltIter1MergedV.associatormap = cms.InputTag ( "tpToHLTiter1MergedTracksAssociation" ) hltIter1MergedV.trackCollectionForDrCalculation = cms.InputTag("hltIter1Merged") hltIter2V = hltMultiTrackValidator.clone() hltIter2V.label = cms.VInputTag( cms.InputTag("hltIter2PFlowTrackSelectionHighPurity") ) -hltIter2V.associatormap = cms.InputTag ( "tpToHLTiter2HPtracksAssociation" ) hltIter2V.trackCollectionForDrCalculation = cms.InputTag("hltIter2PFlowTrackSelectionHighPurity") hltIter2MergedV = hltMultiTrackValidator.clone() hltIter2MergedV.label = cms.VInputTag( cms.InputTag("hltIter2Merged") ) -hltIter2MergedV.associatormap = cms.InputTag ("tpToHLTiter2MergedTracksAssociation" ) hltIter2MergedV.trackCollectionForDrCalculation = cms.InputTag("hltIter2Merged") hltIter3V = hltMultiTrackValidator.clone() hltIter3V.label = cms.VInputTag( cms.InputTag("hltIter3PFlowTrackSelectionHighPurity") ) -hltIter3V.associatormap = cms.InputTag( "tpToHLTiter3HPtracksAssociation" ) hltIter3V.trackCollectionForDrCalculation = cms.InputTag("hltIter3PFlowTrackSelectionHighPurity") hltIter3MergedV = hltMultiTrackValidator.clone() hltIter3MergedV.label = cms.VInputTag( cms.InputTag("hltIter3Merged") ) -hltIter3MergedV.associatormap = cms.InputTag ( "tpToHLTiter3MergedTracksAssociation" ) hltIter3MergedV.trackCollectionForDrCalculation = cms.InputTag("hltIter3Merged") hltIter4V = hltMultiTrackValidator.clone() hltIter4V.label = cms.VInputTag( cms.InputTag("hltIter4PFlowTrackSelectionHighPurity") ) -hltIter4V.associatormap = cms.InputTag( "tpToHLTiter4HPtracksAssociation" ) hltIter4V.trackCollectionForDrCalculation = cms.InputTag("hltIter4PFlowTrackSelectionHighPurity") hltIter4MergedV = hltMultiTrackValidator.clone() hltIter4MergedV.label = cms.VInputTag( cms.InputTag("hltIter4Merged") ) -hltIter4MergedV.associatormap = cms.InputTag ( "tpToHLTiter4MergedTracksAssociation" ) hltIter4MergedV.trackCollectionForDrCalculation = cms.InputTag("hltIter4Merged") from Validation.RecoTrack.cutsTPEffic_cfi import * @@ -60,7 +50,8 @@ # simHitTPAssocProducer # + hltTPClusterProducer - + tpToHLTtracksAssociationSequence +# + tpToHLTtracksAssociationSequence # not needed because MTV is configured to use the associators in itself, instead we need the hltTrackAssociatorByHits + + hltTrackAssociatorByHits + cms.ignore(cutsTPEffic) + cms.ignore(cutsTPFake) + hltPixelTracksV diff --git a/Validation/RecoTrack/python/HLTmultiTrackValidator_cfi.py b/Validation/RecoTrack/python/HLTmultiTrackValidator_cfi.py index b65d119549751..1194f084078b8 100644 --- a/Validation/RecoTrack/python/HLTmultiTrackValidator_cfi.py +++ b/Validation/RecoTrack/python/HLTmultiTrackValidator_cfi.py @@ -28,7 +28,7 @@ #hltMultiTrackValidator.parametersDefiner = cms.string('LhcParametersDefinerForTP') ### for fake rate vs dR ### hltMultiTrackValidator.trackCollectionForDrCalculation = cms.InputTag("hltPixelTracks") -hltMultiTrackValidator.associatormap = cms.InputTag("tpToHLTpixelTrackAssociation") hltMultiTrackValidator.ignoremissingtrackcollection = cms.untracked.bool(True) -hltMultiTrackValidator.associators = cms.vstring('hltTrackAssociatorByHits') +hltMultiTrackValidator.UseAssociators = True +hltMultiTrackValidator.associators = ['hltTrackAssociatorByHits'] diff --git a/Validation/RecoTrack/python/MultiTrackValidatorGenPs_cfi.py b/Validation/RecoTrack/python/MultiTrackValidatorGenPs_cfi.py index f8266679b94ec..4defb97ac2920 100644 --- a/Validation/RecoTrack/python/MultiTrackValidatorGenPs_cfi.py +++ b/Validation/RecoTrack/python/MultiTrackValidatorGenPs_cfi.py @@ -32,11 +32,7 @@ ### matching configuration ### - associatormap = cms.InputTag("trackingParticleRecoTrackAsssociation"), - #associatormap = cms.InputTag("assoc2secStepTk"), - #associatormap = cms.InputTag("assoc2thStepTk"), - #associatormap = cms.InputTag("assoc2GsfTracks"), - associators = cms.vstring('TrackAssociatorByChi2'), + associators = cms.untracked.VInputTag("TrackAssociatorByChi2"), UseAssociators = cms.bool(True), # if False, the TP-RecoTrack maps has to be specified ### sim input configuration ### diff --git a/Validation/RecoTrack/python/MultiTrackValidator_cfi.py b/Validation/RecoTrack/python/MultiTrackValidator_cfi.py index 234e81aad370a..62627bf3850b7 100644 --- a/Validation/RecoTrack/python/MultiTrackValidator_cfi.py +++ b/Validation/RecoTrack/python/MultiTrackValidator_cfi.py @@ -29,12 +29,13 @@ ### matching configuration ### - associatormap = cms.InputTag("trackingParticleRecoTrackAsssociation"), - #associatormap = cms.InputTag("assoc2secStepTk"), - #associatormap = cms.InputTag("assoc2thStepTk"), - #associatormap = cms.InputTag("assoc2GsfTracks"), - associators = cms.vstring('trackAssociatorByHitsRecoDenom'), - UseAssociators = cms.bool(True), # if False, the TP-RecoTrack maps has to be specified + # Example of TP-Track map + associators = cms.untracked.VInputTag("trackingParticleRecoTrackAsssociation"), + # Example of associator + #associators = cms.untracked.VInputTag("quickTrackAssociatorByHits"), + # if False, the src's above should specify the TP-RecoTrack association + # if True, the src's above should specify the associator + UseAssociators = cms.bool(False), ### sim input configuration ### label_tp_effic = cms.InputTag("mix","MergedTrackTruth"), diff --git a/Validation/RecoTrack/python/TrackValidation_cff.py b/Validation/RecoTrack/python/TrackValidation_cff.py index 8df31638cdb6c..4e2e8fad9d10a 100644 --- a/Validation/RecoTrack/python/TrackValidation_cff.py +++ b/Validation/RecoTrack/python/TrackValidation_cff.py @@ -1,117 +1,115 @@ import FWCore.ParameterSet.Config as cms import SimTracker.TrackAssociatorProducers.trackAssociatorByChi2_cfi -import SimTracker.TrackAssociatorProducers.quickTrackAssociatorByHits_cfi +from SimTracker.TrackAssociatorProducers.quickTrackAssociatorByHits_cfi import * +from SimTracker.TrackAssociation.trackingParticleRecoTrackAsssociation_cfi import * import Validation.RecoTrack.MultiTrackValidator_cfi from SimTracker.TrackAssociation.LhcParametersDefinerForTP_cfi import * from SimTracker.TrackAssociation.CosmicParametersDefinerForTP_cfi import * from Validation.RecoTrack.PostProcessorTracker_cfi import * -import PhysicsTools.RecoAlgos.recoTrackSelector_cfi +import cutsRecoTracks_cfi from SimTracker.TrackerHitAssociation.clusterTpAssociationProducer_cfi import * -trackAssociatorByHitsRecoDenom= SimTracker.TrackAssociatorProducers.quickTrackAssociatorByHits_cfi.quickTrackAssociatorByHits.clone( - ) - # Validation iterative steps -cutsRecoTracksZero = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksZero.algorithm=cms.vstring("initialStep") +cutsRecoTracksInitialStep = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksInitialStep.algorithm=cms.vstring("initialStep") -cutsRecoTracksFirst = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksFirst.algorithm=cms.vstring("lowPtTripletStep") +cutsRecoTracksLowPtTripletStep = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksLowPtTripletStep.algorithm=cms.vstring("lowPtTripletStep") -cutsRecoTracksSecond = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksSecond.algorithm=cms.vstring("pixelPairStep") +cutsRecoTracksPixelPairStep = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksPixelPairStep.algorithm=cms.vstring("pixelPairStep") -cutsRecoTracksThird = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksThird.algorithm=cms.vstring("detachedTripletStep") +cutsRecoTracksDetachedTripletStep = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksDetachedTripletStep.algorithm=cms.vstring("detachedTripletStep") -cutsRecoTracksFourth = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksFourth.algorithm=cms.vstring("mixedTripletStep") +cutsRecoTracksMixedTripletStep = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksMixedTripletStep.algorithm=cms.vstring("mixedTripletStep") -cutsRecoTracksFifth = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksFifth.algorithm=cms.vstring("pixelLessStep") +cutsRecoTracksPixelLessStep = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksPixelLessStep.algorithm=cms.vstring("pixelLessStep") -cutsRecoTracksSixth = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksSixth.algorithm=cms.vstring("tobTecStep") +cutsRecoTracksTobTecStep = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksTobTecStep.algorithm=cms.vstring("tobTecStep") -cutsRecoTracksSeventh = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksSeventh.algorithm=cms.vstring("jetCoreRegionalStep") +cutsRecoTracksJetCoreRegionalStep = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksJetCoreRegionalStep.algorithm=cms.vstring("jetCoreRegionalStep") -cutsRecoTracksNinth = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksNinth.algorithm=cms.vstring("muonSeededStepInOut") +cutsRecoTracksMuonSeededStepInOut = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksMuonSeededStepInOut.algorithm=cms.vstring("muonSeededStepInOut") -cutsRecoTracksTenth = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksTenth.algorithm=cms.vstring("muonSeededStepOutIn") +cutsRecoTracksMuonSeededStepOutIn = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksMuonSeededStepOutIn.algorithm=cms.vstring("muonSeededStepOutIn") # high purity -cutsRecoTracksHp = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() +cutsRecoTracksHp = cutsRecoTracks_cfi.cutsRecoTracks.clone() cutsRecoTracksHp.quality=cms.vstring("highPurity") -cutsRecoTracksZeroHp = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksZeroHp.algorithm=cms.vstring("initialStep") -cutsRecoTracksZeroHp.quality=cms.vstring("highPurity") +cutsRecoTracksInitialStepHp = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksInitialStepHp.algorithm=cms.vstring("initialStep") +cutsRecoTracksInitialStepHp.quality=cms.vstring("highPurity") -cutsRecoTracksFirstHp = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksFirstHp.algorithm=cms.vstring("lowPtTripletStep") -cutsRecoTracksFirstHp.quality=cms.vstring("highPurity") +cutsRecoTracksLowPtTripletStepHp = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksLowPtTripletStepHp.algorithm=cms.vstring("lowPtTripletStep") +cutsRecoTracksLowPtTripletStepHp.quality=cms.vstring("highPurity") -cutsRecoTracksSecondHp = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksSecondHp.algorithm=cms.vstring("pixelPairStep") -cutsRecoTracksSecondHp.quality=cms.vstring("highPurity") +cutsRecoTracksPixelPairStepHp = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksPixelPairStepHp.algorithm=cms.vstring("pixelPairStep") +cutsRecoTracksPixelPairStepHp.quality=cms.vstring("highPurity") -cutsRecoTracksThirdHp = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksThirdHp.algorithm=cms.vstring("detachedTripletStep") -cutsRecoTracksThirdHp.quality=cms.vstring("highPurity") +cutsRecoTracksDetachedTripletStepHp = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksDetachedTripletStepHp.algorithm=cms.vstring("detachedTripletStep") +cutsRecoTracksDetachedTripletStepHp.quality=cms.vstring("highPurity") -cutsRecoTracksFourthHp = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksFourthHp.algorithm=cms.vstring("mixedTripletStep") -cutsRecoTracksFourthHp.quality=cms.vstring("highPurity") +cutsRecoTracksMixedTripletStepHp = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksMixedTripletStepHp.algorithm=cms.vstring("mixedTripletStep") +cutsRecoTracksMixedTripletStepHp.quality=cms.vstring("highPurity") -cutsRecoTracksFifthHp = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksFifthHp.algorithm=cms.vstring("pixelLessStep") -cutsRecoTracksFifthHp.quality=cms.vstring("highPurity") +cutsRecoTracksPixelLessStepHp = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksPixelLessStepHp.algorithm=cms.vstring("pixelLessStep") +cutsRecoTracksPixelLessStepHp.quality=cms.vstring("highPurity") -cutsRecoTracksSixthHp = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksSixthHp.algorithm=cms.vstring("tobTecStep") -cutsRecoTracksSixthHp.quality=cms.vstring("highPurity") +cutsRecoTracksTobTecStepHp = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksTobTecStepHp.algorithm=cms.vstring("tobTecStep") +cutsRecoTracksTobTecStepHp.quality=cms.vstring("highPurity") -cutsRecoTracksSeventhHp = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksSeventhHp.algorithm=cms.vstring("jetCoreRegionalStep") -cutsRecoTracksSeventhHp.quality=cms.vstring("highPurity") +cutsRecoTracksJetCoreRegionalStepHp = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksJetCoreRegionalStepHp.algorithm=cms.vstring("jetCoreRegionalStep") +cutsRecoTracksJetCoreRegionalStepHp.quality=cms.vstring("highPurity") -cutsRecoTracksNinthHp = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksNinthHp.algorithm=cms.vstring("muonSeededStepInOut") -cutsRecoTracksNinthHp.quality=cms.vstring("highPurity") +cutsRecoTracksMuonSeededStepInOutHp = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksMuonSeededStepInOutHp.algorithm=cms.vstring("muonSeededStepInOut") +cutsRecoTracksMuonSeededStepInOutHp.quality=cms.vstring("highPurity") -cutsRecoTracksTenthHp = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() -cutsRecoTracksTenthHp.algorithm=cms.vstring("muonSeededStepOutIn") -cutsRecoTracksTenthHp.quality=cms.vstring("highPurity") +cutsRecoTracksMuonSeededStepOutInHp = cutsRecoTracks_cfi.cutsRecoTracks.clone() +cutsRecoTracksMuonSeededStepOutInHp.algorithm=cms.vstring("muonSeededStepOutIn") +cutsRecoTracksMuonSeededStepOutInHp.quality=cms.vstring("highPurity") trackValidator= Validation.RecoTrack.MultiTrackValidator_cfi.multiTrackValidator.clone() trackValidator.label=cms.VInputTag(cms.InputTag("generalTracks"), cms.InputTag("cutsRecoTracksHp"), - cms.InputTag("cutsRecoTracksZero"), - cms.InputTag("cutsRecoTracksZeroHp"), - cms.InputTag("cutsRecoTracksFirst"), - cms.InputTag("cutsRecoTracksFirstHp"), - cms.InputTag("cutsRecoTracksSecond"), - cms.InputTag("cutsRecoTracksSecondHp"), - cms.InputTag("cutsRecoTracksThird"), - cms.InputTag("cutsRecoTracksThirdHp"), - cms.InputTag("cutsRecoTracksFourth"), - cms.InputTag("cutsRecoTracksFourthHp"), - cms.InputTag("cutsRecoTracksFifth"), - cms.InputTag("cutsRecoTracksFifthHp"), - cms.InputTag("cutsRecoTracksSixth"), - cms.InputTag("cutsRecoTracksSixthHp"), - cms.InputTag("cutsRecoTracksSeventh"), - cms.InputTag("cutsRecoTracksSeventhHp"), - cms.InputTag("cutsRecoTracksNinth"), - cms.InputTag("cutsRecoTracksNinthHp"), - cms.InputTag("cutsRecoTracksTenth"), - cms.InputTag("cutsRecoTracksTenthHp"), + cms.InputTag("cutsRecoTracksInitialStep"), + cms.InputTag("cutsRecoTracksInitialStepHp"), + cms.InputTag("cutsRecoTracksLowPtTripletStep"), + cms.InputTag("cutsRecoTracksLowPtTripletStepHp"), + cms.InputTag("cutsRecoTracksPixelPairStep"), + cms.InputTag("cutsRecoTracksPixelPairStepHp"), + cms.InputTag("cutsRecoTracksDetachedTripletStep"), + cms.InputTag("cutsRecoTracksDetachedTripletStepHp"), + cms.InputTag("cutsRecoTracksMixedTripletStep"), + cms.InputTag("cutsRecoTracksMixedTripletStepHp"), + cms.InputTag("cutsRecoTracksPixelLessStep"), + cms.InputTag("cutsRecoTracksPixelLessStepHp"), + cms.InputTag("cutsRecoTracksTobTecStep"), + cms.InputTag("cutsRecoTracksTobTecStepHp"), + cms.InputTag("cutsRecoTracksJetCoreRegionalStep"), + cms.InputTag("cutsRecoTracksJetCoreRegionalStepHp"), + cms.InputTag("cutsRecoTracksMuonSeededStepInOut"), + cms.InputTag("cutsRecoTracksMuonSeededStepInOutHp"), + cms.InputTag("cutsRecoTracksMuonSeededStepOutIn"), + cms.InputTag("cutsRecoTracksMuonSeededStepOutInHp"), ) trackValidator.skipHistoFit=cms.untracked.bool(True) trackValidator.useLogPt=cms.untracked.bool(True) @@ -121,28 +119,46 @@ # the track selectors tracksValidationSelectors = cms.Sequence( cutsRecoTracksHp* - cutsRecoTracksZero* - cutsRecoTracksZeroHp* - cutsRecoTracksFirst* - cutsRecoTracksFirstHp* - cutsRecoTracksSecond* - cutsRecoTracksSecondHp* - cutsRecoTracksThird* - cutsRecoTracksThirdHp* - cutsRecoTracksFourth* - cutsRecoTracksFourthHp* - cutsRecoTracksFifth* - cutsRecoTracksFifthHp* - cutsRecoTracksSixth* - cutsRecoTracksSixthHp* - cutsRecoTracksSeventh* - cutsRecoTracksSeventhHp* - cutsRecoTracksNinth* - cutsRecoTracksNinthHp* - cutsRecoTracksTenth* - cutsRecoTracksTenthHp ) + cutsRecoTracksInitialStep* + cutsRecoTracksInitialStepHp* + cutsRecoTracksLowPtTripletStep* + cutsRecoTracksLowPtTripletStepHp* + cutsRecoTracksPixelPairStep* + cutsRecoTracksPixelPairStepHp* + cutsRecoTracksDetachedTripletStep* + cutsRecoTracksDetachedTripletStepHp* + cutsRecoTracksMixedTripletStep* + cutsRecoTracksMixedTripletStepHp* + cutsRecoTracksPixelLessStep* + cutsRecoTracksPixelLessStepHp* + cutsRecoTracksTobTecStep* + cutsRecoTracksTobTecStepHp* + cutsRecoTracksJetCoreRegionalStep* + cutsRecoTracksJetCoreRegionalStepHp* + cutsRecoTracksMuonSeededStepInOut* + cutsRecoTracksMuonSeededStepInOutHp* + cutsRecoTracksMuonSeededStepOutIn* + cutsRecoTracksMuonSeededStepOutInHp ) +tracksValidationTruth = cms.Sequence( + tpClusterProducer + + quickTrackAssociatorByHits + + trackingParticleRecoTrackAsssociation +) +tracksValidationTruthFS = cms.Sequence( + quickTrackAssociatorByHits + + trackingParticleRecoTrackAsssociation +) + +tracksPreValidation = cms.Sequence( + tracksValidationSelectors + + tracksValidationTruth +) +tracksPreValidationFS = cms.Sequence( + tracksValidationSelectors + + tracksValidationTruthFS +) # selectors go into separate "prevalidation" sequence -tracksValidation = cms.Sequence( tpClusterProducer * trackAssociatorByHitsRecoDenom * trackValidator) -tracksValidationFS = cms.Sequence( trackAssociatorByHitsRecoDenom * trackValidator ) +tracksValidation = cms.Sequence( trackValidator) +tracksValidationFS = cms.Sequence( trackValidator ) diff --git a/Validation/RecoTrack/python/TrackValidation_fastsim_cff.py b/Validation/RecoTrack/python/TrackValidation_fastsim_cff.py index 7322f5e52e287..be28337872e40 100644 --- a/Validation/RecoTrack/python/TrackValidation_fastsim_cff.py +++ b/Validation/RecoTrack/python/TrackValidation_fastsim_cff.py @@ -1,11 +1,11 @@ import FWCore.ParameterSet.Config as cms -from SimTracker.TrackAssociatorProducers.trackAssociatorByHits_cfi import * +from SimTracker.TrackAssociatorProducers.quickTrackAssociatorByHits_cfi import * from Validation.RecoTrack.TrackValidation_cff import * -trackAssociatorByHitsRecoDenom.associateStrip = False -trackAssociatorByHitsRecoDenom.associatePixel = False +quickTrackAssociatorByHits.associateStrip = False +quickTrackAssociatorByHits.associatePixel = False +quickTrackAssociatorByHits.useClusterTPAssociation = False #TrackAssociatorByHitsRecoDenom.ROUList = ['famosSimHitsTrackerHits'] -trackValidator.UseAssociators = True trackValidator.skipHistoFit=cms.untracked.bool(True) trackValidator.useLogPt=cms.untracked.bool(True) diff --git a/Validation/RecoTrack/python/TrackerSeedValidator_cfi.py b/Validation/RecoTrack/python/TrackerSeedValidator_cfi.py index f988e7b717721..4bc1a040824d1 100644 --- a/Validation/RecoTrack/python/TrackerSeedValidator_cfi.py +++ b/Validation/RecoTrack/python/TrackerSeedValidator_cfi.py @@ -24,7 +24,7 @@ runStandalone = cms.bool(True), ### matching configuration ### - associators = cms.vstring('trackAssociatorByHits'), + associators = cms.VInputTag("trackAssociatorByHits"), ### sim input configuration ### label_tp_effic = cms.InputTag("mix","MergedTrackTruth"), diff --git a/Validation/RecoTrack/python/cutsRecoTracks_cfi.py b/Validation/RecoTrack/python/cutsRecoTracks_cfi.py index 0bb93c143ee7a..c28973840457f 100644 --- a/Validation/RecoTrack/python/cutsRecoTracks_cfi.py +++ b/Validation/RecoTrack/python/cutsRecoTracks_cfi.py @@ -1,4 +1,4 @@ import FWCore.ParameterSet.Config as cms -import PhysicsTools.RecoAlgos.recoTrackSelector_cfi -cutsRecoTracks = PhysicsTools.RecoAlgos.recoTrackSelector_cfi.recoTrackSelector.clone() +import CommonTools.RecoAlgos.recoTrackRefSelector_cfi +cutsRecoTracks = CommonTools.RecoAlgos.recoTrackRefSelector_cfi.recoTrackRefSelector.clone() diff --git a/Validation/RecoTrack/python/plotting/trackingPlots.py b/Validation/RecoTrack/python/plotting/trackingPlots.py index 345b202c451bd..4b2c29d3c2321 100644 --- a/Validation/RecoTrack/python/plotting/trackingPlots.py +++ b/Validation/RecoTrack/python/plotting/trackingPlots.py @@ -282,30 +282,30 @@ _tracks_map = { '': { # all tracks - 'ootb': 'general_trackAssociatorByHitsRecoDenom', - 'iter0': 'cutsRecoZero_trackAssociatorByHitsRecoDenom', - 'iter1': 'cutsRecoFirst_trackAssociatorByHitsRecoDenom', - 'iter2': 'cutsRecoSecond_trackAssociatorByHitsRecoDenom', - 'iter3': 'cutsRecoThird_trackAssociatorByHitsRecoDenom', - 'iter4': 'cutsRecoFourth_trackAssociatorByHitsRecoDenom', - 'iter5': 'cutsRecoFifth_trackAssociatorByHitsRecoDenom', - 'iter6': 'cutsRecoSixth_trackAssociatorByHitsRecoDenom', - 'iter7': 'cutsRecoSeventh_trackAssociatorByHitsRecoDenom', - 'iter9': 'cutsRecoNinth_trackAssociatorByHitsRecoDenom', - 'iter10':'cutsRecoTenth_trackAssociatorByHitsRecoDenom' + 'ootb' : 'general_trackingParticleRecoAsssociation', + 'initialStep' : 'cutsRecoInitialStep_trackingParticleRecoAsssociation', + 'lowPtTripletStep' : 'cutsRecoLowPtTripletStep_trackingParticleRecoAsssociation', + 'pixelPairStep' : 'cutsRecoPixelPairStep_trackingParticleRecoAsssociation', + 'detachedTripletStep' : 'cutsRecoDetachedTripletStep_trackingParticleRecoAsssociation', + 'mixedTripletStep' : 'cutsRecoMixedTripletStep_trackingParticleRecoAsssociation', + 'pixelLessStep' : 'cutsRecoPixelLessStep_trackingParticleRecoAsssociation', + 'tobTecStep' : 'cutsRecoTobTecStep_trackingParticleRecoAsssociation', + 'jetCoreRegionalStep' : 'cutsRecoJetCoreRegionalStep_trackingParticleRecoAsssociation', + 'muonSeededStepInOut' : 'cutsRecoMuonSeededStepInOut_trackingParticleRecoAsssociation', + 'muonSeededStepOutIn' : 'cutsRecoMuonSeededStepOutIn_trackingParticleRecoAsssociation' }, "highPurity": { - 'ootb': 'cutsRecoHp_trackAssociatorByHitsRecoDenom', - 'iter0': 'cutsRecoZeroHp_trackAssociatorByHitsRecoDenom', - 'iter1': 'cutsRecoFirstHp_trackAssociatorByHitsRecoDenom', - 'iter2': 'cutsRecoSecondHp_trackAssociatorByHitsRecoDenom', - 'iter3': 'cutsRecoThirdHp_trackAssociatorByHitsRecoDenom', - 'iter4': 'cutsRecoFourthHp_trackAssociatorByHitsRecoDenom', - 'iter5': 'cutsRecoFifthHp_trackAssociatorByHitsRecoDenom', - 'iter6': 'cutsRecoSixthHp_trackAssociatorByHitsRecoDenom', - 'iter7': 'cutsRecoSeventhHp_trackAssociatorByHitsRecoDenom', - 'iter9': 'cutsRecoNinthHp_trackAssociatorByHitsRecoDenom', - 'iter10': 'cutsRecoTenthHp_trackAssociatorByHitsRecoDenom' + 'ootb' : 'cutsRecoHp_trackingParticleRecoAsssociation', + 'initialStep' : 'cutsRecoInitialStepHp_trackingParticleRecoAsssociation', + 'lowPtTripletStep' : 'cutsRecoLowPtTripletStepHp_trackingParticleRecoAsssociation', + 'pixelPairStep' : 'cutsRecoPixelPairStepHp_trackingParticleRecoAsssociation', + 'detachedTripletStep' : 'cutsRecoDetachedTripletStepHp_trackingParticleRecoAsssociation', + 'mixedTripletStep' : 'cutsRecoMixedTripletStepHp_trackingParticleRecoAsssociation', + 'pixelLessStep' : 'cutsRecoPixelLessStepHp_trackingParticleRecoAsssociation', + 'tobTecStep' : 'cutsRecoTobTecStepHp_trackingParticleRecoAsssociation', + 'jetCoreRegionalStep' : 'cutsRecoJetCoreRegionalStepHp_trackingParticleRecoAsssociation', + 'muonSeededStepInOut' : 'cutsRecoMuonSeededStepInOutHp_trackingParticleRecoAsssociation', + 'muonSeededStepOutIn' : 'cutsRecoMuonSeededStepOutInHp_trackingParticleRecoAsssociation' } } diff --git a/Validation/RecoTrack/src/MultiTrackValidatorBase.cc b/Validation/RecoTrack/src/MultiTrackValidatorBase.cc index e0a8301db1f7d..6cff7e5e2e605 100644 --- a/Validation/RecoTrack/src/MultiTrackValidatorBase.cc +++ b/Validation/RecoTrack/src/MultiTrackValidatorBase.cc @@ -3,7 +3,7 @@ MultiTrackValidatorBase::MultiTrackValidatorBase(const edm::ParameterSet& pset, edm::ConsumesCollector && iC, bool isSeed){ //dbe_ = edm::Service().operator->(); - associators = pset.getParameter< std::vector >("associators"); + associators = pset.getUntrackedParameter< std::vector >("associators"); label_tp_effic = iC.consumes(pset.getParameter< edm::InputTag >("label_tp_effic")); label_tp_fake = iC.consumes(pset.getParameter< edm::InputTag >("label_tp_fake")); label_tv = iC.mayConsume(pset.getParameter< edm::InputTag >("label_tv")); diff --git a/Validation/RecoTrack/test/SeedValidator_cfg.py b/Validation/RecoTrack/test/SeedValidator_cfg.py index 9e9e0a41d969e..53be4d2179455 100644 --- a/Validation/RecoTrack/test/SeedValidator_cfg.py +++ b/Validation/RecoTrack/test/SeedValidator_cfg.py @@ -66,7 +66,7 @@ process.load("Validation.RecoTrack.cuts_cff") process.load("Validation.RecoTrack.TrackerSeedValidator_cff") -process.trackerSeedValidator.associators = cms.vstring('trackAssociatorByHits') +process.trackerSeedValidator.associators = ['trackAssociatorByHits'] process.trackerSeedValidator.label = ['initialStepSeeds'] process.trackerSeedValidator.outputFile = 'file.root' diff --git a/Validation/RecoTrack/test/trackingCompare.py b/Validation/RecoTrack/test/trackingCompare.py index 217d00145b9e7..e229e9ae443c1 100755 --- a/Validation/RecoTrack/test/trackingCompare.py +++ b/Validation/RecoTrack/test/trackingCompare.py @@ -18,7 +18,7 @@ outputDir = "plots" ### Track algorithm name and quality. Can be a list. -Algos= ['ootb', 'iter0', 'iter1','iter2','iter3','iter4','iter5','iter6','iter7','iter9','iter10'] +Algos= ['ootb', 'initialStep', 'lowPtTripletStep','pixelPairStep','detachedTripletStep','mixedTripletStep','pixelLessStep','tobTecStep','jetCoreRegionalStep','muonSeededStepInOut','muonSeededStepOutIn'] #Algos= ['ootb'] Qualities=['', 'highPurity'] diff --git a/Validation/RecoTrack/test/trackingPerformanceValidation.py b/Validation/RecoTrack/test/trackingPerformanceValidation.py index acae15cddaff6..a93cdfdeb1bed 100755 --- a/Validation/RecoTrack/test/trackingPerformanceValidation.py +++ b/Validation/RecoTrack/test/trackingPerformanceValidation.py @@ -11,7 +11,7 @@ RefRelease='CMSSW_7_4_0_pre6' ### Relval release (set if different from $CMSSW_VERSION) -RefRelease='CMSSW_7_4_0_pre8' +NewRelease='CMSSW_7_4_0_pre8' #import Validation.RecoTrack.plotting.plotting as plotting #plotting.missingOk = True @@ -33,7 +33,7 @@ pileupstartupsamples = [ Sample('RelValTTbar', putype="25ns", midfix="13"), - Sample('RelValTTbar', putype="50ns", midfix="13") + Sample('RelValTTbar', putype="50ns", midfix="13"), Sample('RelValZMM', putype="25ns", midfix="13"), Sample('RelValZMM', putype="50ns", midfix="13") ] @@ -67,7 +67,7 @@ ] ### Track algorithm name and quality. Can be a list. -Algos= ['ootb', 'iter0', 'iter1','iter2','iter3','iter4','iter5','iter6','iter7','iter9','iter10'] +Algos= ['ootb', 'initialStep', 'lowPtTripletStep','pixelPairStep','detachedTripletStep','mixedTripletStep','pixelLessStep','tobTecStep','jetCoreRegionalStep','muonSeededStepInOut','muonSeededStepOutIn'] #Algos= ['ootb'] Qualities=['', 'highPurity'] diff --git a/Validation/RecoVertex/README.md b/Validation/RecoVertex/README.md index 6f9fb77309606..491fac3f86e0c 100644 --- a/Validation/RecoVertex/README.md +++ b/Validation/RecoVertex/README.md @@ -70,7 +70,7 @@ command that will dynamically prepare it for you. To obtain such a cfg file, issue the following command: ``` -cmsDriver.py step3 --conditions auto:run2_mc -n 100 --eventcontent DQM -s RAW2DIGI,RECO,VALIDATION:vertexValidation --datatier DQMIO --filein filelist:gen_sim_digi_raw_files.txt --fileout step3_VertexValidation.root --customise SLHCUpgradeSimulations/Configuration/postLS1Customs.customisePostLS1 --magField 38T_PostLS1 +cmsDriver.py step3 --conditions auto:run2_mc -n 100 --eventcontent DQM -s RAW2DIGI,RECO,VALIDATION:vertexValidationStandalone --datatier DQMIO --filein filelist:gen_sim_digi_raw_files.txt --fileout step3_VertexValidation.root --customise SLHCUpgradeSimulations/Configuration/postLS1Customs.customisePostLS1 --magField 38T_PostLS1 ``` This will create the python configuration file **and will @@ -102,7 +102,7 @@ das_client.py --limit 0 --query='file dataset=/RelValTTbar_13/CMSSW_7_2_0_pre1-P The configuration can then be generated with ``` -cmsDriver.py step3 --conditions auto:run2_mc -n 100 --eventcontent DQM -s VALIDATION:vertexValidation --datatier DQMIO --filein filelist:gen_sim_reco_files.txt --secondfilein filelist:gen_sim_digi_raw_files.txt --fileout step3_VertexValidation.root --customise SLHCUpgradeSimulations/Configuration/postLS1Customs.customisePostLS1 --magField 38T_PostLS1 --no_exec +cmsDriver.py step3 --conditions auto:run2_mc -n 100 --eventcontent DQM -s VALIDATION:vertexValidationStandalone --datatier DQMIO --filein filelist:gen_sim_reco_files.txt --secondfilein filelist:gen_sim_digi_raw_files.txt --fileout step3_VertexValidation.root --customise SLHCUpgradeSimulations/Configuration/postLS1Customs.customisePostLS1 --magField 38T_PostLS1 --no_exec ``` Note the `secondfilein` parameter for specifying the RAW files for the diff --git a/Validation/RecoVertex/python/VertexValidation_cff.py b/Validation/RecoVertex/python/VertexValidation_cff.py index a982bba82f250..ff05e85ff0cd9 100644 --- a/Validation/RecoVertex/python/VertexValidation_cff.py +++ b/Validation/RecoVertex/python/VertexValidation_cff.py @@ -1,12 +1,15 @@ import FWCore.ParameterSet.Config as cms -from SimTracker.TrackAssociation.trackingParticleRecoTrackAsssociation_cfi import * -from SimTracker.TrackAssociatorProducers.quickTrackAssociatorByHits_cfi import * from Validation.RecoVertex.v0validator_cfi import * from Validation.RecoVertex.PrimaryVertexAnalyzer4PUSlimmed_cfi import * -vertexValidation = cms.Sequence(quickTrackAssociatorByHits - * trackingParticleRecoTrackAsssociation - * v0Validator +# Rely on tracksValidationTruth sequence being already run +vertexValidation = cms.Sequence(v0Validator * vertexAnalysisSequence) + +from Validation.RecoTrack.TrackValidation_cff import tracksValidationTruth +vertexValidationStandalone = cms.Sequence( + tracksValidationTruth + * vertexValidation +)