From fa35b42b884c83f50e89b13a546100deb12533fa Mon Sep 17 00:00:00 2001 From: Andreas Pfeiffer Date: Tue, 24 Feb 2015 12:00:23 +0100 Subject: [PATCH 01/22] 74x version of added ctors to fix failing unit-test in root6 branch --- CondFormats/L1TObjects/interface/CaloParams.h | 20 ++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/CondFormats/L1TObjects/interface/CaloParams.h b/CondFormats/L1TObjects/interface/CaloParams.h index a7837ee52ccca..13fe5d43d5073 100644 --- a/CondFormats/L1TObjects/interface/CaloParams.h +++ b/CondFormats/L1TObjects/interface/CaloParams.h @@ -82,6 +82,12 @@ namespace l1t { // turn encoding on/off bool doEncoding_; + TowerParams() : lsbH_(0), lsbE_(0), lsbSum_(0), + nBitsH_(0), nBitsE_(0), nBitsSum_(0), nBitsRatio_(0), + maskH_(0), maskE_(0), maskSum_(0), maskRatio_(0), + doEncoding_(false) + { /* no-op */} + COND_SERIALIZABLE; }; @@ -122,6 +128,11 @@ namespace l1t { // veto region is seed tower +/- <=egIsoVetoNrTowersPhi unsigned isoVetoNrTowersPhi_; + EgParams() : lsb_(0), seedThreshold_(0), neighbourThreshold_(0), hcalThreshold_(0), maxHcalEt_(0), maxPtHOverE_(0), + minPtJetIsolation_(0), maxPtJetIsolation_(0), minPtHOverEIsolation_(0), maxPtHOverEIsolation_(0), + isoAreaNrTowersEta_(0), isoAreaNrTowersPhi_(0), isoVetoNrTowersPhi_(0) + { /* no-op */ } + COND_SERIALIZABLE; }; @@ -162,6 +173,12 @@ namespace l1t { // veto region is seed tower +/- <=tauIsoVetoNrTowersPhi unsigned isoVetoNrTowersPhi_; + TauParams() : lsb_(0), seedThreshold_(0), neighbourThreshold_(0), maxPtTauVeto_(0), + minPtJetIsolationB_(0), maxJetIsolationB_(0), maxJetIsolationA_(0), + isoEtaMin_(0), isoEtaMax_(0), + isoAreaNrTowersEta_(0), isoAreaNrTowersPhi_(0), isoVetoNrTowersPhi_(0) + { /* no-op */ } + COND_SERIALIZABLE; }; @@ -176,6 +193,8 @@ namespace l1t { // Et threshold on neighbouring towers/regions double neighbourThreshold_; + JetParams() : lsb_(0), seedThreshold_(0), neighbourThreshold_(0) { /* no-op */ } + COND_SERIALIZABLE; }; @@ -368,7 +387,6 @@ namespace l1t { void print(std::ostream&) const; friend std::ostream& operator<<(std::ostream& o, const CaloParams & p) { p.print(o); return o; } - private: unsigned version_; From 1f5292d4d688a5b19b2592738db264d7d7cb5980 Mon Sep 17 00:00:00 2001 From: James Date: Wed, 25 Feb 2015 20:13:09 -0600 Subject: [PATCH 02/22] adding softdrop angular normalization parameter --- RecoJets/Configuration/python/RecoPFJets_cff.py | 3 ++- RecoJets/JetProducers/plugins/FastjetJetProducer.cc | 7 +++++-- RecoJets/JetProducers/plugins/FastjetJetProducer.h | 1 + RecoJets/JetProducers/python/ak4PFJetsSoftDrop_cfi.py | 1 + RecoJets/JetProducers/python/ak5PFJetsSoftDrop_cfi.py | 1 + 5 files changed, 10 insertions(+), 3 deletions(-) diff --git a/RecoJets/Configuration/python/RecoPFJets_cff.py b/RecoJets/Configuration/python/RecoPFJets_cff.py index 6faf766a73823..64f35bfb14fdc 100644 --- a/RecoJets/Configuration/python/RecoPFJets_cff.py +++ b/RecoJets/Configuration/python/RecoPFJets_cff.py @@ -133,7 +133,8 @@ ak8PFJetsCHSSoftDrop = ak5PFJetsCHSSoftDrop.clone( rParam = 0.8, - jetPtMin = 100.0 + jetPtMin = 100.0, + R0 = 100.0 ) diff --git a/RecoJets/JetProducers/plugins/FastjetJetProducer.cc b/RecoJets/JetProducers/plugins/FastjetJetProducer.cc index db4b6c801a224..7907f64d8bead 100644 --- a/RecoJets/JetProducers/plugins/FastjetJetProducer.cc +++ b/RecoJets/JetProducers/plugins/FastjetJetProducer.cc @@ -75,7 +75,8 @@ FastjetJetProducer::FastjetJetProducer(const edm::ParameterSet& iConfig) RcutFactor_(-1.0), csRho_EtaMax_(-1.0), csRParam_(-1.0), - beta_(-1.0) + beta_(-1.0), + R0_(-1.0) { if ( iConfig.exists("UseOnlyVertexTracks") ) @@ -142,6 +143,7 @@ FastjetJetProducer::FastjetJetProducer(const edm::ParameterSet& iConfig) csRho_EtaMax_ = -1.0; csRParam_ = -1.0; beta_ = -1.0; + R0_ = -1.0; useExplicitGhosts_ = true; if ( iConfig.exists("useMassDropTagger") ) { @@ -207,6 +209,7 @@ FastjetJetProducer::FastjetJetProducer(const edm::ParameterSet& iConfig) useSoftDrop_ = iConfig.getParameter("useSoftDrop"); zCut_ = iConfig.getParameter("zcut"); beta_ = iConfig.getParameter("beta"); + R0_ = iConfig.getParameter("R0"); } } @@ -455,7 +458,7 @@ void FastjetJetProducer::runAlgorithm( edm::Event & iEvent, edm::EventSetup cons } if ( useSoftDrop_ ) { - fastjet::contrib::SoftDrop * sd = new fastjet::contrib::SoftDrop(beta_, zCut_ ); + fastjet::contrib::SoftDrop * sd = new fastjet::contrib::SoftDrop(beta_, zCut_, R0_ ); transformers.push_back( transformer_ptr(sd) ); } diff --git a/RecoJets/JetProducers/plugins/FastjetJetProducer.h b/RecoJets/JetProducers/plugins/FastjetJetProducer.h index 781eb27f5fd9e..964dcf12dfe52 100644 --- a/RecoJets/JetProducers/plugins/FastjetJetProducer.h +++ b/RecoJets/JetProducers/plugins/FastjetJetProducer.h @@ -96,6 +96,7 @@ class FastjetJetProducer : public VirtualJetProducer double csRho_EtaMax_; /// for constituent subtraction : maximum rapidity for ghosts double csRParam_; /// for constituent subtraction : R parameter for KT alg in jet median background estimator double beta_; /// for soft drop : beta (angular exponent) + double R0_; /// for soft drop : R0 (angular distance normalization - should be set to jet radius in most cases) double subjetPtMin_; /// for CMSBoostedTauSeedingAlgorithm : subjet pt min diff --git a/RecoJets/JetProducers/python/ak4PFJetsSoftDrop_cfi.py b/RecoJets/JetProducers/python/ak4PFJetsSoftDrop_cfi.py index 9f5f2e01d0b49..603bd1bc33d07 100644 --- a/RecoJets/JetProducers/python/ak4PFJetsSoftDrop_cfi.py +++ b/RecoJets/JetProducers/python/ak4PFJetsSoftDrop_cfi.py @@ -8,6 +8,7 @@ useSoftDrop = cms.bool(True), zcut = cms.double(0.1), beta = cms.double(0.0), + R0 = cms.double(0.4), useExplicitGhosts = cms.bool(True), writeCompound = cms.bool(True), jetCollInstanceName=cms.string("SubJets") diff --git a/RecoJets/JetProducers/python/ak5PFJetsSoftDrop_cfi.py b/RecoJets/JetProducers/python/ak5PFJetsSoftDrop_cfi.py index b4f3dded98e25..a9d374455b77f 100644 --- a/RecoJets/JetProducers/python/ak5PFJetsSoftDrop_cfi.py +++ b/RecoJets/JetProducers/python/ak5PFJetsSoftDrop_cfi.py @@ -8,6 +8,7 @@ useSoftDrop = cms.bool(True), zcut = cms.double(0.1), beta = cms.double(0.0), + R0 = cms.double(0.5), useExplicitGhosts = cms.bool(True), writeCompound = cms.bool(True), jetCollInstanceName=cms.string("SubJets") From b816f31a8aac5866577948964e9824928130dc82 Mon Sep 17 00:00:00 2001 From: James Date: Thu, 26 Feb 2015 17:56:54 -0600 Subject: [PATCH 03/22] fixing R0 value for ak8PFJetsCHSSoftDrop --- RecoJets/Configuration/python/RecoPFJets_cff.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RecoJets/Configuration/python/RecoPFJets_cff.py b/RecoJets/Configuration/python/RecoPFJets_cff.py index 64f35bfb14fdc..285ba5f8c327b 100644 --- a/RecoJets/Configuration/python/RecoPFJets_cff.py +++ b/RecoJets/Configuration/python/RecoPFJets_cff.py @@ -134,7 +134,7 @@ ak8PFJetsCHSSoftDrop = ak5PFJetsCHSSoftDrop.clone( rParam = 0.8, jetPtMin = 100.0, - R0 = 100.0 + R0 = 0.8 ) From 58a80b761d5b1eae9529d3eb4e2c6de7e6143705 Mon Sep 17 00:00:00 2001 From: Matteo Date: Wed, 18 Feb 2015 17:48:28 +0100 Subject: [PATCH 04/22] add fillDescriptions to EcalUncalibRechitProducer --- .../interface/EcalRecHitWorkerBaseClass.h | 1 + ...ncalibRecHitFillDescriptionWorkerFactory.h | 10 + .../EcalUncalibRecHitWorkerBaseClass.h | 20 +- .../plugins/EcalUncalibRecHitProducer.cc | 36 +- .../plugins/EcalUncalibRecHitProducer.h | 5 +- .../plugins/EcalUncalibRecHitWorkerAnalFit.cc | 18 + .../plugins/EcalUncalibRecHitWorkerAnalFit.h | 4 + ...calUncalibRecHitWorkerFixedAlphaBetaFit.cc | 25 + ...EcalUncalibRecHitWorkerFixedAlphaBetaFit.h | 4 +- .../plugins/EcalUncalibRecHitWorkerGlobal.cc | 117 +++- .../plugins/EcalUncalibRecHitWorkerGlobal.h | 6 +- .../EcalUncalibRecHitWorkerMaxSample.cc | 18 + .../EcalUncalibRecHitWorkerMaxSample.h | 3 + .../EcalUncalibRecHitWorkerMultiFit.cc | 515 ++++++++++++++++++ .../plugins/EcalUncalibRecHitWorkerMultiFit.h | 5 +- .../plugins/EcalUncalibRecHitWorkerRatio.cc | 51 ++ .../plugins/EcalUncalibRecHitWorkerRatio.h | 4 + .../plugins/EcalUncalibRecHitWorkerWeights.cc | 17 + .../plugins/EcalUncalibRecHitWorkerWeights.h | 4 + ...calibRecHitFillDescriptionWorkerFactory.cc | 6 + 20 files changed, 843 insertions(+), 26 deletions(-) create mode 100644 RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitFillDescriptionWorkerFactory.h create mode 100644 RecoLocalCalo/EcalRecProducers/src/EcalUncalibRecHitFillDescriptionWorkerFactory.cc diff --git a/RecoLocalCalo/EcalRecProducers/interface/EcalRecHitWorkerBaseClass.h b/RecoLocalCalo/EcalRecProducers/interface/EcalRecHitWorkerBaseClass.h index 357589d435936..6206c41ced14c 100644 --- a/RecoLocalCalo/EcalRecProducers/interface/EcalRecHitWorkerBaseClass.h +++ b/RecoLocalCalo/EcalRecProducers/interface/EcalRecHitWorkerBaseClass.h @@ -20,6 +20,7 @@ class EcalRecHitWorkerBaseClass { virtual void set(const edm::EventSetup& es) = 0; virtual bool run(const edm::Event& evt, const EcalUncalibratedRecHit& uncalibRH, EcalRecHitCollection & result) = 0; + }; #endif diff --git a/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitFillDescriptionWorkerFactory.h b/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitFillDescriptionWorkerFactory.h new file mode 100644 index 0000000000000..d90311dd7f661 --- /dev/null +++ b/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitFillDescriptionWorkerFactory.h @@ -0,0 +1,10 @@ +#ifndef RecoLocalCalo_EcalRecProducers_EcalUncalibRecHitFillDescriptionWorkerFactory_hh +#define RecoLocalCalo_EcalRecProducers_EcalUncalibRecHitFillDescriptionWorkerFactory_hh + +#include "FWCore/PluginManager/interface/PluginFactory.h" +#include "FWCore/Framework/interface/ConsumesCollector.h" +#include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerBaseClass.h" + +typedef edmplugin::PluginFactory< EcalUncalibRecHitWorkerBaseClass*() > EcalUncalibRecHitFillDescriptionWorkerFactory; + +#endif diff --git a/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerBaseClass.h b/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerBaseClass.h index e532569b01334..9b7c5c0ec3c5f 100644 --- a/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerBaseClass.h +++ b/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerBaseClass.h @@ -4,22 +4,26 @@ #include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h" #include "DataFormats/EcalDigi/interface/EcalDigiCollections.h" #include "FWCore/Framework/interface/ConsumesCollector.h" +//#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" namespace edm { class Event; class EventSetup; class ParameterSet; + class ConfigurationDescriptions; } class EcalUncalibRecHitWorkerBaseClass { - public: - EcalUncalibRecHitWorkerBaseClass(const edm::ParameterSet&, edm::ConsumesCollector& c){} - EcalUncalibRecHitWorkerBaseClass(const edm::ParameterSet&){} - virtual ~EcalUncalibRecHitWorkerBaseClass(){} - - virtual void set(const edm::EventSetup& es) = 0; - virtual void set(const edm::Event& evt) {} - virtual bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result) = 0; + public: + EcalUncalibRecHitWorkerBaseClass(const edm::ParameterSet&, edm::ConsumesCollector& c) {} + EcalUncalibRecHitWorkerBaseClass(const edm::ParameterSet&) {} + EcalUncalibRecHitWorkerBaseClass() {} + virtual ~EcalUncalibRecHitWorkerBaseClass() {} + + virtual void set(const edm::EventSetup& es) = 0;//{}; + virtual void set(const edm::Event& evt) {} + virtual bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result) = 0; //{ return false; }; + virtual void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {}; }; #endif diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc index 0d4431142a5bb..217f1e4017bfc 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc @@ -1,5 +1,6 @@ #include "RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.h" #include "FWCore/Framework/interface/ConsumesCollector.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" #include "DataFormats/EcalDigi/interface/EcalDigiCollections.h" #include "DataFormats/Common/interface/Handle.h" @@ -7,8 +8,16 @@ #include "FWCore/MessageLogger/interface/MessageLogger.h" #include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerFactory.h" +#include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitFillDescriptionWorkerFactory.h" #include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" + +#include "FWCore/PluginManager/interface/PluginManager.h" +#include "FWCore/PluginManager/interface/standard.h" +#include "FWCore/PluginManager/interface/PluginInfo.h" +#include "FWCore/Utilities/interface/Exception.h" +#include "FWCore/Utilities/interface/Algorithms.h" EcalUncalibRecHitProducer::EcalUncalibRecHitProducer(const edm::ParameterSet& ps) { @@ -21,9 +30,9 @@ EcalUncalibRecHitProducer::EcalUncalibRecHitProducer(const edm::ParameterSet& ps eeDigiCollectionToken_ = consumes(ps.getParameter("EEdigiCollection")); - std::string componentType = ps.getParameter("algo"); + componentType_ = ps.getParameter("algo"); edm::ConsumesCollector c{consumesCollector()}; - worker_ = EcalUncalibRecHitWorkerFactory::get()->create(componentType, ps, c); + worker_ = EcalUncalibRecHitWorkerFactory::get()->create(componentType_, ps, c); } EcalUncalibRecHitProducer::~EcalUncalibRecHitProducer() @@ -31,6 +40,29 @@ EcalUncalibRecHitProducer::~EcalUncalibRecHitProducer() delete worker_; } +void EcalUncalibRecHitProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + + EcalUncalibRecHitFillDescriptionWorkerFactory* factory = EcalUncalibRecHitFillDescriptionWorkerFactory::get(); + std::vector infos; + + edmplugin::PluginManager::configure(edmplugin::standard::config()); + typedef edmplugin::PluginManager::CategoryToInfos CatToInfos; + CatToInfos const& catToInfos = edmplugin::PluginManager::get()->categoryToInfos(); + + CatToInfos::const_iterator itPlugins = catToInfos.find(factory->category()); + if(itPlugins == catToInfos.end()) + edm::LogWarning("EcalUncalibRecHitProducer") << "[WARNING] No EcaUncalibRecHitFillDescriptionWorker plugin defined" << std::endl; + + infos = itPlugins->second; + + for (std::vector::const_iterator itInfos = infos.begin(); itInfos != infos.end(); itInfos++) { + EcalUncalibRecHitWorkerBaseClass* fdWorker = EcalUncalibRecHitFillDescriptionWorkerFactory::get()->create(itInfos->name_); + fdWorker->fillDescriptions(descriptions); + + delete fdWorker; + } +} + void EcalUncalibRecHitProducer::produce(edm::Event& evt, const edm::EventSetup& es) { diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.h index 53312ee116010..b810d2014b09b 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.h @@ -21,6 +21,7 @@ class EcalUncalibRecHitProducer : public edm::stream::EDProducer<> { explicit EcalUncalibRecHitProducer(const edm::ParameterSet& ps); ~EcalUncalibRecHitProducer(); virtual void produce(edm::Event& evt, const edm::EventSetup& es) override; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); private: @@ -29,7 +30,9 @@ class EcalUncalibRecHitProducer : public edm::stream::EDProducer<> { std::string ebHitCollection_; std::string eeHitCollection_; - + + std::string componentType_; EcalUncalibRecHitWorkerBaseClass * worker_; + EcalUncalibRecHitWorkerBaseClass * fdWorker_; }; #endif diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.cc index c4b68090a3990..82d05240d87b3 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.cc @@ -34,6 +34,10 @@ #include "CondFormats/EcalObjects/interface/EcalGainRatios.h" #include "CondFormats/DataRecord/interface/EcalGainRatiosRcd.h" +#include +#include + + EcalUncalibRecHitWorkerAnalFit::EcalUncalibRecHitWorkerAnalFit(const edm::ParameterSet& ps, edm::ConsumesCollector& c) : EcalUncalibRecHitWorkerBaseClass( ps ,c) { @@ -133,6 +137,20 @@ EcalUncalibRecHitWorkerAnalFit::run( const edm::Event& evt, return true; } +void +EcalUncalibRecHitWorkerAnalFit::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + // ecalAnalFitUncalibRecHit + edm::ParameterSetDescription desc; + desc.add("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")); + desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); + desc.add("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")); + desc.add("algo", "EcalUncalibRecHitWorkerAnalFit"); + desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); + descriptions.add("ecalAnalFitUncalibRecHit", desc); +} + #include "FWCore/Framework/interface/MakerMacros.h" #include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerFactory.h" DEFINE_EDM_PLUGIN( EcalUncalibRecHitWorkerFactory, EcalUncalibRecHitWorkerAnalFit, "EcalUncalibRecHitWorkerAnalFit" ); +#include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitFillDescriptionWorkerFactory.h" +DEFINE_EDM_PLUGIN( EcalUncalibRecHitFillDescriptionWorkerFactory, EcalUncalibRecHitWorkerAnalFit, "EcalUncalibRecHitWorkerAnalFit" ); diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.h index b92b926c5dc3c..8139485ec9ab9 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.h @@ -21,16 +21,20 @@ namespace edm { class Event; class EventSetup; class ParameterSet; + class ConfigurationDescription; } class EcalUncalibRecHitWorkerAnalFit : public EcalUncalibRecHitWorkerBaseClass { public: EcalUncalibRecHitWorkerAnalFit(const edm::ParameterSet& ps,edm::ConsumesCollector& c); + EcalUncalibRecHitWorkerAnalFit() {}; ~EcalUncalibRecHitWorkerAnalFit() {}; void set(const edm::EventSetup& es); bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); + + void fillDescriptions(edm::ConfigurationDescriptions& descriptions); private: EcalUncalibRecHitRecAnalFitAlgo algoEB_; diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc index a223090a9d780..c990e567f2537 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc @@ -24,6 +24,9 @@ #include "CondFormats/EcalObjects/interface/EcalGainRatios.h" #include "CondFormats/DataRecord/interface/EcalGainRatiosRcd.h" +#include +#include + #include #include #include @@ -186,6 +189,28 @@ EcalUncalibRecHitWorkerFixedAlphaBetaFit::run(const edm::Event& evt, return true; } +void +EcalUncalibRecHitWorkerFixedAlphaBetaFit::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + // ecalFixedAlphaBetaFitUncalibRecHit + edm::ParameterSetDescription desc; + desc.add("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")); + desc.add("alphaEB", 1.138); + desc.add("alphaEE", 1.89); + desc.add("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")); + desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); + desc.addUntracked("AlphaBetaFilename", "NOFILE"); + desc.add("betaEB", 1.655); + desc.add("MinAmplEndcap", 14.0); + desc.add("MinAmplBarrel", 8.0); + desc.add("algo", "EcalUncalibRecHitWorkerFixedAlphaBetaFit"); + desc.add("betaEE", 1.4); + desc.add("UseDynamicPedestal", true); + desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); + descriptions.add("ecalFixedAlphaBetaFitUncalibRecHit", desc); +} + #include "FWCore/Framework/interface/MakerMacros.h" #include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerFactory.h" DEFINE_EDM_PLUGIN( EcalUncalibRecHitWorkerFactory, EcalUncalibRecHitWorkerFixedAlphaBetaFit, "EcalUncalibRecHitWorkerFixedAlphaBetaFit" ); +#include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitFillDescriptionWorkerFactory.h" +DEFINE_EDM_PLUGIN( EcalUncalibRecHitFillDescriptionWorkerFactory, EcalUncalibRecHitWorkerFixedAlphaBetaFit, "EcalUncalibRecHitWorkerFixedAlphaBetaFit"); diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.h index 9323b68d6970e..05d4f923e9005 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.h @@ -22,12 +22,14 @@ namespace edm { class EcalUncalibRecHitWorkerFixedAlphaBetaFit : public EcalUncalibRecHitWorkerBaseClass { public: - EcalUncalibRecHitWorkerFixedAlphaBetaFit(const edm::ParameterSet& ps, edm::ConsumesCollector& ); + EcalUncalibRecHitWorkerFixedAlphaBetaFit(const edm::ParameterSet& ps, edm::ConsumesCollector& ); + EcalUncalibRecHitWorkerFixedAlphaBetaFit() {}; virtual ~EcalUncalibRecHitWorkerFixedAlphaBetaFit() {}; void set(const edm::EventSetup& es); bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); + void fillDescriptions(edm::ConfigurationDescriptions& descriptions); private: double AmplThrEB_; diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.cc index a4939367b962e..d7b58c1885fa9 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.cc @@ -14,6 +14,9 @@ #include "CondFormats/DataRecord/interface/EcalTimeOffsetConstantRcd.h" #include "CondFormats/DataRecord/interface/EcalTimeBiasCorrectionsRcd.h" +#include +#include + EcalUncalibRecHitWorkerGlobal::EcalUncalibRecHitWorkerGlobal(const edm::ParameterSet&ps,edm::ConsumesCollector& c) : EcalUncalibRecHitWorkerBaseClass(ps,c) { @@ -98,18 +101,6 @@ EcalUncalibRecHitWorkerGlobal::EcalUncalibRecHitWorkerGlobal(const edm::Paramete EEchi2Parameters_ = ps.getParameter >("EEchi2Parameters"); } - - - - - - - - - - - - void EcalUncalibRecHitWorkerGlobal::set(const edm::EventSetup& es) { @@ -519,6 +510,108 @@ EcalUncalibRecHitWorkerGlobal::run( const edm::Event & evt, return true; } +void +EcalUncalibRecHitWorkerGlobal::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + // ecalGlobalUncalibRecHit + edm::ParameterSetDescription desc; + desc.add("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")); + desc.add>("eePulseShape", { + 5.2e-05, + -5.26e-05, + 6.66e-05, + 0.1168, + 0.7575, + 1.0, + 0.8876, + 0.6732, + 0.4741, + 0.3194, + }); + desc.add>("EBtimeFitParameters", { + -2.015452, + 3.130702, + -12.3473, + 41.88921, + -82.83944, + 91.01147, + -50.35761, + 11.05621, + }); + desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); + desc.add("outOfTimeThresholdGain61pEB", 5); + desc.add("amplitudeThresholdEE", 10); + desc.add("EBtimeConstantTerm", 0.6); + desc.add("outOfTimeThresholdGain61pEE", 1000); + desc.add("ebSpikeThreshold", 1.042); + desc.add("EBtimeNconst", 28.5); + desc.add("kPoorRecoFlagEB", true); + desc.add>("ebPulseShape", { + 5.2e-05, + -5.26e-05, + 6.66e-05, + 0.1168, + 0.7575, + 1.0, + 0.8876, + 0.6732, + 0.4741, + 0.3194, + }); + desc.add("EBtimeFitLimits_Lower", 0.2); + desc.add("kPoorRecoFlagEE", false); + desc.add("chi2ThreshEB_", 36.0); + desc.add("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")); + desc.add>("EEtimeFitParameters", { + -2.390548, + 3.553628, + -17.62341, + 67.67538, + -133.213, + 140.7432, + -75.41106, + 16.20277, + }); + desc.add("outOfTimeThresholdGain61mEE", 1000); + desc.add>("EEchi2Parameters", { + 2.122, + 0.022, + 2.122, + 0.022, + }); + desc.add("outOfTimeThresholdGain12mEE", 1000); + desc.add("outOfTimeThresholdGain12mEB", 5); + desc.add("EEtimeFitLimits_Upper", 1.4); + desc.add("EEtimeFitLimits_Lower", 0.2); + desc.add>("EEamplitudeFitParameters", { + 1.89, + 1.4, + }); + desc.add>("EBamplitudeFitParameters", { + 1.138, + 1.652, + }); + desc.add("amplitudeThresholdEB", 10); + desc.add("outOfTimeThresholdGain12pEE", 1000); + desc.add("outOfTimeThresholdGain12pEB", 5); + desc.add("EEtimeNconst", 31.8); + desc.add("outOfTimeThresholdGain61mEB", 5); + desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); + desc.add>("EBchi2Parameters", { + 2.122, + 0.022, + 2.122, + 0.022, + }); + desc.add("EEtimeConstantTerm", 1.0); + desc.add("algo", "EcalUncalibRecHitWorkerGlobal"); + desc.add("chi2ThreshEE_", 95.0); + desc.add("EBtimeFitLimits_Upper", 1.4); + descriptions.add("ecalGlobalUncalibRecHit", desc); +} + + #include "FWCore/Framework/interface/MakerMacros.h" #include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerFactory.h" DEFINE_EDM_PLUGIN( EcalUncalibRecHitWorkerFactory, EcalUncalibRecHitWorkerGlobal, "EcalUncalibRecHitWorkerGlobal" ); +#include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitFillDescriptionWorkerFactory.h" +DEFINE_EDM_PLUGIN( EcalUncalibRecHitFillDescriptionWorkerFactory, EcalUncalibRecHitWorkerGlobal, "EcalUncalibRecHitWorkerGlobal"); diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.h index 0fd413ae7cae7..8c76aa545f3ca 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.h @@ -31,18 +31,22 @@ namespace edm { class Event; class EventSetup; class ParameterSet; + class ConfigurationDescription; } class EcalUncalibRecHitWorkerGlobal : public EcalUncalibRecHitWorkerBaseClass { public: EcalUncalibRecHitWorkerGlobal(const edm::ParameterSet&, edm::ConsumesCollector& c); - EcalUncalibRecHitWorkerGlobal(const edm::ParameterSet&); + EcalUncalibRecHitWorkerGlobal(const edm::ParameterSet&); + EcalUncalibRecHitWorkerGlobal() {}; virtual ~EcalUncalibRecHitWorkerGlobal() {}; void set(const edm::EventSetup& es); bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); + void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + protected: double pedVec[3]; diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc index 90a417464ba96..49a4d7984c8c0 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc @@ -16,6 +16,9 @@ #include "FWCore/Framework/interface/ESHandle.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" +#include +#include + #include #include #include @@ -48,6 +51,21 @@ EcalUncalibRecHitWorkerMaxSample::run( const edm::Event & evt, return true; } +void +EcalUncalibRecHitWorkerMaxSample::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + // ecalMaxSampleUncalibRecHit + edm::ParameterSetDescription desc; + desc.add("EBdigiCollection", edm::InputTag("ecalEBunpacker","ebDigis")); + desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); + desc.add("EEdigiCollection", edm::InputTag("ecalEBunpacker","eeDigis")); + desc.add("algo", "EcalUncalibRecHitWorkerMaxSample"); + desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); + descriptions.add("ecalMaxSampleUncalibRecHit", desc); +} + + #include "FWCore/Framework/interface/MakerMacros.h" #include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerFactory.h" DEFINE_EDM_PLUGIN( EcalUncalibRecHitWorkerFactory, EcalUncalibRecHitWorkerMaxSample, "EcalUncalibRecHitWorkerMaxSample" ); +#include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitFillDescriptionWorkerFactory.h" +DEFINE_EDM_PLUGIN( EcalUncalibRecHitFillDescriptionWorkerFactory, EcalUncalibRecHitWorkerMaxSample, "EcalUncalibRecHitWorkerMaxSample"); diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.h index 1fab628ace4f8..897d998ffde45 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.h @@ -11,17 +11,20 @@ namespace edm { class ParameterSet; class EventSetup; class Event; + class ConfigurationDescription; } class EcalUncalibRecHitWorkerMaxSample : public EcalUncalibRecHitWorkerBaseClass { public: EcalUncalibRecHitWorkerMaxSample(const edm::ParameterSet& ps,edm::ConsumesCollector& c); + EcalUncalibRecHitWorkerMaxSample() {}; virtual ~EcalUncalibRecHitWorkerMaxSample() {}; void set(const edm::EventSetup& es); bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); + void fillDescriptions(edm::ConfigurationDescriptions& descriptions); private: //std::string ebHitCollection_; // secondary name to be given to collection of hits diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.cc index 627e217135c84..d891fc8f1c264 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.cc @@ -18,6 +18,9 @@ #include "CondFormats/DataRecord/interface/EcalPulseShapesRcd.h" #include "CondFormats/DataRecord/interface/EcalPulseCovariancesRcd.h" +#include +#include + EcalUncalibRecHitWorkerMultiFit::EcalUncalibRecHitWorkerMultiFit(const edm::ParameterSet&ps,edm::ConsumesCollector& c) : EcalUncalibRecHitWorkerBaseClass(ps,c), noisecorEBg12(SampleMatrix::Zero()), noisecorEEg12(SampleMatrix::Zero()), @@ -570,6 +573,518 @@ const SampleMatrix &EcalUncalibRecHitWorkerMultiFit::noisecor(bool barrel, int g } +void EcalUncalibRecHitWorkerMultiFit::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + + edm::ParameterSetDescription desc; + desc.add("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")); + desc.add>("eePulseShape", { + 5.2e-05, + -5.26e-05, + 6.66e-05, + 0.1168, + 0.7575, + 1.0, + 0.8876, + 0.6732, + 0.4741, + 0.3194, + }); + { + edm::ParameterSetDescription psd0; + psd0.add("EcalPreMixStage2", false); + psd0.add>("EECorrNoiseMatrixG01", { + 1.0, + 0.72698, + 0.62048, + 0.55691, + 0.51848, + 0.49147, + 0.47813, + 0.47007, + 0.46621, + 0.46265, + }); + psd0.add("EcalPreMixStage1", false); + psd0.add>("EECorrNoiseMatrixG06", { + 1.0, + 0.71217, + 0.47464, + 0.34056, + 0.26282, + 0.20287, + 0.17734, + 0.16256, + 0.15618, + 0.14443, + }); + psd0.add>("EBCorrNoiseMatrixG01", { + 1.0, + 0.73354, + 0.64442, + 0.58851, + 0.55425, + 0.53082, + 0.51916, + 0.51097, + 0.50732, + 0.50409, + }); + psd0.add>("EBCorrNoiseMatrixG06", { + 1.0, + 0.70946, + 0.58021, + 0.49846, + 0.45006, + 0.41366, + 0.39699, + 0.38478, + 0.37847, + 0.37055, + }); + psd0.add("EBdigiCollection", ""); + psd0.add>("EEPulseShapeCovariance", { + 3.941e-05, + 3.333e-05, + 0.0, + -1.449e-05, + -1.661e-05, + -1.424e-05, + -1.183e-05, + -6.842e-06, + -4.915e-06, + -3.411e-06, + 0.0, + 0.0, + 3.333e-05, + 2.862e-05, + 0.0, + -1.244e-05, + -1.431e-05, + -1.233e-05, + -1.032e-05, + -5.883e-06, + -4.154e-06, + -2.902e-06, + -2.128e-06, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + -1.449e-05, + -1.244e-05, + 0.0, + 5.84e-06, + 6.649e-06, + 5.72e-06, + 4.812e-06, + 2.708e-06, + 1.869e-06, + 1.33e-06, + 9.186e-07, + 6.446e-07, + -1.661e-05, + -1.431e-05, + 0.0, + 6.649e-06, + 7.966e-06, + 6.898e-06, + 5.794e-06, + 3.157e-06, + 2.184e-06, + 1.567e-06, + 1.084e-06, + 7.575e-07, + -1.424e-05, + -1.233e-05, + 0.0, + 5.72e-06, + 6.898e-06, + 6.341e-06, + 5.347e-06, + 2.859e-06, + 1.991e-06, + 1.431e-06, + 9.839e-07, + 6.886e-07, + -1.183e-05, + -1.032e-05, + 0.0, + 4.812e-06, + 5.794e-06, + 5.347e-06, + 4.854e-06, + 2.628e-06, + 1.809e-06, + 1.289e-06, + 9.02e-07, + 6.146e-07, + -6.842e-06, + -5.883e-06, + 0.0, + 2.708e-06, + 3.157e-06, + 2.859e-06, + 2.628e-06, + 1.863e-06, + 1.296e-06, + 8.882e-07, + 6.108e-07, + 4.283e-07, + -4.915e-06, + -4.154e-06, + 0.0, + 1.869e-06, + 2.184e-06, + 1.991e-06, + 1.809e-06, + 1.296e-06, + 1.217e-06, + 8.669e-07, + 5.751e-07, + 3.882e-07, + -3.411e-06, + -2.902e-06, + 0.0, + 1.33e-06, + 1.567e-06, + 1.431e-06, + 1.289e-06, + 8.882e-07, + 8.669e-07, + 9.522e-07, + 6.717e-07, + 4.293e-07, + 0.0, + -2.128e-06, + 0.0, + 9.186e-07, + 1.084e-06, + 9.839e-07, + 9.02e-07, + 6.108e-07, + 5.751e-07, + 6.717e-07, + 7.911e-07, + 5.493e-07, + 0.0, + 0.0, + 0.0, + 6.446e-07, + 7.575e-07, + 6.886e-07, + 6.146e-07, + 4.283e-07, + 3.882e-07, + 4.293e-07, + 5.493e-07, + 7.027e-07, + }); + psd0.add>("EBPulseShapeTemplate", { + 0.0113979, + 0.758151, + 1.0, + 0.887744, + 0.673548, + 0.474332, + 0.319561, + 0.215144, + 0.147464, + 0.101087, + 0.0693181, + 0.0475044, + }); + psd0.add("ESdigiCollection", ""); + psd0.add>("EEPulseShapeTemplate", { + 0.116442, + 0.756246, + 1.0, + 0.897182, + 0.686831, + 0.491506, + 0.344111, + 0.245731, + 0.174115, + 0.123361, + 0.0874288, + 0.061957, + }); + psd0.add>("EBCorrNoiseMatrixG12", { + 1.0, + 0.71073, + 0.55721, + 0.46089, + 0.40449, + 0.35931, + 0.33924, + 0.32439, + 0.31581, + 0.30481, + }); + psd0.add>("EECorrNoiseMatrixG12", { + 1.0, + 0.71373, + 0.44825, + 0.30152, + 0.21609, + 0.14786, + 0.11772, + 0.10165, + 0.09465, + 0.08098, + }); + psd0.add("EEdigiCollection", ""); + psd0.add>("EBPulseShapeCovariance", { + 3.001e-06, + 1.233e-05, + 0.0, + -4.416e-06, + -4.571e-06, + -3.614e-06, + -2.636e-06, + -1.286e-06, + -8.41e-07, + -5.296e-07, + 0.0, + 0.0, + 1.233e-05, + 6.154e-05, + 0.0, + -2.2e-05, + -2.309e-05, + -1.838e-05, + -1.373e-05, + -7.334e-06, + -5.088e-06, + -3.745e-06, + -2.428e-06, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + -4.416e-06, + -2.2e-05, + 0.0, + 8.319e-06, + 8.545e-06, + 6.792e-06, + 5.059e-06, + 2.678e-06, + 1.816e-06, + 1.223e-06, + 8.245e-07, + 5.589e-07, + -4.571e-06, + -2.309e-05, + 0.0, + 8.545e-06, + 9.182e-06, + 7.219e-06, + 5.388e-06, + 2.853e-06, + 1.944e-06, + 1.324e-06, + 9.083e-07, + 6.335e-07, + -3.614e-06, + -1.838e-05, + 0.0, + 6.792e-06, + 7.219e-06, + 6.016e-06, + 4.437e-06, + 2.385e-06, + 1.636e-06, + 1.118e-06, + 7.754e-07, + 5.556e-07, + -2.636e-06, + -1.373e-05, + 0.0, + 5.059e-06, + 5.388e-06, + 4.437e-06, + 3.602e-06, + 1.917e-06, + 1.322e-06, + 9.079e-07, + 6.529e-07, + 4.752e-07, + -1.286e-06, + -7.334e-06, + 0.0, + 2.678e-06, + 2.853e-06, + 2.385e-06, + 1.917e-06, + 1.375e-06, + 9.1e-07, + 6.455e-07, + 4.693e-07, + 3.657e-07, + -8.41e-07, + -5.088e-06, + 0.0, + 1.816e-06, + 1.944e-06, + 1.636e-06, + 1.322e-06, + 9.1e-07, + 9.115e-07, + 6.062e-07, + 4.436e-07, + 3.422e-07, + -5.296e-07, + -3.745e-06, + 0.0, + 1.223e-06, + 1.324e-06, + 1.118e-06, + 9.079e-07, + 6.455e-07, + 6.062e-07, + 7.217e-07, + 4.862e-07, + 3.768e-07, + 0.0, + -2.428e-06, + 0.0, + 8.245e-07, + 9.083e-07, + 7.754e-07, + 6.529e-07, + 4.693e-07, + 4.436e-07, + 4.862e-07, + 6.509e-07, + 4.418e-07, + 0.0, + 0.0, + 0.0, + 5.589e-07, + 6.335e-07, + 5.556e-07, + 4.752e-07, + 3.657e-07, + 3.422e-07, + 3.768e-07, + 4.418e-07, + 6.142e-07, + }); + psd0.addUntracked("UseLCcorrection", true); + desc.add("EcalPulseShapeParameters", psd0); + } + desc.add>("EBtimeFitParameters", { + -2.015452, + 3.130702, + -12.3473, + 41.88921, + -82.83944, + 91.01147, + -50.35761, + 11.05621, + }); + desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); + desc.add("outOfTimeThresholdGain61pEB", 5); + desc.add("amplitudeThresholdEE", 10); + desc.add("EBtimeConstantTerm", 0.6); + desc.add("EEtimeFitLimits_Lower", 0.2); + desc.add("outOfTimeThresholdGain61pEE", 1000); + desc.add("ebSpikeThreshold", 1.042); + desc.add("EBtimeNconst", 28.5); + desc.add("ampErrorCalculation", true); + desc.add("kPoorRecoFlagEB", true); + desc.add>("ebPulseShape", { + 5.2e-05, + -5.26e-05, + 6.66e-05, + 0.1168, + 0.7575, + 1.0, + 0.8876, + 0.6732, + 0.4741, + 0.3194, + }); + desc.add("EBtimeFitLimits_Lower", 0.2); + desc.add("kPoorRecoFlagEE", false); + desc.add("chi2ThreshEB_", 65.0); + desc.add("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")); + desc.add>("EEtimeFitParameters", { + -2.390548, + 3.553628, + -17.62341, + 67.67538, + -133.213, + 140.7432, + -75.41106, + 16.20277, + }); + desc.add("useLumiInfoRunHeader", true); + desc.add>("activeBXs", { + -5, + -4, + -3, + -2, + -1, + 0, + 1, + 2, + 3, + 4, + }); + desc.add("algo", "EcalUncalibRecHitWorkerMultiFit"); + desc.add("outOfTimeThresholdGain12mEE", 1000); + desc.add("outOfTimeThresholdGain12mEB", 5); + desc.add("EEtimeFitLimits_Upper", 1.4); + desc.add("prefitMaxChiSqEB", 25.0); + desc.add>("EEamplitudeFitParameters", { + 1.89, + 1.4, + }); + desc.add("prefitMaxChiSqEE", 10.0); + desc.add>("EBamplitudeFitParameters", { + 1.138, + 1.652, + }); + desc.add("EBtimeFitLimits_Upper", 1.4); + desc.add("timealgo", "RatioMethod"); + desc.add("amplitudeThresholdEB", 10); + desc.add("outOfTimeThresholdGain12pEE", 1000); + desc.add("outOfTimeThresholdGain12pEB", 5); + desc.add("EEtimeNconst", 31.8); + desc.add("outOfTimeThresholdGain61mEB", 5); + desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); + desc.add("outOfTimeThresholdGain61mEE", 1000); + desc.add("EEtimeConstantTerm", 1.0); + desc.add("chi2ThreshEE_", 50.0); + desc.add("doPrefitEE", false); + desc.add("doPrefitEB", false); + descriptions.add("ecalMultiFitUncalibRecHit", desc); + +} + + + #include "FWCore/Framework/interface/MakerMacros.h" #include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerFactory.h" DEFINE_EDM_PLUGIN( EcalUncalibRecHitWorkerFactory, EcalUncalibRecHitWorkerMultiFit, "EcalUncalibRecHitWorkerMultiFit" ); +#include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitFillDescriptionWorkerFactory.h" +DEFINE_EDM_PLUGIN( EcalUncalibRecHitFillDescriptionWorkerFactory, EcalUncalibRecHitWorkerMultiFit, "EcalUncalibRecHitWorkerMultiFit" ); diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.h index 753277624a56d..b58d7dd6a370b 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.h @@ -30,6 +30,7 @@ #include "CondFormats/EcalObjects/interface/EcalPulseCovariances.h" #include "RecoLocalCalo/EcalRecAlgos/interface/EigenMatrixTypes.h" + namespace edm { class Event; class EventSetup; @@ -40,12 +41,14 @@ class EcalUncalibRecHitWorkerMultiFit : public EcalUncalibRecHitWorkerBaseClass public: EcalUncalibRecHitWorkerMultiFit(const edm::ParameterSet&, edm::ConsumesCollector& c); - //EcalUncalibRecHitWorkerMultiFit(const edm::ParameterSet&); + EcalUncalibRecHitWorkerMultiFit() {}; virtual ~EcalUncalibRecHitWorkerMultiFit() {}; void set(const edm::EventSetup& es) override; void set(const edm::Event& evt) override; bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result) override; + + void fillDescriptions(edm::ConfigurationDescriptions& descriptions); protected: diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc index fb0348cb212e0..81ddc31daf4ef 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc @@ -9,6 +9,9 @@ #include "CondFormats/DataRecord/interface/EcalGainRatiosRcd.h" #include "CondFormats/DataRecord/interface/EcalPedestalsRcd.h" +#include +#include + EcalUncalibRecHitWorkerRatio::EcalUncalibRecHitWorkerRatio(const edm::ParameterSet&ps, edm::ConsumesCollector& c) : EcalUncalibRecHitWorkerBaseClass(ps,c) { @@ -124,6 +127,54 @@ EcalUncalibRecHitWorkerRatio::run( const edm::Event & evt, return true; } +void +EcalUncalibRecHitWorkerRatio::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + // ecalRatioUncalibRecHit + edm::ParameterSetDescription desc; + desc.add("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")); + desc.add("EEtimeFitLimits_Upper", 1.4); + desc.add>("EBtimeFitParameters", { + -2.015452, + 3.130702, + -12.3473, + 41.88921, + -82.83944, + 91.01147, + -50.35761, + 11.05621, + }); + desc.add("EEtimeConstantTerm", 0.18); + desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); + desc.add("EBtimeFitLimits_Lower", 0.2); + desc.add("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")); + desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); + desc.add("algo", "EcalUncalibRecHitWorkerRatio"); + desc.add("EBtimeConstantTerm", 0.26); + desc.add("EEtimeFitLimits_Lower", 0.2); + desc.add>("EEtimeFitParameters", { + -2.390548, + 3.553628, + -17.62341, + 67.67538, + -133.213, + 140.7432, + -75.41106, + 16.20277, + }); + desc.add>("EEamplitudeFitParameters", { + 1.89, + 1.4, + }); + desc.add("EBtimeFitLimits_Upper", 1.4); + desc.add>("EBamplitudeFitParameters", { + 1.138, + 1.652, + }); + descriptions.add("ecalRatioUncalibRecHit", desc); +} + #include "FWCore/Framework/interface/MakerMacros.h" #include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerFactory.h" DEFINE_EDM_PLUGIN( EcalUncalibRecHitWorkerFactory, EcalUncalibRecHitWorkerRatio, "EcalUncalibRecHitWorkerRatio" ); +#include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitFillDescriptionWorkerFactory.h" +DEFINE_EDM_PLUGIN( EcalUncalibRecHitFillDescriptionWorkerFactory, EcalUncalibRecHitWorkerRatio, "EcalUncalibRecHitWorkerRatio"); diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.h index 72cf06be9f07a..9c37534e8956f 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.h @@ -19,17 +19,21 @@ namespace edm { class Event; class EventSetup; class ParameterSet; + class ConfigurationDescription; } class EcalUncalibRecHitWorkerRatio : public EcalUncalibRecHitWorkerBaseClass { public: EcalUncalibRecHitWorkerRatio(const edm::ParameterSet&, edm::ConsumesCollector& c); + EcalUncalibRecHitWorkerRatio() {}; virtual ~EcalUncalibRecHitWorkerRatio() {}; void set(const edm::EventSetup& es); bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); + void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + protected: // determie which of the samples must actually be used by ECAL local reco diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.cc index 20c98192f83e6..fb60826bbba34 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.cc @@ -9,6 +9,9 @@ #include "CondFormats/DataRecord/interface/EcalWeightXtalGroupsRcd.h" #include "CondFormats/DataRecord/interface/EcalTBWeightsRcd.h" +#include +#include + EcalUncalibRecHitWorkerWeights::EcalUncalibRecHitWorkerWeights(const edm::ParameterSet&ps, edm::ConsumesCollector& c) : EcalUncalibRecHitWorkerBaseClass(ps,c) { @@ -96,6 +99,20 @@ EcalUncalibRecHitWorkerWeights::run( const edm::Event & evt, return true; } +void +EcalUncalibRecHitWorkerWeights::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + // ecalWeightUncalibRecHit + edm::ParameterSetDescription desc; + desc.add("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")); + desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); + desc.add("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")); + desc.add("algo", "EcalUncalibRecHitWorkerWeights"); + desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); + descriptions.add("ecalWeightUncalibRecHit", desc); +} + #include "FWCore/Framework/interface/MakerMacros.h" #include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerFactory.h" DEFINE_EDM_PLUGIN( EcalUncalibRecHitWorkerFactory, EcalUncalibRecHitWorkerWeights, "EcalUncalibRecHitWorkerWeights" ); +#include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitFillDescriptionWorkerFactory.h" +DEFINE_EDM_PLUGIN( EcalUncalibRecHitFillDescriptionWorkerFactory, EcalUncalibRecHitWorkerWeights, "EcalUncalibRecHitWorkerWeights"); diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.h index 84dd7b0d15df0..a14bcdfada13c 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.h @@ -25,17 +25,21 @@ namespace edm { class Event; class EventSetup; class ParameterSet; + class ConfigurationDescription; } class EcalUncalibRecHitWorkerWeights : public EcalUncalibRecHitWorkerBaseClass { public: EcalUncalibRecHitWorkerWeights(const edm::ParameterSet&, edm::ConsumesCollector& c); + EcalUncalibRecHitWorkerWeights() {}; virtual ~EcalUncalibRecHitWorkerWeights() {}; void set(const edm::EventSetup& es); bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); + void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + protected: edm::ESHandle peds; diff --git a/RecoLocalCalo/EcalRecProducers/src/EcalUncalibRecHitFillDescriptionWorkerFactory.cc b/RecoLocalCalo/EcalRecProducers/src/EcalUncalibRecHitFillDescriptionWorkerFactory.cc new file mode 100644 index 0000000000000..a62d57326ffb5 --- /dev/null +++ b/RecoLocalCalo/EcalRecProducers/src/EcalUncalibRecHitFillDescriptionWorkerFactory.cc @@ -0,0 +1,6 @@ +#include "FWCore/PluginManager/interface/ModuleDef.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/Framework/interface/ModuleFactory.h" + +#include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitFillDescriptionWorkerFactory.h" +EDM_REGISTER_PLUGINFACTORY(EcalUncalibRecHitFillDescriptionWorkerFactory, "EcalUncalibRecHitFillDescriptionWorkerFactory"); From f95c6e7934d7025af1e1d6adc64b36727bff57fe Mon Sep 17 00:00:00 2001 From: Matteo Date: Wed, 18 Feb 2015 18:31:38 +0100 Subject: [PATCH 05/22] cleaned producer --- .../plugins/EcalUncalibRecHitProducer.cc | 22 +++++-------------- .../plugins/EcalUncalibRecHitProducer.h | 2 -- 2 files changed, 5 insertions(+), 19 deletions(-) diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc index 217f1e4017bfc..826b140283985 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc @@ -30,9 +30,9 @@ EcalUncalibRecHitProducer::EcalUncalibRecHitProducer(const edm::ParameterSet& ps eeDigiCollectionToken_ = consumes(ps.getParameter("EEdigiCollection")); - componentType_ = ps.getParameter("algo"); + std::string componentType = ps.getParameter("algo"); edm::ConsumesCollector c{consumesCollector()}; - worker_ = EcalUncalibRecHitWorkerFactory::get()->create(componentType_, ps, c); + worker_ = EcalUncalibRecHitWorkerFactory::get()->create(componentType, ps, c); } EcalUncalibRecHitProducer::~EcalUncalibRecHitProducer() @@ -43,23 +43,11 @@ EcalUncalibRecHitProducer::~EcalUncalibRecHitProducer() void EcalUncalibRecHitProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { EcalUncalibRecHitFillDescriptionWorkerFactory* factory = EcalUncalibRecHitFillDescriptionWorkerFactory::get(); - std::vector infos; - - edmplugin::PluginManager::configure(edmplugin::standard::config()); - typedef edmplugin::PluginManager::CategoryToInfos CatToInfos; - CatToInfos const& catToInfos = edmplugin::PluginManager::get()->categoryToInfos(); - - CatToInfos::const_iterator itPlugins = catToInfos.find(factory->category()); - if(itPlugins == catToInfos.end()) - edm::LogWarning("EcalUncalibRecHitProducer") << "[WARNING] No EcaUncalibRecHitFillDescriptionWorker plugin defined" << std::endl; - - infos = itPlugins->second; + std::vector infos = factory->available(); for (std::vector::const_iterator itInfos = infos.begin(); itInfos != infos.end(); itInfos++) { - EcalUncalibRecHitWorkerBaseClass* fdWorker = EcalUncalibRecHitFillDescriptionWorkerFactory::get()->create(itInfos->name_); - fdWorker->fillDescriptions(descriptions); - - delete fdWorker; + std::unique_ptr fdWorker(EcalUncalibRecHitFillDescriptionWorkerFactory::get()->create(itInfos->name_)); + fdWorker->fillDescriptions(descriptions); } } diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.h index b810d2014b09b..3396fcf4b65bc 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.h @@ -31,8 +31,6 @@ class EcalUncalibRecHitProducer : public edm::stream::EDProducer<> { std::string ebHitCollection_; std::string eeHitCollection_; - std::string componentType_; EcalUncalibRecHitWorkerBaseClass * worker_; - EcalUncalibRecHitWorkerBaseClass * fdWorker_; }; #endif From 92b9a5f2c7f815442aabe0bb82c539920277a0a8 Mon Sep 17 00:00:00 2001 From: Matteo Date: Thu, 19 Feb 2015 18:28:36 +0100 Subject: [PATCH 06/22] use ifValue --- .../EcalUncalibRecHitWorkerBaseClass.h | 9 ++- .../plugins/EcalUncalibRecHitProducer.cc | 46 +++++++++++++- ...calUncalibRecHitWorkerFixedAlphaBetaFit.cc | 34 +++++----- ...EcalUncalibRecHitWorkerFixedAlphaBetaFit.h | 3 +- .../EcalUncalibRecHitWorkerMaxSample.cc | 13 ++-- .../EcalUncalibRecHitWorkerMaxSample.h | 7 +-- .../plugins/EcalUncalibRecHitWorkerRatio.cc | 63 ++++++------------- .../plugins/EcalUncalibRecHitWorkerRatio.h | 4 +- 8 files changed, 94 insertions(+), 85 deletions(-) diff --git a/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerBaseClass.h b/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerBaseClass.h index 9b7c5c0ec3c5f..6cd38e7996593 100644 --- a/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerBaseClass.h +++ b/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerBaseClass.h @@ -4,13 +4,12 @@ #include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h" #include "DataFormats/EcalDigi/interface/EcalDigiCollections.h" #include "FWCore/Framework/interface/ConsumesCollector.h" -//#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" namespace edm { class Event; class EventSetup; class ParameterSet; - class ConfigurationDescriptions; + class ParameterSetDescription; } class EcalUncalibRecHitWorkerBaseClass { @@ -20,10 +19,10 @@ class EcalUncalibRecHitWorkerBaseClass { EcalUncalibRecHitWorkerBaseClass() {} virtual ~EcalUncalibRecHitWorkerBaseClass() {} - virtual void set(const edm::EventSetup& es) = 0;//{}; + virtual void set(const edm::EventSetup& es) = 0; virtual void set(const edm::Event& evt) {} - virtual bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result) = 0; //{ return false; }; - virtual void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {}; + virtual bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result) = 0; + virtual void fillDescriptions(edm::ParameterSetDescription& desc, std::string& moduleName) {}; }; #endif diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc index 826b140283985..d3e374163453a 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc @@ -42,12 +42,54 @@ EcalUncalibRecHitProducer::~EcalUncalibRecHitProducer() void EcalUncalibRecHitProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { +// //std::vector +// +// EcalUncalibRecHitFillDescriptionWorkerFactory* factory = EcalUncalibRecHitFillDescriptionWorkerFactory::get(); +// std::vector infos = factory->available(); +// +// for (std::vector::const_iterator itInfos = infos.begin(); itInfos != infos.end(); itInfos++) { +// std::unique_ptr fdWorker(EcalUncalibRecHitFillDescriptionWorkerFactory::get()->create(itInfos->name_)); +// +// edm::ParameterSetDescription desc; +// desc.add("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")); +// desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); +// desc.add("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")); +// desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); +// desc.add("algo", itInfos->name_); +// std::string moduleName("ecalUncalibRechit"); // default name overwritten by each worker fillDescriptions +// fdWorker->fillDescriptions(desc, moduleName); +// desc +// descriptions.add(moduleName, desc); +// } + +// std::vector descs; +// std::vector moduleNames; + EcalUncalibRecHitFillDescriptionWorkerFactory* factory = EcalUncalibRecHitFillDescriptionWorkerFactory::get(); std::vector infos = factory->available(); - + for (std::vector::const_iterator itInfos = infos.begin(); itInfos != infos.end(); itInfos++) { std::unique_ptr fdWorker(EcalUncalibRecHitFillDescriptionWorkerFactory::get()->create(itInfos->name_)); - fdWorker->fillDescriptions(descriptions); + + edm::ParameterSetDescription desc; + desc.add("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")); + desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); + desc.add("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")); + desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); + //desc.add("algo", itInfos->name_); + + std::string moduleName("ecalUncalibRechit"); // default name overwritten by each worker fillDescriptions + + //desc.ifExists(edm::ParameterDescription("algo", itInfos->name_), + //fdWorker->fillDescriptions(desc, moduleName)); + + fdWorker->fillDescriptions(desc, moduleName); + //descs.push_back(desc); + //moduleNames.push_bakc(moduleName); + + //desc.ifExists(edm::ParameterDescription("algo", itInfos->name_, true) + //edm::ParameterSetDescription<>("x", 100, true)); + descriptions.add(moduleName, desc); } } diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc index c990e567f2537..8e237962c32f7 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc @@ -39,7 +39,7 @@ EcalUncalibRecHitWorkerFixedAlphaBetaFit::EcalUncalibRecHitWorkerFixedAlphaBetaF alphaEE_= ps.getParameter("alphaEE"); betaEE_= ps.getParameter("betaEE"); - alphabetaFilename_= ps.getUntrackedParameter("AlphaBetaFilename","NOFILE"); + alphabetaFilename_= ps.getParameter("AlphaBetaFilename"); useAlphaBetaArray_=setAlphaBeta(); // set crystalwise values of alpha and beta if ( !useAlphaBetaArray_ ) { edm::LogInfo("EcalUncalibRecHitError") << " No alfa-beta file found. Using the deafult values."; @@ -190,23 +190,21 @@ EcalUncalibRecHitWorkerFixedAlphaBetaFit::run(const edm::Event& evt, } void -EcalUncalibRecHitWorkerFixedAlphaBetaFit::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - // ecalFixedAlphaBetaFitUncalibRecHit - edm::ParameterSetDescription desc; - desc.add("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")); - desc.add("alphaEB", 1.138); - desc.add("alphaEE", 1.89); - desc.add("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")); - desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); - desc.addUntracked("AlphaBetaFilename", "NOFILE"); - desc.add("betaEB", 1.655); - desc.add("MinAmplEndcap", 14.0); - desc.add("MinAmplBarrel", 8.0); - desc.add("algo", "EcalUncalibRecHitWorkerFixedAlphaBetaFit"); - desc.add("betaEE", 1.4); - desc.add("UseDynamicPedestal", true); - desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); - descriptions.add("ecalFixedAlphaBetaFitUncalibRecHit", desc); +EcalUncalibRecHitWorkerFixedAlphaBetaFit::fillDescriptions(edm::ParameterSetDescription& desc, std::string& moduleName) { + + desc.ifValue(edm::ParameterDescription("algo", "EcalUncalibRechitWorkerFixedAlphaBetaFit", true), + "EcalUncalibRechitWorkerFixedAlphaBetaFit" >> (edm::ParameterDescription("alphaEB", 1.138, true) and + edm::ParameterDescription("alphaEE", 1.89, true) and + edm::ParameterDescription("AlphaBetaFilename", "NOFILE", true) and + edm::ParameterDescription("betaEB", 1.655, true) and + edm::ParameterDescription("MinAmplEndcap", 14.0, true) and + edm::ParameterDescription("MinAmplBarrel", 8.0, true) and + edm::ParameterDescription("betaEE", 1.4, true) and + edm::ParameterDescription("UseDynamicPedestal", true, true) + ) + ); + + moduleName = "ecalFixedAlphaBetaFitUncalibRecHit"; } #include "FWCore/Framework/interface/MakerMacros.h" diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.h index 05d4f923e9005..23577b188f2e0 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.h @@ -17,6 +17,7 @@ namespace edm { class Event; class EventSetup; class ParameterSet; + class ParameterSetDescription; } class EcalUncalibRecHitWorkerFixedAlphaBetaFit : public EcalUncalibRecHitWorkerBaseClass { @@ -29,7 +30,7 @@ class EcalUncalibRecHitWorkerFixedAlphaBetaFit : public EcalUncalibRecHitWorkerB void set(const edm::EventSetup& es); bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); - void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + void fillDescriptions(edm::ParameterSetDescription& desc, std::string& moduleName); private: double AmplThrEB_; diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc index 49a4d7984c8c0..b947afe76d470 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc @@ -1,3 +1,4 @@ + /** \class EcalMaxSampleUncalibRecHitProducer * produce ECAL uncalibrated rechits from dataframes * @@ -52,15 +53,9 @@ EcalUncalibRecHitWorkerMaxSample::run( const edm::Event & evt, } void -EcalUncalibRecHitWorkerMaxSample::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - // ecalMaxSampleUncalibRecHit - edm::ParameterSetDescription desc; - desc.add("EBdigiCollection", edm::InputTag("ecalEBunpacker","ebDigis")); - desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); - desc.add("EEdigiCollection", edm::InputTag("ecalEBunpacker","eeDigis")); - desc.add("algo", "EcalUncalibRecHitWorkerMaxSample"); - desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); - descriptions.add("ecalMaxSampleUncalibRecHit", desc); +EcalUncalibRecHitWorkerMaxSample::fillDescriptions(edm::ParameterSetDescription& desc, std::string& moduleName) { + + moduleName = "ecalMaxSampleUncalibRecHit"; } diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.h index 897d998ffde45..076590a4874e8 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.h @@ -11,7 +11,7 @@ namespace edm { class ParameterSet; class EventSetup; class Event; - class ConfigurationDescription; + class ParameterSetDescription; } class EcalUncalibRecHitWorkerMaxSample : public EcalUncalibRecHitWorkerBaseClass { @@ -24,12 +24,9 @@ class EcalUncalibRecHitWorkerMaxSample : public EcalUncalibRecHitWorkerBaseClass void set(const edm::EventSetup& es); bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); - void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + void fillDescriptions(edm::ParameterSetDescription& desc, std::string& moduleName); private: - //std::string ebHitCollection_; // secondary name to be given to collection of hits - //std::string eeHitCollection_; // secondary name to be given to collection of hits - EcalUncalibRecHitMaxSampleAlgo ebAlgo_; EcalUncalibRecHitMaxSampleAlgo eeAlgo_; }; diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc index 81ddc31daf4ef..fccfa28114e57 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc @@ -128,49 +128,26 @@ EcalUncalibRecHitWorkerRatio::run( const edm::Event & evt, } void -EcalUncalibRecHitWorkerRatio::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - // ecalRatioUncalibRecHit - edm::ParameterSetDescription desc; - desc.add("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")); - desc.add("EEtimeFitLimits_Upper", 1.4); - desc.add>("EBtimeFitParameters", { - -2.015452, - 3.130702, - -12.3473, - 41.88921, - -82.83944, - 91.01147, - -50.35761, - 11.05621, - }); - desc.add("EEtimeConstantTerm", 0.18); - desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); - desc.add("EBtimeFitLimits_Lower", 0.2); - desc.add("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")); - desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); - desc.add("algo", "EcalUncalibRecHitWorkerRatio"); - desc.add("EBtimeConstantTerm", 0.26); - desc.add("EEtimeFitLimits_Lower", 0.2); - desc.add>("EEtimeFitParameters", { - -2.390548, - 3.553628, - -17.62341, - 67.67538, - -133.213, - 140.7432, - -75.41106, - 16.20277, - }); - desc.add>("EEamplitudeFitParameters", { - 1.89, - 1.4, - }); - desc.add("EBtimeFitLimits_Upper", 1.4); - desc.add>("EBamplitudeFitParameters", { - 1.138, - 1.652, - }); - descriptions.add("ecalRatioUncalibRecHit", desc); +EcalUncalibRecHitWorkerRatio::fillDescriptions(edm::ParameterSetDescription& desc, std::string& moduleName) { + + std::vector dSet1 = {-2.390548,3.553628,-17.62341,67.67538,-133.213,140.7432,-75.41106,16.20277}; + std::vector dSet2 = {-2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621}; + + desc.ifValue(edm::ParameterDescription("algo", "EcalUncalibRechitWorkerRatio", true), + "EcalUncalibRechitWorkerRatio" >> (edm::ParameterDescription("EEtimeFitLimits_Upper", 1.4, true) and + edm::ParameterDescription("EEtimeConstantTerm", 0.18, true) and + edm::ParameterDescription("EBtimeFitLimits_Lower", 0.2, true) and + edm::ParameterDescription("EBtimeConstantTerm", 0.26, true) and + edm::ParameterDescription("EEtimeFitLimits_Lower", 0.2, true) and + edm::ParameterDescription >("EEtimeFitParameters", dSet1, true) and + edm::ParameterDescription>("EEamplitudeFitParameters", {1.89, 1.4}, true) and + edm::ParameterDescription("EBtimeFitLimits_Upper", 1.4, true) and + edm::ParameterDescription>("EBamplitudeFitParameters", {1.138,1.652}, true) and + edm::ParameterDescription>("EBtimeFitParameters", dSet2, true) + ) + ); + + moduleName = "ecalRatioUncalibRecHit"; } #include "FWCore/Framework/interface/MakerMacros.h" diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.h index 9c37534e8956f..2690a492c127d 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.h @@ -19,7 +19,7 @@ namespace edm { class Event; class EventSetup; class ParameterSet; - class ConfigurationDescription; + class ParameterSetDescription; } class EcalUncalibRecHitWorkerRatio : public EcalUncalibRecHitWorkerBaseClass { @@ -32,7 +32,7 @@ class EcalUncalibRecHitWorkerRatio : public EcalUncalibRecHitWorkerBaseClass { void set(const edm::EventSetup& es); bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); - void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + void fillDescriptions(edm::ParameterSetDescription& desc, std::string& moduleName); protected: From 2d0c0a3f8025bd0db7e62ba9cd8203f7fc59caf1 Mon Sep 17 00:00:00 2001 From: Matteo Date: Thu, 19 Feb 2015 23:21:11 +0100 Subject: [PATCH 07/22] added default config --- .../EcalUncalibRecHitWorkerBaseClass.h | 3 +- .../plugins/EcalUncalibRecHitProducer.cc | 63 ++++++++----------- ...calUncalibRecHitWorkerFixedAlphaBetaFit.cc | 28 ++++----- ...EcalUncalibRecHitWorkerFixedAlphaBetaFit.h | 2 +- .../EcalUncalibRecHitWorkerMaxSample.cc | 8 +-- .../EcalUncalibRecHitWorkerMaxSample.h | 2 +- .../plugins/EcalUncalibRecHitWorkerRatio.cc | 24 ++++++- .../plugins/EcalUncalibRecHitWorkerRatio.h | 2 +- 8 files changed, 69 insertions(+), 63 deletions(-) diff --git a/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerBaseClass.h b/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerBaseClass.h index 6cd38e7996593..22bf7ea74ec31 100644 --- a/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerBaseClass.h +++ b/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerBaseClass.h @@ -10,6 +10,7 @@ namespace edm { class EventSetup; class ParameterSet; class ParameterSetDescription; + class ParameterDescriptionNode; } class EcalUncalibRecHitWorkerBaseClass { @@ -22,7 +23,7 @@ class EcalUncalibRecHitWorkerBaseClass { virtual void set(const edm::EventSetup& es) = 0; virtual void set(const edm::Event& evt) {} virtual bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result) = 0; - virtual void fillDescriptions(edm::ParameterSetDescription& desc, std::string& moduleName) {}; + virtual std::auto_ptr fillDescriptions() = 0; }; #endif diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc index d3e374163453a..7338cd55c8ba7 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc @@ -42,32 +42,30 @@ EcalUncalibRecHitProducer::~EcalUncalibRecHitProducer() void EcalUncalibRecHitProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { -// //std::vector -// -// EcalUncalibRecHitFillDescriptionWorkerFactory* factory = EcalUncalibRecHitFillDescriptionWorkerFactory::get(); -// std::vector infos = factory->available(); -// -// for (std::vector::const_iterator itInfos = infos.begin(); itInfos != infos.end(); itInfos++) { -// std::unique_ptr fdWorker(EcalUncalibRecHitFillDescriptionWorkerFactory::get()->create(itInfos->name_)); -// -// edm::ParameterSetDescription desc; -// desc.add("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")); -// desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); -// desc.add("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")); -// desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); -// desc.add("algo", itInfos->name_); -// std::string moduleName("ecalUncalibRechit"); // default name overwritten by each worker fillDescriptions -// fdWorker->fillDescriptions(desc, moduleName); -// desc -// descriptions.add(moduleName, desc); -// } - -// std::vector descs; -// std::vector moduleNames; - EcalUncalibRecHitFillDescriptionWorkerFactory* factory = EcalUncalibRecHitFillDescriptionWorkerFactory::get(); std::vector infos = factory->available(); - + + { + edm::ParameterSetDescription desc; + desc.add("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")); + desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); + desc.add("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")); + desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); + + auto itInfos = infos.begin(); + assert(itInfos != infos.end()); + std::auto_ptr> s; + s = (itInfos->name_ >> EcalUncalibRecHitFillDescriptionWorkerFactory::get()->create(itInfos->name_)->fillDescriptions()); + for (++itInfos; itInfos != infos.end(); ++itInfos) + s = s or itInfos->name_ >> EcalUncalibRecHitFillDescriptionWorkerFactory::get()->create(itInfos->name_)->fillDescriptions(); + + edm::ParameterSetDescription ps0; + ps0.ifValue( edm::ParameterDescription("algo", "EcalUncalibRecHitWorkerRatio", true), s); + desc.add("algoPset", ps0); + + descriptions.addDefault(desc); + } + for (std::vector::const_iterator itInfos = infos.begin(); itInfos != infos.end(); itInfos++) { std::unique_ptr fdWorker(EcalUncalibRecHitFillDescriptionWorkerFactory::get()->create(itInfos->name_)); @@ -76,20 +74,13 @@ void EcalUncalibRecHitProducer::fillDescriptions(edm::ConfigurationDescriptions& desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); desc.add("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")); desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); - //desc.add("algo", itInfos->name_); + desc.add("algo", itInfos->name_); - std::string moduleName("ecalUncalibRechit"); // default name overwritten by each worker fillDescriptions + edm::ParameterSetDescription ps0; + ps0.addNode(fdWorker->fillDescriptions()); + desc.add("algoPset", ps0); - //desc.ifExists(edm::ParameterDescription("algo", itInfos->name_), - //fdWorker->fillDescriptions(desc, moduleName)); - - fdWorker->fillDescriptions(desc, moduleName); - //descs.push_back(desc); - //moduleNames.push_bakc(moduleName); - - //desc.ifExists(edm::ParameterDescription("algo", itInfos->name_, true) - //edm::ParameterSetDescription<>("x", 100, true)); - descriptions.add(moduleName, desc); + descriptions.add("ecal"+itInfos->name_, desc); } } diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc index 8e237962c32f7..e525e9a0bbdb6 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc @@ -39,7 +39,7 @@ EcalUncalibRecHitWorkerFixedAlphaBetaFit::EcalUncalibRecHitWorkerFixedAlphaBetaF alphaEE_= ps.getParameter("alphaEE"); betaEE_= ps.getParameter("betaEE"); - alphabetaFilename_= ps.getParameter("AlphaBetaFilename"); + alphabetaFilename_= ps.getUntrackedParameter("AlphaBetaFilename"); useAlphaBetaArray_=setAlphaBeta(); // set crystalwise values of alpha and beta if ( !useAlphaBetaArray_ ) { edm::LogInfo("EcalUncalibRecHitError") << " No alfa-beta file found. Using the deafult values."; @@ -189,22 +189,16 @@ EcalUncalibRecHitWorkerFixedAlphaBetaFit::run(const edm::Event& evt, return true; } -void -EcalUncalibRecHitWorkerFixedAlphaBetaFit::fillDescriptions(edm::ParameterSetDescription& desc, std::string& moduleName) { - - desc.ifValue(edm::ParameterDescription("algo", "EcalUncalibRechitWorkerFixedAlphaBetaFit", true), - "EcalUncalibRechitWorkerFixedAlphaBetaFit" >> (edm::ParameterDescription("alphaEB", 1.138, true) and - edm::ParameterDescription("alphaEE", 1.89, true) and - edm::ParameterDescription("AlphaBetaFilename", "NOFILE", true) and - edm::ParameterDescription("betaEB", 1.655, true) and - edm::ParameterDescription("MinAmplEndcap", 14.0, true) and - edm::ParameterDescription("MinAmplBarrel", 8.0, true) and - edm::ParameterDescription("betaEE", 1.4, true) and - edm::ParameterDescription("UseDynamicPedestal", true, true) - ) - ); - - moduleName = "ecalFixedAlphaBetaFitUncalibRecHit"; +std::auto_ptr +EcalUncalibRecHitWorkerFixedAlphaBetaFit::fillDescriptions() { + return (edm::ParameterDescription("alphaEB", 1.138, true) and + edm::ParameterDescription("alphaEE", 1.89, true) and + edm::ParameterDescription("AlphaBetaFilename", "NOFILE", false) and + edm::ParameterDescription("betaEB", 1.655, true) and + edm::ParameterDescription("MinAmplEndcap", 14.0, true) and + edm::ParameterDescription("MinAmplBarrel", 8.0, true) and + edm::ParameterDescription("betaEE", 1.4, true) and + edm::ParameterDescription("UseDynamicPedestal", true, true) ); } #include "FWCore/Framework/interface/MakerMacros.h" diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.h index 23577b188f2e0..4953fa8e6e12b 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.h @@ -30,7 +30,7 @@ class EcalUncalibRecHitWorkerFixedAlphaBetaFit : public EcalUncalibRecHitWorkerB void set(const edm::EventSetup& es); bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); - void fillDescriptions(edm::ParameterSetDescription& desc, std::string& moduleName); + std::auto_ptr fillDescriptions(); private: double AmplThrEB_; diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc index b947afe76d470..5a6c6d8733cae 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc @@ -19,6 +19,7 @@ #include #include +#include #include #include @@ -52,10 +53,9 @@ EcalUncalibRecHitWorkerMaxSample::run( const edm::Event & evt, return true; } -void -EcalUncalibRecHitWorkerMaxSample::fillDescriptions(edm::ParameterSetDescription& desc, std::string& moduleName) { - - moduleName = "ecalMaxSampleUncalibRecHit"; +std::auto_ptr +EcalUncalibRecHitWorkerMaxSample::fillDescriptions() { + return std::auto_ptr(new edm::EmptyGroupDescription()); } diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.h index 076590a4874e8..9e86d00b6640d 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.h @@ -24,7 +24,7 @@ class EcalUncalibRecHitWorkerMaxSample : public EcalUncalibRecHitWorkerBaseClass void set(const edm::EventSetup& es); bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); - void fillDescriptions(edm::ParameterSetDescription& desc, std::string& moduleName); + std::auto_ptr fillDescriptions(); private: EcalUncalibRecHitMaxSampleAlgo ebAlgo_; diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc index fccfa28114e57..1e3128846c1ee 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc @@ -127,14 +127,33 @@ EcalUncalibRecHitWorkerRatio::run( const edm::Event & evt, return true; } +std::auto_ptr +EcalUncalibRecHitWorkerRatio::fillDescriptions() { + + std::vector dSet1 = {-2.390548,3.553628,-17.62341,67.67538,-133.213,140.7432,-75.41106,16.20277}; + std::vector dSet2 = {-2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621}; + + return (edm::ParameterDescription("EEtimeFitLimits_Upper", 1.4, true) and + edm::ParameterDescription("EEtimeConstantTerm", 0.18, true) and + edm::ParameterDescription("EBtimeFitLimits_Lower", 0.2, true) and + edm::ParameterDescription("EBtimeConstantTerm", 0.26, true) and + edm::ParameterDescription("EEtimeFitLimits_Lower", 0.2, true) and + edm::ParameterDescription >("EEtimeFitParameters", dSet1, true) and + edm::ParameterDescription>("EEamplitudeFitParameters", {1.89, 1.4}, true) and + edm::ParameterDescription("EBtimeFitLimits_Upper", 1.4, true) and + edm::ParameterDescription>("EBamplitudeFitParameters", {1.138,1.652}, true) and + edm::ParameterDescription>("EBtimeFitParameters", dSet2, true) ); +} + +/* void EcalUncalibRecHitWorkerRatio::fillDescriptions(edm::ParameterSetDescription& desc, std::string& moduleName) { std::vector dSet1 = {-2.390548,3.553628,-17.62341,67.67538,-133.213,140.7432,-75.41106,16.20277}; std::vector dSet2 = {-2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621}; - desc.ifValue(edm::ParameterDescription("algo", "EcalUncalibRechitWorkerRatio", true), - "EcalUncalibRechitWorkerRatio" >> (edm::ParameterDescription("EEtimeFitLimits_Upper", 1.4, true) and + desc.ifValue(edm::ParameterDescription("algo", "EcalUncalibRecHitWorkerRatio", true), + "EcalUncalibRecHitWorkerRatio" >> (edm::ParameterDescription("EEtimeFitLimits_Upper", 1.4, true) and edm::ParameterDescription("EEtimeConstantTerm", 0.18, true) and edm::ParameterDescription("EBtimeFitLimits_Lower", 0.2, true) and edm::ParameterDescription("EBtimeConstantTerm", 0.26, true) and @@ -149,6 +168,7 @@ EcalUncalibRecHitWorkerRatio::fillDescriptions(edm::ParameterSetDescription& des moduleName = "ecalRatioUncalibRecHit"; } +*/ #include "FWCore/Framework/interface/MakerMacros.h" #include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerFactory.h" diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.h index 2690a492c127d..07b0868ff44d3 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.h @@ -32,7 +32,7 @@ class EcalUncalibRecHitWorkerRatio : public EcalUncalibRecHitWorkerBaseClass { void set(const edm::EventSetup& es); bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); - void fillDescriptions(edm::ParameterSetDescription& desc, std::string& moduleName); + std::auto_ptr fillDescriptions(); protected: From 85254776426d36836ea3abbafefe40e6b273b08f Mon Sep 17 00:00:00 2001 From: Matteo Date: Fri, 20 Feb 2015 11:50:57 +0100 Subject: [PATCH 08/22] final version --- .../EcalUncalibRecHitWorkerBaseClass.h | 4 +- .../plugins/EcalUncalibRecHitProducer.cc | 24 +- .../plugins/EcalUncalibRecHitWorkerAnalFit.cc | 21 +- .../plugins/EcalUncalibRecHitWorkerAnalFit.h | 4 +- ...calUncalibRecHitWorkerFixedAlphaBetaFit.cc | 25 +- ...EcalUncalibRecHitWorkerFixedAlphaBetaFit.h | 4 +- .../plugins/EcalUncalibRecHitWorkerGlobal.cc | 134 ++-- .../plugins/EcalUncalibRecHitWorkerGlobal.h | 5 +- .../EcalUncalibRecHitWorkerMaxSample.cc | 8 +- .../EcalUncalibRecHitWorkerMaxSample.h | 26 +- .../EcalUncalibRecHitWorkerMultiFit.cc | 600 +++--------------- .../plugins/EcalUncalibRecHitWorkerMultiFit.h | 4 +- .../plugins/EcalUncalibRecHitWorkerRatio.cc | 52 +- .../plugins/EcalUncalibRecHitWorkerRatio.h | 4 +- .../plugins/EcalUncalibRecHitWorkerWeights.cc | 21 +- .../plugins/EcalUncalibRecHitWorkerWeights.h | 4 +- 16 files changed, 227 insertions(+), 713 deletions(-) diff --git a/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerBaseClass.h b/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerBaseClass.h index 22bf7ea74ec31..2749c4dfe294e 100644 --- a/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerBaseClass.h +++ b/RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerBaseClass.h @@ -10,7 +10,7 @@ namespace edm { class EventSetup; class ParameterSet; class ParameterSetDescription; - class ParameterDescriptionNode; + //class ParameterDescriptionNode; } class EcalUncalibRecHitWorkerBaseClass { @@ -23,7 +23,7 @@ class EcalUncalibRecHitWorkerBaseClass { virtual void set(const edm::EventSetup& es) = 0; virtual void set(const edm::Event& evt) {} virtual bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result) = 0; - virtual std::auto_ptr fillDescriptions() = 0; + virtual edm::ParameterSetDescription getAlgoDescription() = 0; }; #endif diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc index 7338cd55c8ba7..6ed0bccc39411 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc @@ -31,8 +31,10 @@ EcalUncalibRecHitProducer::EcalUncalibRecHitProducer(const edm::ParameterSet& ps eeDigiCollectionToken_ = consumes(ps.getParameter("EEdigiCollection")); std::string componentType = ps.getParameter("algo"); + edm::ParameterSet algoConf = ps.getParameter("algoPSet"); + edm::ConsumesCollector c{consumesCollector()}; - worker_ = EcalUncalibRecHitWorkerFactory::get()->create(componentType, ps, c); + worker_ = EcalUncalibRecHitWorkerFactory::get()->create(componentType, algoConf, c); } EcalUncalibRecHitProducer::~EcalUncalibRecHitProducer() @@ -54,14 +56,14 @@ void EcalUncalibRecHitProducer::fillDescriptions(edm::ConfigurationDescriptions& auto itInfos = infos.begin(); assert(itInfos != infos.end()); + std::auto_ptr> s; - s = (itInfos->name_ >> EcalUncalibRecHitFillDescriptionWorkerFactory::get()->create(itInfos->name_)->fillDescriptions()); + { + s = itInfos->name_ >> edm::ParameterDescription("algoPset", EcalUncalibRecHitFillDescriptionWorkerFactory::get()->create(itInfos->name_)->getAlgoDescription(), true); + } for (++itInfos; itInfos != infos.end(); ++itInfos) - s = s or itInfos->name_ >> EcalUncalibRecHitFillDescriptionWorkerFactory::get()->create(itInfos->name_)->fillDescriptions(); - - edm::ParameterSetDescription ps0; - ps0.ifValue( edm::ParameterDescription("algo", "EcalUncalibRecHitWorkerRatio", true), s); - desc.add("algoPset", ps0); + s = s or itInfos->name_ >> edm::ParameterDescription("algoPset", EcalUncalibRecHitFillDescriptionWorkerFactory::get()->create(itInfos->name_)->getAlgoDescription(), true); + desc.ifValue(edm::ParameterDescription("algo", "EcalUncalibRecHitWorkerWeights", true), s); descriptions.addDefault(desc); } @@ -75,12 +77,10 @@ void EcalUncalibRecHitProducer::fillDescriptions(edm::ConfigurationDescriptions& desc.add("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")); desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); desc.add("algo", itInfos->name_); + desc.add("algoPSet", fdWorker->getAlgoDescription()); - edm::ParameterSetDescription ps0; - ps0.addNode(fdWorker->fillDescriptions()); - desc.add("algoPset", ps0); - - descriptions.add("ecal"+itInfos->name_, desc); + std::string algoName = itInfos->name_.substr(itInfos->name_.find("Worker")+6, itInfos->name_.length()); + descriptions.add("ecal"+algoName+"UncalibRecHit", desc); } } diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.cc index 82d05240d87b3..162c366fe0d31 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.cc @@ -137,16 +137,17 @@ EcalUncalibRecHitWorkerAnalFit::run( const edm::Event& evt, return true; } -void -EcalUncalibRecHitWorkerAnalFit::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - // ecalAnalFitUncalibRecHit - edm::ParameterSetDescription desc; - desc.add("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")); - desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); - desc.add("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")); - desc.add("algo", "EcalUncalibRecHitWorkerAnalFit"); - desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); - descriptions.add("ecalAnalFitUncalibRecHit", desc); +edm::ParameterSetDescription +EcalUncalibRecHitWorkerAnalFit::getAlgoDescription() { + + edm::ParameterSetDescription pset; +//pset.addNode(edm::ParameterSet("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")) and +// edm::ParameterSet("EEhitCollection", "EcalUncalibRecHitsEE") and +// edm::ParameterSet("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")) and +// edm::ParameterSet("algo", "EcalUncalibRecHitWorkerAnalFit") and +// edm::ParameterSet("EBhitCollection", "EcalUncalibRecHitsEB")); +// + return pset; } #include "FWCore/Framework/interface/MakerMacros.h" diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.h index 8139485ec9ab9..f6ef58f402117 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.h @@ -21,7 +21,7 @@ namespace edm { class Event; class EventSetup; class ParameterSet; - class ConfigurationDescription; + class ParameterSetDescription; } class EcalUncalibRecHitWorkerAnalFit : public EcalUncalibRecHitWorkerBaseClass { @@ -34,7 +34,7 @@ class EcalUncalibRecHitWorkerAnalFit : public EcalUncalibRecHitWorkerBaseClass { void set(const edm::EventSetup& es); bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); - void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + edm::ParameterSetDescription getAlgoDescription(); private: EcalUncalibRecHitRecAnalFitAlgo algoEB_; diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc index e525e9a0bbdb6..b51d4d51801c0 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc @@ -189,16 +189,21 @@ EcalUncalibRecHitWorkerFixedAlphaBetaFit::run(const edm::Event& evt, return true; } -std::auto_ptr -EcalUncalibRecHitWorkerFixedAlphaBetaFit::fillDescriptions() { - return (edm::ParameterDescription("alphaEB", 1.138, true) and - edm::ParameterDescription("alphaEE", 1.89, true) and - edm::ParameterDescription("AlphaBetaFilename", "NOFILE", false) and - edm::ParameterDescription("betaEB", 1.655, true) and - edm::ParameterDescription("MinAmplEndcap", 14.0, true) and - edm::ParameterDescription("MinAmplBarrel", 8.0, true) and - edm::ParameterDescription("betaEE", 1.4, true) and - edm::ParameterDescription("UseDynamicPedestal", true, true) ); +edm::ParameterSetDescription +EcalUncalibRecHitWorkerFixedAlphaBetaFit::getAlgoDescription() { + + edm::ParameterSetDescription pset; + + pset.addNode(edm::ParameterDescription("alphaEB", 1.138, true) and + edm::ParameterDescription("alphaEE", 1.89, true) and + edm::ParameterDescription("AlphaBetaFilename", "NOFILE", false) and + edm::ParameterDescription("betaEB", 1.655, true) and + edm::ParameterDescription("MinAmplEndcap", 14.0, true) and + edm::ParameterDescription("MinAmplBarrel", 8.0, true) and + edm::ParameterDescription("betaEE", 1.4, true) and + edm::ParameterDescription("UseDynamicPedestal", true, true) ); + + return pset; } #include "FWCore/Framework/interface/MakerMacros.h" diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.h index 4953fa8e6e12b..b7b24c835b426 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.h @@ -29,8 +29,8 @@ class EcalUncalibRecHitWorkerFixedAlphaBetaFit : public EcalUncalibRecHitWorkerB void set(const edm::EventSetup& es); bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); - - std::auto_ptr fillDescriptions(); + + edm::ParameterSetDescription getAlgoDescription(); private: double AmplThrEB_; diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.cc index d7b58c1885fa9..65007ead79a7e 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.cc @@ -510,103 +510,43 @@ EcalUncalibRecHitWorkerGlobal::run( const edm::Event & evt, return true; } -void -EcalUncalibRecHitWorkerGlobal::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - // ecalGlobalUncalibRecHit - edm::ParameterSetDescription desc; - desc.add("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")); - desc.add>("eePulseShape", { - 5.2e-05, - -5.26e-05, - 6.66e-05, - 0.1168, - 0.7575, - 1.0, - 0.8876, - 0.6732, - 0.4741, - 0.3194, - }); - desc.add>("EBtimeFitParameters", { - -2.015452, - 3.130702, - -12.3473, - 41.88921, - -82.83944, - 91.01147, - -50.35761, - 11.05621, - }); - desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); - desc.add("outOfTimeThresholdGain61pEB", 5); - desc.add("amplitudeThresholdEE", 10); - desc.add("EBtimeConstantTerm", 0.6); - desc.add("outOfTimeThresholdGain61pEE", 1000); - desc.add("ebSpikeThreshold", 1.042); - desc.add("EBtimeNconst", 28.5); - desc.add("kPoorRecoFlagEB", true); - desc.add>("ebPulseShape", { - 5.2e-05, - -5.26e-05, - 6.66e-05, - 0.1168, - 0.7575, - 1.0, - 0.8876, - 0.6732, - 0.4741, - 0.3194, - }); - desc.add("EBtimeFitLimits_Lower", 0.2); - desc.add("kPoorRecoFlagEE", false); - desc.add("chi2ThreshEB_", 36.0); - desc.add("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")); - desc.add>("EEtimeFitParameters", { - -2.390548, - 3.553628, - -17.62341, - 67.67538, - -133.213, - 140.7432, - -75.41106, - 16.20277, - }); - desc.add("outOfTimeThresholdGain61mEE", 1000); - desc.add>("EEchi2Parameters", { - 2.122, - 0.022, - 2.122, - 0.022, - }); - desc.add("outOfTimeThresholdGain12mEE", 1000); - desc.add("outOfTimeThresholdGain12mEB", 5); - desc.add("EEtimeFitLimits_Upper", 1.4); - desc.add("EEtimeFitLimits_Lower", 0.2); - desc.add>("EEamplitudeFitParameters", { - 1.89, - 1.4, - }); - desc.add>("EBamplitudeFitParameters", { - 1.138, - 1.652, - }); - desc.add("amplitudeThresholdEB", 10); - desc.add("outOfTimeThresholdGain12pEE", 1000); - desc.add("outOfTimeThresholdGain12pEB", 5); - desc.add("EEtimeNconst", 31.8); - desc.add("outOfTimeThresholdGain61mEB", 5); - desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); - desc.add>("EBchi2Parameters", { - 2.122, - 0.022, - 2.122, - 0.022, - }); - desc.add("EEtimeConstantTerm", 1.0); - desc.add("algo", "EcalUncalibRecHitWorkerGlobal"); - desc.add("chi2ThreshEE_", 95.0); - desc.add("EBtimeFitLimits_Upper", 1.4); - descriptions.add("ecalGlobalUncalibRecHit", desc); +edm::ParameterSetDescription +EcalUncalibRecHitWorkerGlobal::getAlgoDescription() { + + edm::ParameterSetDescription pset; + pset.addNode(edm::ParameterDescription>("eePulseShape", {5.2e-05,-5.26e-05,6.66e-05,0.1168,0.7575,1.0,0.8876,0.6732,0.4741,0.3194}, true) and + edm::ParameterDescription>("EBtimeFitParameters", {-2.015452,3.130702,-12.3473,41.88921,-82.83944,91.01147,-50.35761,11.05621}, true) and + edm::ParameterDescription("outOfTimeThresholdGain61pEB", 5, true) and + edm::ParameterDescription("amplitudeThresholdEE", 10, true) and + edm::ParameterDescription("EBtimeConstantTerm", 0.6, true) and + edm::ParameterDescription("outOfTimeThresholdGain61pEE", 1000, true) and + edm::ParameterDescription("ebSpikeThreshold", 1.042, true) and + edm::ParameterDescription("EBtimeNconst", 28.5, true) and + edm::ParameterDescription("kPoorRecoFlagEB", true, true) and + edm::ParameterDescription>("ebPulseShape", {5.2e-05,-5.26e-05,6.66e-05,0.1168,0.7575,1.0,0.8876,0.6732,0.4741,0.3194}, true) and + edm::ParameterDescription("EBtimeFitLimits_Lower", 0.2, true) and + edm::ParameterDescription("kPoorRecoFlagEE", false, true) and + edm::ParameterDescription("chi2ThreshEB_", 36.0, true) and + edm::ParameterDescription>("EEtimeFitParameters", {-2.390548,3.553628,-17.62341,67.67538,-133.213,140.7432,-75.41106,16.20277}, true) and + edm::ParameterDescription("outOfTimeThresholdGain61mEE", 1000, true) and + edm::ParameterDescription>("EEchi2Parameters", {2.122,0.022,2.122,0.022}, true) and + edm::ParameterDescription("outOfTimeThresholdGain12mEE", 1000, true) and + edm::ParameterDescription("outOfTimeThresholdGain12mEB", 5, true) and + edm::ParameterDescription("EEtimeFitLimits_Upper", 1.4, true) and + edm::ParameterDescription("EEtimeFitLimits_Lower", 0.2, true) and + edm::ParameterDescription>("EEamplitudeFitParameters", {1.89,1.4}, true) and + edm::ParameterDescription>("EBamplitudeFitParameters", {1.138,1.652}, true) and + edm::ParameterDescription("amplitudeThresholdEB", 10, true) and + edm::ParameterDescription("outOfTimeThresholdGain12pEE", 1000, true) and + edm::ParameterDescription("outOfTimeThresholdGain12pEB", 5, true) and + edm::ParameterDescription("EEtimeNconst", 31.8, true) and + edm::ParameterDescription("outOfTimeThresholdGain61mEB", 5, true) and + edm::ParameterDescription>("EBchi2Parameters", {2.122,0.022,2.122,0.022}, true) and + edm::ParameterDescription("EEtimeConstantTerm", 1.0, true) and + edm::ParameterDescription("chi2ThreshEE_", 95.0, true) and + edm::ParameterDescription("EBtimeFitLimits_Upper", 1.4, true)); + + return pset; } diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.h index 8c76aa545f3ca..5297de816e0fa 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.h @@ -31,7 +31,7 @@ namespace edm { class Event; class EventSetup; class ParameterSet; - class ConfigurationDescription; + class ParameterSetDescription; } class EcalUncalibRecHitWorkerGlobal : public EcalUncalibRecHitWorkerBaseClass { @@ -45,8 +45,7 @@ class EcalUncalibRecHitWorkerGlobal : public EcalUncalibRecHitWorkerBaseClass { void set(const edm::EventSetup& es); bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); - void fillDescriptions(edm::ConfigurationDescriptions& descriptions); - + edm::ParameterSetDescription getAlgoDescription(); protected: double pedVec[3]; diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc index 5a6c6d8733cae..50a56242112c4 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc @@ -53,9 +53,11 @@ EcalUncalibRecHitWorkerMaxSample::run( const edm::Event & evt, return true; } -std::auto_ptr -EcalUncalibRecHitWorkerMaxSample::fillDescriptions() { - return std::auto_ptr(new edm::EmptyGroupDescription()); +edm::ParameterSetDescription +EcalUncalibRecHitWorkerMaxSample::getAlgoDescription() { + + edm::ParameterSetDescription pset; + return pset;//.addNode(std::auto_ptr(new edm::EmptyGroupDescription())); } diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.h index 9e86d00b6640d..3d784cb06234f 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.h @@ -16,18 +16,18 @@ namespace edm { class EcalUncalibRecHitWorkerMaxSample : public EcalUncalibRecHitWorkerBaseClass { - public: - EcalUncalibRecHitWorkerMaxSample(const edm::ParameterSet& ps,edm::ConsumesCollector& c); - EcalUncalibRecHitWorkerMaxSample() {}; - virtual ~EcalUncalibRecHitWorkerMaxSample() {}; - - void set(const edm::EventSetup& es); - bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); - - std::auto_ptr fillDescriptions(); - private: - - EcalUncalibRecHitMaxSampleAlgo ebAlgo_; - EcalUncalibRecHitMaxSampleAlgo eeAlgo_; + public: + EcalUncalibRecHitWorkerMaxSample(const edm::ParameterSet& ps,edm::ConsumesCollector& c); + EcalUncalibRecHitWorkerMaxSample() {}; + virtual ~EcalUncalibRecHitWorkerMaxSample() {}; + + void set(const edm::EventSetup& es); + bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); + + edm::ParameterSetDescription getAlgoDescription(); + private: + + EcalUncalibRecHitMaxSampleAlgo ebAlgo_; + EcalUncalibRecHitMaxSampleAlgo eeAlgo_; }; #endif diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.cc index d891fc8f1c264..fd7106f074e93 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.cc @@ -573,512 +573,100 @@ const SampleMatrix &EcalUncalibRecHitWorkerMultiFit::noisecor(bool barrel, int g } -void EcalUncalibRecHitWorkerMultiFit::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - - edm::ParameterSetDescription desc; - desc.add("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")); - desc.add>("eePulseShape", { - 5.2e-05, - -5.26e-05, - 6.66e-05, - 0.1168, - 0.7575, - 1.0, - 0.8876, - 0.6732, - 0.4741, - 0.3194, - }); - { - edm::ParameterSetDescription psd0; - psd0.add("EcalPreMixStage2", false); - psd0.add>("EECorrNoiseMatrixG01", { - 1.0, - 0.72698, - 0.62048, - 0.55691, - 0.51848, - 0.49147, - 0.47813, - 0.47007, - 0.46621, - 0.46265, - }); - psd0.add("EcalPreMixStage1", false); - psd0.add>("EECorrNoiseMatrixG06", { - 1.0, - 0.71217, - 0.47464, - 0.34056, - 0.26282, - 0.20287, - 0.17734, - 0.16256, - 0.15618, - 0.14443, - }); - psd0.add>("EBCorrNoiseMatrixG01", { - 1.0, - 0.73354, - 0.64442, - 0.58851, - 0.55425, - 0.53082, - 0.51916, - 0.51097, - 0.50732, - 0.50409, - }); - psd0.add>("EBCorrNoiseMatrixG06", { - 1.0, - 0.70946, - 0.58021, - 0.49846, - 0.45006, - 0.41366, - 0.39699, - 0.38478, - 0.37847, - 0.37055, - }); - psd0.add("EBdigiCollection", ""); - psd0.add>("EEPulseShapeCovariance", { - 3.941e-05, - 3.333e-05, - 0.0, - -1.449e-05, - -1.661e-05, - -1.424e-05, - -1.183e-05, - -6.842e-06, - -4.915e-06, - -3.411e-06, - 0.0, - 0.0, - 3.333e-05, - 2.862e-05, - 0.0, - -1.244e-05, - -1.431e-05, - -1.233e-05, - -1.032e-05, - -5.883e-06, - -4.154e-06, - -2.902e-06, - -2.128e-06, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - -1.449e-05, - -1.244e-05, - 0.0, - 5.84e-06, - 6.649e-06, - 5.72e-06, - 4.812e-06, - 2.708e-06, - 1.869e-06, - 1.33e-06, - 9.186e-07, - 6.446e-07, - -1.661e-05, - -1.431e-05, - 0.0, - 6.649e-06, - 7.966e-06, - 6.898e-06, - 5.794e-06, - 3.157e-06, - 2.184e-06, - 1.567e-06, - 1.084e-06, - 7.575e-07, - -1.424e-05, - -1.233e-05, - 0.0, - 5.72e-06, - 6.898e-06, - 6.341e-06, - 5.347e-06, - 2.859e-06, - 1.991e-06, - 1.431e-06, - 9.839e-07, - 6.886e-07, - -1.183e-05, - -1.032e-05, - 0.0, - 4.812e-06, - 5.794e-06, - 5.347e-06, - 4.854e-06, - 2.628e-06, - 1.809e-06, - 1.289e-06, - 9.02e-07, - 6.146e-07, - -6.842e-06, - -5.883e-06, - 0.0, - 2.708e-06, - 3.157e-06, - 2.859e-06, - 2.628e-06, - 1.863e-06, - 1.296e-06, - 8.882e-07, - 6.108e-07, - 4.283e-07, - -4.915e-06, - -4.154e-06, - 0.0, - 1.869e-06, - 2.184e-06, - 1.991e-06, - 1.809e-06, - 1.296e-06, - 1.217e-06, - 8.669e-07, - 5.751e-07, - 3.882e-07, - -3.411e-06, - -2.902e-06, - 0.0, - 1.33e-06, - 1.567e-06, - 1.431e-06, - 1.289e-06, - 8.882e-07, - 8.669e-07, - 9.522e-07, - 6.717e-07, - 4.293e-07, - 0.0, - -2.128e-06, - 0.0, - 9.186e-07, - 1.084e-06, - 9.839e-07, - 9.02e-07, - 6.108e-07, - 5.751e-07, - 6.717e-07, - 7.911e-07, - 5.493e-07, - 0.0, - 0.0, - 0.0, - 6.446e-07, - 7.575e-07, - 6.886e-07, - 6.146e-07, - 4.283e-07, - 3.882e-07, - 4.293e-07, - 5.493e-07, - 7.027e-07, - }); - psd0.add>("EBPulseShapeTemplate", { - 0.0113979, - 0.758151, - 1.0, - 0.887744, - 0.673548, - 0.474332, - 0.319561, - 0.215144, - 0.147464, - 0.101087, - 0.0693181, - 0.0475044, - }); - psd0.add("ESdigiCollection", ""); - psd0.add>("EEPulseShapeTemplate", { - 0.116442, - 0.756246, - 1.0, - 0.897182, - 0.686831, - 0.491506, - 0.344111, - 0.245731, - 0.174115, - 0.123361, - 0.0874288, - 0.061957, - }); - psd0.add>("EBCorrNoiseMatrixG12", { - 1.0, - 0.71073, - 0.55721, - 0.46089, - 0.40449, - 0.35931, - 0.33924, - 0.32439, - 0.31581, - 0.30481, - }); - psd0.add>("EECorrNoiseMatrixG12", { - 1.0, - 0.71373, - 0.44825, - 0.30152, - 0.21609, - 0.14786, - 0.11772, - 0.10165, - 0.09465, - 0.08098, - }); - psd0.add("EEdigiCollection", ""); - psd0.add>("EBPulseShapeCovariance", { - 3.001e-06, - 1.233e-05, - 0.0, - -4.416e-06, - -4.571e-06, - -3.614e-06, - -2.636e-06, - -1.286e-06, - -8.41e-07, - -5.296e-07, - 0.0, - 0.0, - 1.233e-05, - 6.154e-05, - 0.0, - -2.2e-05, - -2.309e-05, - -1.838e-05, - -1.373e-05, - -7.334e-06, - -5.088e-06, - -3.745e-06, - -2.428e-06, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - -4.416e-06, - -2.2e-05, - 0.0, - 8.319e-06, - 8.545e-06, - 6.792e-06, - 5.059e-06, - 2.678e-06, - 1.816e-06, - 1.223e-06, - 8.245e-07, - 5.589e-07, - -4.571e-06, - -2.309e-05, - 0.0, - 8.545e-06, - 9.182e-06, - 7.219e-06, - 5.388e-06, - 2.853e-06, - 1.944e-06, - 1.324e-06, - 9.083e-07, - 6.335e-07, - -3.614e-06, - -1.838e-05, - 0.0, - 6.792e-06, - 7.219e-06, - 6.016e-06, - 4.437e-06, - 2.385e-06, - 1.636e-06, - 1.118e-06, - 7.754e-07, - 5.556e-07, - -2.636e-06, - -1.373e-05, - 0.0, - 5.059e-06, - 5.388e-06, - 4.437e-06, - 3.602e-06, - 1.917e-06, - 1.322e-06, - 9.079e-07, - 6.529e-07, - 4.752e-07, - -1.286e-06, - -7.334e-06, - 0.0, - 2.678e-06, - 2.853e-06, - 2.385e-06, - 1.917e-06, - 1.375e-06, - 9.1e-07, - 6.455e-07, - 4.693e-07, - 3.657e-07, - -8.41e-07, - -5.088e-06, - 0.0, - 1.816e-06, - 1.944e-06, - 1.636e-06, - 1.322e-06, - 9.1e-07, - 9.115e-07, - 6.062e-07, - 4.436e-07, - 3.422e-07, - -5.296e-07, - -3.745e-06, - 0.0, - 1.223e-06, - 1.324e-06, - 1.118e-06, - 9.079e-07, - 6.455e-07, - 6.062e-07, - 7.217e-07, - 4.862e-07, - 3.768e-07, - 0.0, - -2.428e-06, - 0.0, - 8.245e-07, - 9.083e-07, - 7.754e-07, - 6.529e-07, - 4.693e-07, - 4.436e-07, - 4.862e-07, - 6.509e-07, - 4.418e-07, - 0.0, - 0.0, - 0.0, - 5.589e-07, - 6.335e-07, - 5.556e-07, - 4.752e-07, - 3.657e-07, - 3.422e-07, - 3.768e-07, - 4.418e-07, - 6.142e-07, - }); - psd0.addUntracked("UseLCcorrection", true); - desc.add("EcalPulseShapeParameters", psd0); - } - desc.add>("EBtimeFitParameters", { - -2.015452, - 3.130702, - -12.3473, - 41.88921, - -82.83944, - 91.01147, - -50.35761, - 11.05621, - }); - desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); - desc.add("outOfTimeThresholdGain61pEB", 5); - desc.add("amplitudeThresholdEE", 10); - desc.add("EBtimeConstantTerm", 0.6); - desc.add("EEtimeFitLimits_Lower", 0.2); - desc.add("outOfTimeThresholdGain61pEE", 1000); - desc.add("ebSpikeThreshold", 1.042); - desc.add("EBtimeNconst", 28.5); - desc.add("ampErrorCalculation", true); - desc.add("kPoorRecoFlagEB", true); - desc.add>("ebPulseShape", { - 5.2e-05, - -5.26e-05, - 6.66e-05, - 0.1168, - 0.7575, - 1.0, - 0.8876, - 0.6732, - 0.4741, - 0.3194, - }); - desc.add("EBtimeFitLimits_Lower", 0.2); - desc.add("kPoorRecoFlagEE", false); - desc.add("chi2ThreshEB_", 65.0); - desc.add("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")); - desc.add>("EEtimeFitParameters", { - -2.390548, - 3.553628, - -17.62341, - 67.67538, - -133.213, - 140.7432, - -75.41106, - 16.20277, - }); - desc.add("useLumiInfoRunHeader", true); - desc.add>("activeBXs", { - -5, - -4, - -3, - -2, - -1, - 0, - 1, - 2, - 3, - 4, - }); - desc.add("algo", "EcalUncalibRecHitWorkerMultiFit"); - desc.add("outOfTimeThresholdGain12mEE", 1000); - desc.add("outOfTimeThresholdGain12mEB", 5); - desc.add("EEtimeFitLimits_Upper", 1.4); - desc.add("prefitMaxChiSqEB", 25.0); - desc.add>("EEamplitudeFitParameters", { - 1.89, - 1.4, - }); - desc.add("prefitMaxChiSqEE", 10.0); - desc.add>("EBamplitudeFitParameters", { - 1.138, - 1.652, - }); - desc.add("EBtimeFitLimits_Upper", 1.4); - desc.add("timealgo", "RatioMethod"); - desc.add("amplitudeThresholdEB", 10); - desc.add("outOfTimeThresholdGain12pEE", 1000); - desc.add("outOfTimeThresholdGain12pEB", 5); - desc.add("EEtimeNconst", 31.8); - desc.add("outOfTimeThresholdGain61mEB", 5); - desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); - desc.add("outOfTimeThresholdGain61mEE", 1000); - desc.add("EEtimeConstantTerm", 1.0); - desc.add("chi2ThreshEE_", 50.0); - desc.add("doPrefitEE", false); - desc.add("doPrefitEB", false); - descriptions.add("ecalMultiFitUncalibRecHit", desc); - +edm::ParameterSetDescription +EcalUncalibRecHitWorkerMultiFit::getAlgoDescription() { + + edm::ParameterSetDescription psd0; + edm::ParameterSetDescription psd1; + psd1.addNode(edm::ParameterDescription>("EBPulseShapeTemplate", {1.13979e-02, 7.58151e-01, 1.00000e+00, 8.87744e-01, 6.73548e-01, 4.74332e-01, 3.19561e-01, 2.15144e-01, 1.47464e-01, 1.01087e-01, 6.93181e-02, 4.75044e-02}, true) and + edm::ParameterDescription>("EEPulseShapeTemplate", {1.16442e-01, 7.56246e-01, 1.00000e+00, 8.97182e-01, 6.86831e-01, 4.91506e-01, 3.44111e-01, 2.45731e-01, 1.74115e-01, 1.23361e-01, 8.74288e-02, 6.19570e-02}, true)); + psd0.add("ecal_pulse_shape_parameters", psd1); + + edm::ParameterSetDescription psd2; + psd2.addNode(edm::ParameterDescription("EEdigiCollection", "", true) and + edm::ParameterDescription("EBdigiCollection", "", true) and + edm::ParameterDescription("ESdigiCollection", "", true) and + edm::ParameterDescription("UseLCcorrection", true, true) and + edm::ParameterDescription>("EBCorrNoiseMatrixG12", {1.00000, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 }, true) and + edm::ParameterDescription>("EECorrNoiseMatrixG12", {1.00000, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 }, true) and + edm::ParameterDescription>("EBCorrNoiseMatrixG06", {1.00000, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 }, true) and + edm::ParameterDescription>("EECorrNoiseMatrixG06", {1.00000, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 }, true) and + edm::ParameterDescription>("EBCorrNoiseMatrixG01", {1.00000, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 }, true) and + edm::ParameterDescription>("EECorrNoiseMatrixG01", {1.00000, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 }, true) and + edm::ParameterDescription("EcalPreMixStage1", false, true) and + edm::ParameterDescription("EcalPreMixStage2", false, true)); + psd0.add("ecal_digi_parameters", psd2); + + edm::ParameterSetDescription psd3; + psd3.addNode(edm::ParameterDescription>("EBPulseShapeCovariance", {3.001e-06, 1.233e-05, 0.000e+00, -4.416e-06, -4.571e-06, -3.614e-06, -2.636e-06, -1.286e-06, -8.410e-07, -5.296e-07, 0.000e+00, 0.000e+00, + 1.233e-05, 6.154e-05, 0.000e+00, -2.200e-05, -2.309e-05, -1.838e-05, -1.373e-05, -7.334e-06, -5.088e-06, -3.745e-06, -2.428e-06, 0.000e+00, + 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, + -4.416e-06, -2.200e-05, 0.000e+00, 8.319e-06, 8.545e-06, 6.792e-06, 5.059e-06, 2.678e-06, 1.816e-06, 1.223e-06, 8.245e-07, 5.589e-07, + -4.571e-06, -2.309e-05, 0.000e+00, 8.545e-06, 9.182e-06, 7.219e-06, 5.388e-06, 2.853e-06, 1.944e-06, 1.324e-06, 9.083e-07, 6.335e-07, + -3.614e-06, -1.838e-05, 0.000e+00, 6.792e-06, 7.219e-06, 6.016e-06, 4.437e-06, 2.385e-06, 1.636e-06, 1.118e-06, 7.754e-07, 5.556e-07, + -2.636e-06, -1.373e-05, 0.000e+00, 5.059e-06, 5.388e-06, 4.437e-06, 3.602e-06, 1.917e-06, 1.322e-06, 9.079e-07, 6.529e-07, 4.752e-07, + -1.286e-06, -7.334e-06, 0.000e+00, 2.678e-06, 2.853e-06, 2.385e-06, 1.917e-06, 1.375e-06, 9.100e-07, 6.455e-07, 4.693e-07, 3.657e-07, + -8.410e-07, -5.088e-06, 0.000e+00, 1.816e-06, 1.944e-06, 1.636e-06, 1.322e-06, 9.100e-07, 9.115e-07, 6.062e-07, 4.436e-07, 3.422e-07, + -5.296e-07, -3.745e-06, 0.000e+00, 1.223e-06, 1.324e-06, 1.118e-06, 9.079e-07, 6.455e-07, 6.062e-07, 7.217e-07, 4.862e-07, 3.768e-07, + 0.000e+00, -2.428e-06, 0.000e+00, 8.245e-07, 9.083e-07, 7.754e-07, 6.529e-07, 4.693e-07, 4.436e-07, 4.862e-07, 6.509e-07, 4.418e-07, + 0.000e+00, 0.000e+00, 0.000e+00, 5.589e-07, 6.335e-07, 5.556e-07, 4.752e-07, 3.657e-07, 3.422e-07, 3.768e-07, 4.418e-07, 6.142e-07}, true) and + edm::ParameterDescription>("EEPulseShapeCovariance", {3.941e-05, 3.333e-05, 0.000e+00, -1.449e-05, -1.661e-05, -1.424e-05, -1.183e-05, -6.842e-06, -4.915e-06, -3.411e-06, 0.000e+00, 0.000e+00, + 3.333e-05, 2.862e-05, 0.000e+00, -1.244e-05, -1.431e-05, -1.233e-05, -1.032e-05, -5.883e-06, -4.154e-06, -2.902e-06, -2.128e-06, 0.000e+00, + 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, + -1.449e-05, -1.244e-05, 0.000e+00, 5.840e-06, 6.649e-06, 5.720e-06, 4.812e-06, 2.708e-06, 1.869e-06, 1.330e-06, 9.186e-07, 6.446e-07, + -1.661e-05, -1.431e-05, 0.000e+00, 6.649e-06, 7.966e-06, 6.898e-06, 5.794e-06, 3.157e-06, 2.184e-06, 1.567e-06, 1.084e-06, 7.575e-07, + -1.424e-05, -1.233e-05, 0.000e+00, 5.720e-06, 6.898e-06, 6.341e-06, 5.347e-06, 2.859e-06, 1.991e-06, 1.431e-06, 9.839e-07, 6.886e-07, + -1.183e-05, -1.032e-05, 0.000e+00, 4.812e-06, 5.794e-06, 5.347e-06, 4.854e-06, 2.628e-06, 1.809e-06, 1.289e-06, 9.020e-07, 6.146e-07, + -6.842e-06, -5.883e-06, 0.000e+00, 2.708e-06, 3.157e-06, 2.859e-06, 2.628e-06, 1.863e-06, 1.296e-06, 8.882e-07, 6.108e-07, 4.283e-07, + -4.915e-06, -4.154e-06, 0.000e+00, 1.869e-06, 2.184e-06, 1.991e-06, 1.809e-06, 1.296e-06, 1.217e-06, 8.669e-07, 5.751e-07, 3.882e-07, + -3.411e-06, -2.902e-06, 0.000e+00, 1.330e-06, 1.567e-06, 1.431e-06, 1.289e-06, 8.882e-07, 8.669e-07, 9.522e-07, 6.717e-07, 4.293e-07, + 0.000e+00, -2.128e-06, 0.000e+00, 9.186e-07, 1.084e-06, 9.839e-07, 9.020e-07, 6.108e-07, 5.751e-07, 6.717e-07, 7.911e-07, 5.493e-07, + 0.000e+00, 0.000e+00, 0.000e+00, 6.446e-07, 7.575e-07, 6.886e-07, 6.146e-07, 4.283e-07, 3.882e-07, 4.293e-07, 5.493e-07, 7.027e-07}, true)); + + psd0.add("ecal_pulse_shape_covariances", psd3); + + + edm::ParameterSetDescription pset; + pset.addNode(edm::ParameterDescription>("activeBXs", {-5,-4,-3,-2,-1,0,1,2,3,4}, true) and + edm::ParameterDescription("ampErrorCalculation", true, true) and + edm::ParameterDescription("useLumiInfoRunHeader", true, true) and + edm::ParameterDescription("doPrefitEB", false, true) and + edm::ParameterDescription("doPrefitEE", false, true) and + edm::ParameterDescription("prefitMaxChiSqEB", 25., true) and + edm::ParameterDescription("prefitMaxChiSqEE", 10., true) and + edm::ParameterDescription("timealgo", "RatioMethod", true) and + edm::ParameterDescription>("EBtimeFitParameters", {-2.015452e+00, 3.130702e+00, -1.234730e+01, 4.188921e+01, -8.283944e+01, 9.101147e+01, -5.035761e+01, 1.105621e+01}, true) and + edm::ParameterDescription>("EEtimeFitParameters", {-2.390548e+00, 3.553628e+00, -1.762341e+01, 6.767538e+01, -1.332130e+02, 1.407432e+02, -7.541106e+01, 1.620277e+01}, true) and + edm::ParameterDescription>("EBamplitudeFitParameters", {1.138,1.652}, true) and + edm::ParameterDescription>("EEamplitudeFitParameters", {1.890,1.400}, true) and + edm::ParameterDescription("EBtimeFitLimits_Lower", 0.2, true) and + edm::ParameterDescription("EBtimeFitLimits_Upper", 1.4, true) and + edm::ParameterDescription("EEtimeFitLimits_Lower", 0.2, true) and + edm::ParameterDescription("EEtimeFitLimits_Upper", 1.4, true) and + edm::ParameterDescription("EBtimeConstantTerm", .6, true) and + edm::ParameterDescription("EEtimeConstantTerm", 1.0, true) and + edm::ParameterDescription("EBtimeNconst", 28.5, true) and + edm::ParameterDescription("EEtimeNconst", 31.8, true) and + edm::ParameterDescription("outOfTimeThresholdGain12pEB", 5, true) and + edm::ParameterDescription("outOfTimeThresholdGain12mEB", 5, true) and + edm::ParameterDescription("outOfTimeThresholdGain61pEB", 5, true) and + edm::ParameterDescription("outOfTimeThresholdGain61mEB", 5, true) and + edm::ParameterDescription("outOfTimeThresholdGain12pEE", 1000, true) and + edm::ParameterDescription("outOfTimeThresholdGain12mEE", 1000, true) and + edm::ParameterDescription("outOfTimeThresholdGain61pEE", 1000, true) and + edm::ParameterDescription("outOfTimeThresholdGain61mEE", 1000, true) and + edm::ParameterDescription("amplitudeThresholdEB", 10, true) and + edm::ParameterDescription("amplitudeThresholdEE", 10, true) and + edm::ParameterDescription("ebSpikeThreshold", 1.042, true) and + edm::ParameterDescription>("ebPulseShape", {5.2e-05,-5.26e-05 , 6.66e-05, 0.1168, 0.7575, 1., 0.8876, 0.6732, 0.4741, 0.3194}, true) and + edm::ParameterDescription>("eePulseShape", {5.2e-05,-5.26e-05 , 6.66e-05, 0.1168, 0.7575, 1., 0.8876, 0.6732, 0.4741, 0.3194}, true) and + edm::ParameterDescription("kPoorRecoFlagEB", true, true) and + edm::ParameterDescription("kPoorRecoFlagEE", false, true) and + edm::ParameterDescription("chi2ThreshEB_", 65.0, true) and + edm::ParameterDescription("chi2ThreshEE_", 50.0, true) and + edm::ParameterDescription("EcalPulseShapeParameters", psd0, true)); + + return pset; } diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.h index b58d7dd6a370b..8e5e062ffeb24 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.h @@ -35,6 +35,7 @@ namespace edm { class Event; class EventSetup; class ParameterSet; + class ParameterSetDescription; } class EcalUncalibRecHitWorkerMultiFit : public EcalUncalibRecHitWorkerBaseClass { @@ -48,8 +49,7 @@ class EcalUncalibRecHitWorkerMultiFit : public EcalUncalibRecHitWorkerBaseClass void set(const edm::Event& evt) override; bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result) override; - void fillDescriptions(edm::ConfigurationDescriptions& descriptions); - + edm::ParameterSetDescription getAlgoDescription(); protected: double pedVec[3]; diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc index 1e3128846c1ee..de822b18026db 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc @@ -127,49 +127,27 @@ EcalUncalibRecHitWorkerRatio::run( const edm::Event & evt, return true; } -std::auto_ptr -EcalUncalibRecHitWorkerRatio::fillDescriptions() { +edm::ParameterSetDescription +EcalUncalibRecHitWorkerRatio::getAlgoDescription() { + edm::ParameterSetDescription pset; std::vector dSet1 = {-2.390548,3.553628,-17.62341,67.67538,-133.213,140.7432,-75.41106,16.20277}; std::vector dSet2 = {-2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621}; - return (edm::ParameterDescription("EEtimeFitLimits_Upper", 1.4, true) and - edm::ParameterDescription("EEtimeConstantTerm", 0.18, true) and - edm::ParameterDescription("EBtimeFitLimits_Lower", 0.2, true) and - edm::ParameterDescription("EBtimeConstantTerm", 0.26, true) and - edm::ParameterDescription("EEtimeFitLimits_Lower", 0.2, true) and - edm::ParameterDescription >("EEtimeFitParameters", dSet1, true) and - edm::ParameterDescription>("EEamplitudeFitParameters", {1.89, 1.4}, true) and - edm::ParameterDescription("EBtimeFitLimits_Upper", 1.4, true) and - edm::ParameterDescription>("EBamplitudeFitParameters", {1.138,1.652}, true) and - edm::ParameterDescription>("EBtimeFitParameters", dSet2, true) ); + pset.addNode(edm::ParameterDescription("EEtimeFitLimits_Upper", 1.4, true) and + edm::ParameterDescription("EEtimeConstantTerm", 0.18, true) and + edm::ParameterDescription("EBtimeFitLimits_Lower", 0.2, true) and + edm::ParameterDescription("EBtimeConstantTerm", 0.26, true) and + edm::ParameterDescription("EEtimeFitLimits_Lower", 0.2, true) and + edm::ParameterDescription >("EEtimeFitParameters", dSet1, true) and + edm::ParameterDescription>("EEamplitudeFitParameters", {1.89, 1.4}, true) and + edm::ParameterDescription("EBtimeFitLimits_Upper", 1.4, true) and + edm::ParameterDescription>("EBamplitudeFitParameters", {1.138,1.652}, true) and + edm::ParameterDescription>("EBtimeFitParameters", dSet2, true) ); + + return pset; } -/* -void -EcalUncalibRecHitWorkerRatio::fillDescriptions(edm::ParameterSetDescription& desc, std::string& moduleName) { - - std::vector dSet1 = {-2.390548,3.553628,-17.62341,67.67538,-133.213,140.7432,-75.41106,16.20277}; - std::vector dSet2 = {-2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621}; - - desc.ifValue(edm::ParameterDescription("algo", "EcalUncalibRecHitWorkerRatio", true), - "EcalUncalibRecHitWorkerRatio" >> (edm::ParameterDescription("EEtimeFitLimits_Upper", 1.4, true) and - edm::ParameterDescription("EEtimeConstantTerm", 0.18, true) and - edm::ParameterDescription("EBtimeFitLimits_Lower", 0.2, true) and - edm::ParameterDescription("EBtimeConstantTerm", 0.26, true) and - edm::ParameterDescription("EEtimeFitLimits_Lower", 0.2, true) and - edm::ParameterDescription >("EEtimeFitParameters", dSet1, true) and - edm::ParameterDescription>("EEamplitudeFitParameters", {1.89, 1.4}, true) and - edm::ParameterDescription("EBtimeFitLimits_Upper", 1.4, true) and - edm::ParameterDescription>("EBamplitudeFitParameters", {1.138,1.652}, true) and - edm::ParameterDescription>("EBtimeFitParameters", dSet2, true) - ) - ); - - moduleName = "ecalRatioUncalibRecHit"; -} -*/ - #include "FWCore/Framework/interface/MakerMacros.h" #include "RecoLocalCalo/EcalRecProducers/interface/EcalUncalibRecHitWorkerFactory.h" DEFINE_EDM_PLUGIN( EcalUncalibRecHitWorkerFactory, EcalUncalibRecHitWorkerRatio, "EcalUncalibRecHitWorkerRatio" ); diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.h index 07b0868ff44d3..796092d04096c 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.h @@ -31,8 +31,8 @@ class EcalUncalibRecHitWorkerRatio : public EcalUncalibRecHitWorkerBaseClass { void set(const edm::EventSetup& es); bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); - - std::auto_ptr fillDescriptions(); + + edm::ParameterSetDescription getAlgoDescription(); protected: diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.cc index fb60826bbba34..488b39b9637a6 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.cc @@ -99,16 +99,17 @@ EcalUncalibRecHitWorkerWeights::run( const edm::Event & evt, return true; } -void -EcalUncalibRecHitWorkerWeights::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - // ecalWeightUncalibRecHit - edm::ParameterSetDescription desc; - desc.add("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")); - desc.add("EEhitCollection", "EcalUncalibRecHitsEE"); - desc.add("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")); - desc.add("algo", "EcalUncalibRecHitWorkerWeights"); - desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); - descriptions.add("ecalWeightUncalibRecHit", desc); +edm::ParameterSetDescription +EcalUncalibRecHitWorkerWeights::getAlgoDescription() { + + edm::ParameterSetDescription pset; +//pset.addNode(edm::ParameterSet("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")) and +// edm::ParameterSet("EEhitCollection", "EcalUncalibRecHitsEE") and +// edm::ParameterSet("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")) and +// edm::ParameterSet("algo", "EcalUncalibRecHitWorkerWeights") and +// edm::ParameterSet("EBhitCollection", "EcalUncalibRecHitsEB")); +// + return pset; } #include "FWCore/Framework/interface/MakerMacros.h" diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.h b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.h index a14bcdfada13c..e4469fb98f8e9 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.h +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.h @@ -25,7 +25,7 @@ namespace edm { class Event; class EventSetup; class ParameterSet; - class ConfigurationDescription; + class ParameterSetDescription; } class EcalUncalibRecHitWorkerWeights : public EcalUncalibRecHitWorkerBaseClass { @@ -38,7 +38,7 @@ class EcalUncalibRecHitWorkerWeights : public EcalUncalibRecHitWorkerBaseClass { void set(const edm::EventSetup& es); bool run(const edm::Event& evt, const EcalDigiCollection::const_iterator & digi, EcalUncalibratedRecHitCollection & result); - void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + edm::ParameterSetDescription getAlgoDescription(); protected: From 6ff86b60b2c1b789fa6064015e79c87a95933768 Mon Sep 17 00:00:00 2001 From: Matteo Date: Fri, 20 Feb 2015 12:10:01 +0100 Subject: [PATCH 09/22] fix in pset name --- .../EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc index 6ed0bccc39411..fad7de19d933e 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc @@ -59,10 +59,10 @@ void EcalUncalibRecHitProducer::fillDescriptions(edm::ConfigurationDescriptions& std::auto_ptr> s; { - s = itInfos->name_ >> edm::ParameterDescription("algoPset", EcalUncalibRecHitFillDescriptionWorkerFactory::get()->create(itInfos->name_)->getAlgoDescription(), true); + s = itInfos->name_ >> edm::ParameterDescription("algoPSet", EcalUncalibRecHitFillDescriptionWorkerFactory::get()->create(itInfos->name_)->getAlgoDescription(), true); } for (++itInfos; itInfos != infos.end(); ++itInfos) - s = s or itInfos->name_ >> edm::ParameterDescription("algoPset", EcalUncalibRecHitFillDescriptionWorkerFactory::get()->create(itInfos->name_)->getAlgoDescription(), true); + s = s or itInfos->name_ >> edm::ParameterDescription("algoPSet", EcalUncalibRecHitFillDescriptionWorkerFactory::get()->create(itInfos->name_)->getAlgoDescription(), true); desc.ifValue(edm::ParameterDescription("algo", "EcalUncalibRecHitWorkerWeights", true), s); descriptions.addDefault(desc); From 7c35fd3095767b5bac5fd62be040c330710b0308 Mon Sep 17 00:00:00 2001 From: Matteo Date: Fri, 20 Feb 2015 12:18:20 +0100 Subject: [PATCH 10/22] fix of default cfi --- .../python/ecalAnalFitUncalibRecHit_cfi.py | 3 +- .../ecalFixedAlphaBetaFitUncalibRecHit_cfi.py | 20 ++-- .../python/ecalGlobalUncalibRecHit_cfi.py | 78 ++++++------- .../python/ecalMaxSampleUncalibRecHit_cfi.py | 3 +- .../python/ecalMultiFitUncalibRecHit_cfi.py | 110 +++++++++--------- .../python/ecalRatioUncalibRecHit_cfi.py | 24 ++-- .../python/ecalUncalibRecHit_cfi.py | 3 +- .../python/ecalWeightUncalibRecHit_cfi.py | 3 +- 8 files changed, 126 insertions(+), 118 deletions(-) diff --git a/RecoLocalCalo/EcalRecProducers/python/ecalAnalFitUncalibRecHit_cfi.py b/RecoLocalCalo/EcalRecProducers/python/ecalAnalFitUncalibRecHit_cfi.py index 0a1f26f6a3bc5..b976c6db09804 100644 --- a/RecoLocalCalo/EcalRecProducers/python/ecalAnalFitUncalibRecHit_cfi.py +++ b/RecoLocalCalo/EcalRecProducers/python/ecalAnalFitUncalibRecHit_cfi.py @@ -6,5 +6,6 @@ EEhitCollection = cms.string('EcalUncalibRecHitsEE'), EEdigiCollection = cms.InputTag("ecalDigis","eeDigis"), EBhitCollection = cms.string("EcalUncalibRecHitsEB"), - algo = cms.string("EcalUncalibRecHitWorkerAnalFit") + algo = cms.string("EcalUncalibRecHitWorkerAnalFit"), + algoPSet = cms.PSet() ) diff --git a/RecoLocalCalo/EcalRecProducers/python/ecalFixedAlphaBetaFitUncalibRecHit_cfi.py b/RecoLocalCalo/EcalRecProducers/python/ecalFixedAlphaBetaFitUncalibRecHit_cfi.py index f5fd75baa2575..51629851d34a5 100644 --- a/RecoLocalCalo/EcalRecProducers/python/ecalFixedAlphaBetaFitUncalibRecHit_cfi.py +++ b/RecoLocalCalo/EcalRecProducers/python/ecalFixedAlphaBetaFitUncalibRecHit_cfi.py @@ -5,14 +5,16 @@ EEdigiCollection = cms.InputTag("ecalDigis","eeDigis"), EBdigiCollection = cms.InputTag("ecalDigis","ebDigis"), EEhitCollection = cms.string("EcalUncalibRecHitsEE"), - betaEB = cms.double(1.655), - betaEE = cms.double(1.400), - AlphaBetaFilename = cms.untracked.string("NOFILE"), - MinAmplEndcap = cms.double(14.0), - MinAmplBarrel = cms.double(8.0), - UseDynamicPedestal = cms.bool(True), - alphaEB = cms.double(1.138), - alphaEE = cms.double(1.890), EBhitCollection = cms.string("EcalUncalibRecHitsEB"), - algo = cms.string("EcalUncalibRecHitWorkerFixedAlphaBetaFit") + algo = cms.string("EcalUncalibRecHitWorkerFixedAlphaBetaFit"), + algoPSet = cms.PSet( + betaEB = cms.double(1.655), + betaEE = cms.double(1.400), + AlphaBetaFilename = cms.untracked.string("NOFILE"), + MinAmplEndcap = cms.double(14.0), + MinAmplBarrel = cms.double(8.0), + UseDynamicPedestal = cms.bool(True), + alphaEB = cms.double(1.138), + alphaEE = cms.double(1.890) + ) ) diff --git a/RecoLocalCalo/EcalRecProducers/python/ecalGlobalUncalibRecHit_cfi.py b/RecoLocalCalo/EcalRecProducers/python/ecalGlobalUncalibRecHit_cfi.py index 0a666b6d3353c..35950f157436e 100644 --- a/RecoLocalCalo/EcalRecProducers/python/ecalGlobalUncalibRecHit_cfi.py +++ b/RecoLocalCalo/EcalRecProducers/python/ecalGlobalUncalibRecHit_cfi.py @@ -5,43 +5,43 @@ EEdigiCollection = cms.InputTag("ecalDigis","eeDigis"), EBhitCollection = cms.string("EcalUncalibRecHitsEB"), EEhitCollection = cms.string('EcalUncalibRecHitsEE'), - - # for ratio method - EBtimeFitParameters = cms.vdouble(-2.015452e+00, 3.130702e+00, -1.234730e+01, 4.188921e+01, -8.283944e+01, 9.101147e+01, -5.035761e+01, 1.105621e+01), - EEtimeFitParameters = cms.vdouble(-2.390548e+00, 3.553628e+00, -1.762341e+01, 6.767538e+01, -1.332130e+02, 1.407432e+02, -7.541106e+01, 1.620277e+01), - EBamplitudeFitParameters = cms.vdouble(1.138,1.652), - EEamplitudeFitParameters = cms.vdouble(1.890,1.400), - EBtimeFitLimits_Lower = cms.double(0.2), - EBtimeFitLimits_Upper = cms.double(1.4), - EEtimeFitLimits_Lower = cms.double(0.2), - EEtimeFitLimits_Upper = cms.double(1.4), - # for kOutOfTime flag - EBtimeConstantTerm= cms.double(.6), - EBtimeNconst = cms.double(28.5), - EEtimeConstantTerm= cms.double(1.0), - EEtimeNconst = cms.double(31.8), - outOfTimeThresholdGain12pEB = cms.double(5), # times estimated precision - outOfTimeThresholdGain12mEB = cms.double(5), # times estimated precision - outOfTimeThresholdGain61pEB = cms.double(5), # times estimated precision - outOfTimeThresholdGain61mEB = cms.double(5), # times estimated precision - outOfTimeThresholdGain12pEE = cms.double(1000), # times estimated precision - outOfTimeThresholdGain12mEE = cms.double(1000), # times estimated precision - outOfTimeThresholdGain61pEE = cms.double(1000), # times estimated precision - outOfTimeThresholdGain61mEE = cms.double(1000), # times estimated precision - amplitudeThresholdEB = cms.double(10), - amplitudeThresholdEE = cms.double(10), - - ebSpikeThreshold = cms.double(1.042), - - ebPulseShape = cms.vdouble( 5.2e-05,-5.26e-05 , 6.66e-05, 0.1168, 0.7575, 1., 0.8876, 0.6732, 0.4741, 0.3194 ), - eePulseShape = cms.vdouble( 5.2e-05,-5.26e-05 , 6.66e-05, 0.1168, 0.7575, 1., 0.8876, 0.6732, 0.4741, 0.3194 ), - - kPoorRecoFlagEB = cms.bool(True), - kPoorRecoFlagEE = cms.bool(False), - chi2ThreshEB_ = cms.double(36.0), - chi2ThreshEE_ = cms.double(95.0), - EBchi2Parameters = cms.vdouble(2.122, 0.022, 2.122, 0.022), - EEchi2Parameters = cms.vdouble(2.122, 0.022, 2.122, 0.022), - - algo = cms.string("EcalUncalibRecHitWorkerGlobal") + algo = cms.string("EcalUncalibRecHitWorkerGlobal"), + algoPSet = cms.PSet( + # for ratio method + EBtimeFitParameters = cms.vdouble(-2.015452e+00, 3.130702e+00, -1.234730e+01, 4.188921e+01, -8.283944e+01, 9.101147e+01, -5.035761e+01, 1.105621e+01), + EEtimeFitParameters = cms.vdouble(-2.390548e+00, 3.553628e+00, -1.762341e+01, 6.767538e+01, -1.332130e+02, 1.407432e+02, -7.541106e+01, 1.620277e+01), + EBamplitudeFitParameters = cms.vdouble(1.138,1.652), + EEamplitudeFitParameters = cms.vdouble(1.890,1.400), + EBtimeFitLimits_Lower = cms.double(0.2), + EBtimeFitLimits_Upper = cms.double(1.4), + EEtimeFitLimits_Lower = cms.double(0.2), + EEtimeFitLimits_Upper = cms.double(1.4), + # for kOutOfTime flag + EBtimeConstantTerm= cms.double(.6), + EBtimeNconst = cms.double(28.5), + EEtimeConstantTerm= cms.double(1.0), + EEtimeNconst = cms.double(31.8), + outOfTimeThresholdGain12pEB = cms.double(5), # times estimated precision + outOfTimeThresholdGain12mEB = cms.double(5), # times estimated precision + outOfTimeThresholdGain61pEB = cms.double(5), # times estimated precision + outOfTimeThresholdGain61mEB = cms.double(5), # times estimated precision + outOfTimeThresholdGain12pEE = cms.double(1000), # times estimated precision + outOfTimeThresholdGain12mEE = cms.double(1000), # times estimated precision + outOfTimeThresholdGain61pEE = cms.double(1000), # times estimated precision + outOfTimeThresholdGain61mEE = cms.double(1000), # times estimated precision + amplitudeThresholdEB = cms.double(10), + amplitudeThresholdEE = cms.double(10), + + ebSpikeThreshold = cms.double(1.042), + + ebPulseShape = cms.vdouble( 5.2e-05,-5.26e-05 , 6.66e-05, 0.1168, 0.7575, 1., 0.8876, 0.6732, 0.4741, 0.3194 ), + eePulseShape = cms.vdouble( 5.2e-05,-5.26e-05 , 6.66e-05, 0.1168, 0.7575, 1., 0.8876, 0.6732, 0.4741, 0.3194 ), + + kPoorRecoFlagEB = cms.bool(True), + kPoorRecoFlagEE = cms.bool(False), + chi2ThreshEB_ = cms.double(36.0), + chi2ThreshEE_ = cms.double(95.0), + EBchi2Parameters = cms.vdouble(2.122, 0.022, 2.122, 0.022), + EEchi2Parameters = cms.vdouble(2.122, 0.022, 2.122, 0.022), + ) ) diff --git a/RecoLocalCalo/EcalRecProducers/python/ecalMaxSampleUncalibRecHit_cfi.py b/RecoLocalCalo/EcalRecProducers/python/ecalMaxSampleUncalibRecHit_cfi.py index 0e6124904ec8e..014f4c7c3f779 100644 --- a/RecoLocalCalo/EcalRecProducers/python/ecalMaxSampleUncalibRecHit_cfi.py +++ b/RecoLocalCalo/EcalRecProducers/python/ecalMaxSampleUncalibRecHit_cfi.py @@ -5,5 +5,6 @@ EEhitCollection = cms.string("EcalUncalibRecHitsEE"), EEdigiCollection = cms.InputTag("ecalEBunpacker","eeDigis"), EBhitCollection = cms.string("EcalUncalibRecHitsEB"), - algo = cms.string("EcalUncalibRecHitWorkerMaxSample") + algo = cms.string("EcalUncalibRecHitWorkerMaxSample"), + algoPSet = cms.PSet() ) diff --git a/RecoLocalCalo/EcalRecProducers/python/ecalMultiFitUncalibRecHit_cfi.py b/RecoLocalCalo/EcalRecProducers/python/ecalMultiFitUncalibRecHit_cfi.py index 514c11092b985..c0b4aa76035a8 100644 --- a/RecoLocalCalo/EcalRecProducers/python/ecalMultiFitUncalibRecHit_cfi.py +++ b/RecoLocalCalo/EcalRecProducers/python/ecalMultiFitUncalibRecHit_cfi.py @@ -7,59 +7,59 @@ EEdigiCollection = cms.InputTag("ecalDigis","eeDigis"), EBhitCollection = cms.string("EcalUncalibRecHitsEB"), EEhitCollection = cms.string('EcalUncalibRecHitsEE'), - - # for multifit method - EcalPulseShapeParameters = cms.PSet( ecal_pulse_shape_parameters ), - activeBXs = cms.vint32(-5,-4,-3,-2,-1,0,1,2,3,4), - ampErrorCalculation = cms.bool(True), - useLumiInfoRunHeader = cms.bool(True), - - doPrefitEB = cms.bool(False), - doPrefitEE = cms.bool(False), - prefitMaxChiSqEB = cms.double(25.), - prefitMaxChiSqEE = cms.double(10.), - - # decide which algorithm to be use to calculate the jitter - timealgo = cms.string("RatioMethod"), - - # for ratio method - EBtimeFitParameters = cms.vdouble(-2.015452e+00, 3.130702e+00, -1.234730e+01, 4.188921e+01, -8.283944e+01, 9.101147e+01, -5.035761e+01, 1.105621e+01), - EEtimeFitParameters = cms.vdouble(-2.390548e+00, 3.553628e+00, -1.762341e+01, 6.767538e+01, -1.332130e+02, 1.407432e+02, -7.541106e+01, 1.620277e+01), - EBamplitudeFitParameters = cms.vdouble(1.138,1.652), - EEamplitudeFitParameters = cms.vdouble(1.890,1.400), - EBtimeFitLimits_Lower = cms.double(0.2), - EBtimeFitLimits_Upper = cms.double(1.4), - EEtimeFitLimits_Lower = cms.double(0.2), - EEtimeFitLimits_Upper = cms.double(1.4), - # for time error - EBtimeConstantTerm= cms.double(.6), - EEtimeConstantTerm= cms.double(1.0), - - # for kOutOfTime flag - EBtimeNconst = cms.double(28.5), - EEtimeNconst = cms.double(31.8), - outOfTimeThresholdGain12pEB = cms.double(5), # times estimated precision - outOfTimeThresholdGain12mEB = cms.double(5), # times estimated precision - outOfTimeThresholdGain61pEB = cms.double(5), # times estimated precision - outOfTimeThresholdGain61mEB = cms.double(5), # times estimated precision - outOfTimeThresholdGain12pEE = cms.double(1000), # times estimated precision - outOfTimeThresholdGain12mEE = cms.double(1000), # times estimated precision - outOfTimeThresholdGain61pEE = cms.double(1000), # times estimated precision - outOfTimeThresholdGain61mEE = cms.double(1000), # times estimated precision - amplitudeThresholdEB = cms.double(10), - amplitudeThresholdEE = cms.double(10), - - ebSpikeThreshold = cms.double(1.042), - - # these are now taken from DB. Here the MC parameters for backward compatibility - ebPulseShape = cms.vdouble( 5.2e-05,-5.26e-05 , 6.66e-05, 0.1168, 0.7575, 1., 0.8876, 0.6732, 0.4741, 0.3194 ), - eePulseShape = cms.vdouble( 5.2e-05,-5.26e-05 , 6.66e-05, 0.1168, 0.7575, 1., 0.8876, 0.6732, 0.4741, 0.3194 ), - - # for kPoorReco flag - kPoorRecoFlagEB = cms.bool(True), - kPoorRecoFlagEE = cms.bool(False), - chi2ThreshEB_ = cms.double(65.0), - chi2ThreshEE_ = cms.double(50.0), - - algo = cms.string("EcalUncalibRecHitWorkerMultiFit") + algo = cms.string("EcalUncalibRecHitWorkerMultiFit"), + algoPSet = cms.PSet( + # for multifit method + EcalPulseShapeParameters = cms.PSet( ecal_pulse_shape_parameters ), + activeBXs = cms.vint32(-5,-4,-3,-2,-1,0,1,2,3,4), + ampErrorCalculation = cms.bool(True), + useLumiInfoRunHeader = cms.bool(True), + + doPrefitEB = cms.bool(False), + doPrefitEE = cms.bool(False), + prefitMaxChiSqEB = cms.double(25.), + prefitMaxChiSqEE = cms.double(10.), + + # decide which algorithm to be use to calculate the jitter + timealgo = cms.string("RatioMethod"), + + # for ratio method + EBtimeFitParameters = cms.vdouble(-2.015452e+00, 3.130702e+00, -1.234730e+01, 4.188921e+01, -8.283944e+01, 9.101147e+01, -5.035761e+01, 1.105621e+01), + EEtimeFitParameters = cms.vdouble(-2.390548e+00, 3.553628e+00, -1.762341e+01, 6.767538e+01, -1.332130e+02, 1.407432e+02, -7.541106e+01, 1.620277e+01), + EBamplitudeFitParameters = cms.vdouble(1.138,1.652), + EEamplitudeFitParameters = cms.vdouble(1.890,1.400), + EBtimeFitLimits_Lower = cms.double(0.2), + EBtimeFitLimits_Upper = cms.double(1.4), + EEtimeFitLimits_Lower = cms.double(0.2), + EEtimeFitLimits_Upper = cms.double(1.4), + # for time error + EBtimeConstantTerm= cms.double(.6), + EEtimeConstantTerm= cms.double(1.0), + + # for kOutOfTime flag + EBtimeNconst = cms.double(28.5), + EEtimeNconst = cms.double(31.8), + outOfTimeThresholdGain12pEB = cms.double(5), # times estimated precision + outOfTimeThresholdGain12mEB = cms.double(5), # times estimated precision + outOfTimeThresholdGain61pEB = cms.double(5), # times estimated precision + outOfTimeThresholdGain61mEB = cms.double(5), # times estimated precision + outOfTimeThresholdGain12pEE = cms.double(1000), # times estimated precision + outOfTimeThresholdGain12mEE = cms.double(1000), # times estimated precision + outOfTimeThresholdGain61pEE = cms.double(1000), # times estimated precision + outOfTimeThresholdGain61mEE = cms.double(1000), # times estimated precision + amplitudeThresholdEB = cms.double(10), + amplitudeThresholdEE = cms.double(10), + + ebSpikeThreshold = cms.double(1.042), + + # these are now taken from DB. Here the MC parameters for backward compatibility + ebPulseShape = cms.vdouble( 5.2e-05,-5.26e-05 , 6.66e-05, 0.1168, 0.7575, 1., 0.8876, 0.6732, 0.4741, 0.3194 ), + eePulseShape = cms.vdouble( 5.2e-05,-5.26e-05 , 6.66e-05, 0.1168, 0.7575, 1., 0.8876, 0.6732, 0.4741, 0.3194 ), + + # for kPoorReco flag + kPoorRecoFlagEB = cms.bool(True), + kPoorRecoFlagEE = cms.bool(False), + chi2ThreshEB_ = cms.double(65.0), + chi2ThreshEE_ = cms.double(50.0), + ) ) diff --git a/RecoLocalCalo/EcalRecProducers/python/ecalRatioUncalibRecHit_cfi.py b/RecoLocalCalo/EcalRecProducers/python/ecalRatioUncalibRecHit_cfi.py index 2e6cf04e178ec..6def0e54acb2e 100644 --- a/RecoLocalCalo/EcalRecProducers/python/ecalRatioUncalibRecHit_cfi.py +++ b/RecoLocalCalo/EcalRecProducers/python/ecalRatioUncalibRecHit_cfi.py @@ -5,15 +5,17 @@ EEdigiCollection = cms.InputTag("ecalDigis","eeDigis"), EBhitCollection = cms.string("EcalUncalibRecHitsEB"), EEhitCollection = cms.string('EcalUncalibRecHitsEE'), - EBtimeFitParameters = cms.vdouble(-2.015452e+00, 3.130702e+00, -1.234730e+01, 4.188921e+01, -8.283944e+01, 9.101147e+01, -5.035761e+01, 1.105621e+01), - EEtimeFitParameters = cms.vdouble(-2.390548e+00, 3.553628e+00, -1.762341e+01, 6.767538e+01, -1.332130e+02, 1.407432e+02, -7.541106e+01, 1.620277e+01), - EBamplitudeFitParameters = cms.vdouble(1.138,1.652), - EEamplitudeFitParameters = cms.vdouble(1.890,1.400), - EBtimeFitLimits_Lower = cms.double(0.2), - EBtimeFitLimits_Upper = cms.double(1.4), - EEtimeFitLimits_Lower = cms.double(0.2), - EEtimeFitLimits_Upper = cms.double(1.4), - EBtimeConstantTerm = cms.double(.26), - EEtimeConstantTerm = cms.double(.18), - algo = cms.string("EcalUncalibRecHitWorkerRatio") + algo = cms.string("EcalUncalibRecHitWorkerRatio"), + algoPSet = cms.PSet( + EBtimeFitParameters = cms.vdouble(-2.015452e+00, 3.130702e+00, -1.234730e+01, 4.188921e+01, -8.283944e+01, 9.101147e+01, -5.035761e+01, 1.105621e+01), + EEtimeFitParameters = cms.vdouble(-2.390548e+00, 3.553628e+00, -1.762341e+01, 6.767538e+01, -1.332130e+02, 1.407432e+02, -7.541106e+01, 1.620277e+01), + EBamplitudeFitParameters = cms.vdouble(1.138,1.652), + EEamplitudeFitParameters = cms.vdouble(1.890,1.400), + EBtimeFitLimits_Lower = cms.double(0.2), + EBtimeFitLimits_Upper = cms.double(1.4), + EEtimeFitLimits_Lower = cms.double(0.2), + EEtimeFitLimits_Upper = cms.double(1.4), + EBtimeConstantTerm = cms.double(.26), + EEtimeConstantTerm = cms.double(.18), + ) ) diff --git a/RecoLocalCalo/EcalRecProducers/python/ecalUncalibRecHit_cfi.py b/RecoLocalCalo/EcalRecProducers/python/ecalUncalibRecHit_cfi.py index 91a0732ae645d..3773daca2af60 100644 --- a/RecoLocalCalo/EcalRecProducers/python/ecalUncalibRecHit_cfi.py +++ b/RecoLocalCalo/EcalRecProducers/python/ecalUncalibRecHit_cfi.py @@ -6,5 +6,6 @@ EEhitCollection = cms.string('EcalUncalibRecHitsEE'), EEdigiCollection = cms.InputTag("ecalDigis","eeDigis"), EBhitCollection = cms.string('EcalUncalibRecHitsEB'), - algo = cms.string("EcalUncalibRecHitWorkerWeights") + algo = cms.string("EcalUncalibRecHitWorkerWeights"), + algoPSet = cms.PSet() ) diff --git a/RecoLocalCalo/EcalRecProducers/python/ecalWeightUncalibRecHit_cfi.py b/RecoLocalCalo/EcalRecProducers/python/ecalWeightUncalibRecHit_cfi.py index 068e03c499a25..4424007546717 100644 --- a/RecoLocalCalo/EcalRecProducers/python/ecalWeightUncalibRecHit_cfi.py +++ b/RecoLocalCalo/EcalRecProducers/python/ecalWeightUncalibRecHit_cfi.py @@ -6,5 +6,6 @@ EEhitCollection = cms.string('EcalUncalibRecHitsEE'), EEdigiCollection = cms.InputTag("ecalDigis","eeDigis"), EBhitCollection = cms.string('EcalUncalibRecHitsEB'), - algo = cms.string("EcalUncalibRecHitWorkerWeights") + algo = cms.string("EcalUncalibRecHitWorkerWeights"), + algoPSet = cms.PSet() ) From e6d7c4c45ce1b73bdbe845aab4e17b36ef4c788e Mon Sep 17 00:00:00 2001 From: Matteo Date: Fri, 20 Feb 2015 14:18:16 +0100 Subject: [PATCH 11/22] finally fixed multifit config --- .../plugins/EcalUncalibRecHitProducer.cc | 6 +- .../plugins/EcalUncalibRecHitWorkerAnalFit.cc | 6 +- ...calUncalibRecHitWorkerFixedAlphaBetaFit.cc | 6 +- .../plugins/EcalUncalibRecHitWorkerGlobal.cc | 6 +- .../EcalUncalibRecHitWorkerMaxSample.cc | 4 +- .../EcalUncalibRecHitWorkerMultiFit.cc | 177 +++++++++--------- .../plugins/EcalUncalibRecHitWorkerRatio.cc | 6 +- .../plugins/EcalUncalibRecHitWorkerWeights.cc | 10 +- 8 files changed, 104 insertions(+), 117 deletions(-) diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc index fad7de19d933e..d4a7bec2af027 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitProducer.cc @@ -63,8 +63,8 @@ void EcalUncalibRecHitProducer::fillDescriptions(edm::ConfigurationDescriptions& } for (++itInfos; itInfos != infos.end(); ++itInfos) s = s or itInfos->name_ >> edm::ParameterDescription("algoPSet", EcalUncalibRecHitFillDescriptionWorkerFactory::get()->create(itInfos->name_)->getAlgoDescription(), true); - desc.ifValue(edm::ParameterDescription("algo", "EcalUncalibRecHitWorkerWeights", true), s); - + desc.ifValue(edm::ParameterDescription("algo", "EcalUncalibRecHitWorkerMultiFit", true), s); + descriptions.addDefault(desc); } @@ -78,7 +78,7 @@ void EcalUncalibRecHitProducer::fillDescriptions(edm::ConfigurationDescriptions& desc.add("EBhitCollection", "EcalUncalibRecHitsEB"); desc.add("algo", itInfos->name_); desc.add("algoPSet", fdWorker->getAlgoDescription()); - + std::string algoName = itInfos->name_.substr(itInfos->name_.find("Worker")+6, itInfos->name_.length()); descriptions.add("ecal"+algoName+"UncalibRecHit", desc); } diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.cc index 162c366fe0d31..622da80e05c9b 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerAnalFit.cc @@ -140,14 +140,14 @@ EcalUncalibRecHitWorkerAnalFit::run( const edm::Event& evt, edm::ParameterSetDescription EcalUncalibRecHitWorkerAnalFit::getAlgoDescription() { - edm::ParameterSetDescription pset; -//pset.addNode(edm::ParameterSet("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")) and + edm::ParameterSetDescription psd; +//psd.addNode(edm::ParameterSet("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")) and // edm::ParameterSet("EEhitCollection", "EcalUncalibRecHitsEE") and // edm::ParameterSet("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")) and // edm::ParameterSet("algo", "EcalUncalibRecHitWorkerAnalFit") and // edm::ParameterSet("EBhitCollection", "EcalUncalibRecHitsEB")); // - return pset; + return psd; } #include "FWCore/Framework/interface/MakerMacros.h" diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc index b51d4d51801c0..3022566d164c1 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerFixedAlphaBetaFit.cc @@ -192,9 +192,9 @@ EcalUncalibRecHitWorkerFixedAlphaBetaFit::run(const edm::Event& evt, edm::ParameterSetDescription EcalUncalibRecHitWorkerFixedAlphaBetaFit::getAlgoDescription() { - edm::ParameterSetDescription pset; + edm::ParameterSetDescription psd; - pset.addNode(edm::ParameterDescription("alphaEB", 1.138, true) and + psd.addNode(edm::ParameterDescription("alphaEB", 1.138, true) and edm::ParameterDescription("alphaEE", 1.89, true) and edm::ParameterDescription("AlphaBetaFilename", "NOFILE", false) and edm::ParameterDescription("betaEB", 1.655, true) and @@ -203,7 +203,7 @@ EcalUncalibRecHitWorkerFixedAlphaBetaFit::getAlgoDescription() { edm::ParameterDescription("betaEE", 1.4, true) and edm::ParameterDescription("UseDynamicPedestal", true, true) ); - return pset; + return psd; } #include "FWCore/Framework/interface/MakerMacros.h" diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.cc index 65007ead79a7e..086a658c6cbb4 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerGlobal.cc @@ -513,8 +513,8 @@ EcalUncalibRecHitWorkerGlobal::run( const edm::Event & evt, edm::ParameterSetDescription EcalUncalibRecHitWorkerGlobal::getAlgoDescription() { - edm::ParameterSetDescription pset; - pset.addNode(edm::ParameterDescription>("eePulseShape", {5.2e-05,-5.26e-05,6.66e-05,0.1168,0.7575,1.0,0.8876,0.6732,0.4741,0.3194}, true) and + edm::ParameterSetDescription psd; + psd.addNode(edm::ParameterDescription>("eePulseShape", {5.2e-05,-5.26e-05,6.66e-05,0.1168,0.7575,1.0,0.8876,0.6732,0.4741,0.3194}, true) and edm::ParameterDescription>("EBtimeFitParameters", {-2.015452,3.130702,-12.3473,41.88921,-82.83944,91.01147,-50.35761,11.05621}, true) and edm::ParameterDescription("outOfTimeThresholdGain61pEB", 5, true) and edm::ParameterDescription("amplitudeThresholdEE", 10, true) and @@ -546,7 +546,7 @@ EcalUncalibRecHitWorkerGlobal::getAlgoDescription() { edm::ParameterDescription("chi2ThreshEE_", 95.0, true) and edm::ParameterDescription("EBtimeFitLimits_Upper", 1.4, true)); - return pset; + return psd; } diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc index 50a56242112c4..30b43c628defd 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMaxSample.cc @@ -56,8 +56,8 @@ EcalUncalibRecHitWorkerMaxSample::run( const edm::Event & evt, edm::ParameterSetDescription EcalUncalibRecHitWorkerMaxSample::getAlgoDescription() { - edm::ParameterSetDescription pset; - return pset;//.addNode(std::auto_ptr(new edm::EmptyGroupDescription())); + edm::ParameterSetDescription psd; + return psd;//.addNode(std::auto_ptr(new edm::EmptyGroupDescription())); } diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.cc index fd7106f074e93..e2e322cf195ee 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerMultiFit.cc @@ -20,6 +20,7 @@ #include #include +#include EcalUncalibRecHitWorkerMultiFit::EcalUncalibRecHitWorkerMultiFit(const edm::ParameterSet&ps,edm::ConsumesCollector& c) : EcalUncalibRecHitWorkerBaseClass(ps,c), @@ -575,98 +576,90 @@ const SampleMatrix &EcalUncalibRecHitWorkerMultiFit::noisecor(bool barrel, int g edm::ParameterSetDescription EcalUncalibRecHitWorkerMultiFit::getAlgoDescription() { - - edm::ParameterSetDescription psd0; - edm::ParameterSetDescription psd1; - psd1.addNode(edm::ParameterDescription>("EBPulseShapeTemplate", {1.13979e-02, 7.58151e-01, 1.00000e+00, 8.87744e-01, 6.73548e-01, 4.74332e-01, 3.19561e-01, 2.15144e-01, 1.47464e-01, 1.01087e-01, 6.93181e-02, 4.75044e-02}, true) and - edm::ParameterDescription>("EEPulseShapeTemplate", {1.16442e-01, 7.56246e-01, 1.00000e+00, 8.97182e-01, 6.86831e-01, 4.91506e-01, 3.44111e-01, 2.45731e-01, 1.74115e-01, 1.23361e-01, 8.74288e-02, 6.19570e-02}, true)); - psd0.add("ecal_pulse_shape_parameters", psd1); - - edm::ParameterSetDescription psd2; - psd2.addNode(edm::ParameterDescription("EEdigiCollection", "", true) and - edm::ParameterDescription("EBdigiCollection", "", true) and - edm::ParameterDescription("ESdigiCollection", "", true) and - edm::ParameterDescription("UseLCcorrection", true, true) and - edm::ParameterDescription>("EBCorrNoiseMatrixG12", {1.00000, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 }, true) and - edm::ParameterDescription>("EECorrNoiseMatrixG12", {1.00000, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 }, true) and - edm::ParameterDescription>("EBCorrNoiseMatrixG06", {1.00000, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 }, true) and - edm::ParameterDescription>("EECorrNoiseMatrixG06", {1.00000, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 }, true) and - edm::ParameterDescription>("EBCorrNoiseMatrixG01", {1.00000, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 }, true) and - edm::ParameterDescription>("EECorrNoiseMatrixG01", {1.00000, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 }, true) and - edm::ParameterDescription("EcalPreMixStage1", false, true) and - edm::ParameterDescription("EcalPreMixStage2", false, true)); - psd0.add("ecal_digi_parameters", psd2); - - edm::ParameterSetDescription psd3; - psd3.addNode(edm::ParameterDescription>("EBPulseShapeCovariance", {3.001e-06, 1.233e-05, 0.000e+00, -4.416e-06, -4.571e-06, -3.614e-06, -2.636e-06, -1.286e-06, -8.410e-07, -5.296e-07, 0.000e+00, 0.000e+00, - 1.233e-05, 6.154e-05, 0.000e+00, -2.200e-05, -2.309e-05, -1.838e-05, -1.373e-05, -7.334e-06, -5.088e-06, -3.745e-06, -2.428e-06, 0.000e+00, - 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, - -4.416e-06, -2.200e-05, 0.000e+00, 8.319e-06, 8.545e-06, 6.792e-06, 5.059e-06, 2.678e-06, 1.816e-06, 1.223e-06, 8.245e-07, 5.589e-07, - -4.571e-06, -2.309e-05, 0.000e+00, 8.545e-06, 9.182e-06, 7.219e-06, 5.388e-06, 2.853e-06, 1.944e-06, 1.324e-06, 9.083e-07, 6.335e-07, - -3.614e-06, -1.838e-05, 0.000e+00, 6.792e-06, 7.219e-06, 6.016e-06, 4.437e-06, 2.385e-06, 1.636e-06, 1.118e-06, 7.754e-07, 5.556e-07, - -2.636e-06, -1.373e-05, 0.000e+00, 5.059e-06, 5.388e-06, 4.437e-06, 3.602e-06, 1.917e-06, 1.322e-06, 9.079e-07, 6.529e-07, 4.752e-07, - -1.286e-06, -7.334e-06, 0.000e+00, 2.678e-06, 2.853e-06, 2.385e-06, 1.917e-06, 1.375e-06, 9.100e-07, 6.455e-07, 4.693e-07, 3.657e-07, - -8.410e-07, -5.088e-06, 0.000e+00, 1.816e-06, 1.944e-06, 1.636e-06, 1.322e-06, 9.100e-07, 9.115e-07, 6.062e-07, 4.436e-07, 3.422e-07, - -5.296e-07, -3.745e-06, 0.000e+00, 1.223e-06, 1.324e-06, 1.118e-06, 9.079e-07, 6.455e-07, 6.062e-07, 7.217e-07, 4.862e-07, 3.768e-07, - 0.000e+00, -2.428e-06, 0.000e+00, 8.245e-07, 9.083e-07, 7.754e-07, 6.529e-07, 4.693e-07, 4.436e-07, 4.862e-07, 6.509e-07, 4.418e-07, - 0.000e+00, 0.000e+00, 0.000e+00, 5.589e-07, 6.335e-07, 5.556e-07, 4.752e-07, 3.657e-07, 3.422e-07, 3.768e-07, 4.418e-07, 6.142e-07}, true) and - edm::ParameterDescription>("EEPulseShapeCovariance", {3.941e-05, 3.333e-05, 0.000e+00, -1.449e-05, -1.661e-05, -1.424e-05, -1.183e-05, -6.842e-06, -4.915e-06, -3.411e-06, 0.000e+00, 0.000e+00, - 3.333e-05, 2.862e-05, 0.000e+00, -1.244e-05, -1.431e-05, -1.233e-05, -1.032e-05, -5.883e-06, -4.154e-06, -2.902e-06, -2.128e-06, 0.000e+00, - 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, - -1.449e-05, -1.244e-05, 0.000e+00, 5.840e-06, 6.649e-06, 5.720e-06, 4.812e-06, 2.708e-06, 1.869e-06, 1.330e-06, 9.186e-07, 6.446e-07, - -1.661e-05, -1.431e-05, 0.000e+00, 6.649e-06, 7.966e-06, 6.898e-06, 5.794e-06, 3.157e-06, 2.184e-06, 1.567e-06, 1.084e-06, 7.575e-07, - -1.424e-05, -1.233e-05, 0.000e+00, 5.720e-06, 6.898e-06, 6.341e-06, 5.347e-06, 2.859e-06, 1.991e-06, 1.431e-06, 9.839e-07, 6.886e-07, - -1.183e-05, -1.032e-05, 0.000e+00, 4.812e-06, 5.794e-06, 5.347e-06, 4.854e-06, 2.628e-06, 1.809e-06, 1.289e-06, 9.020e-07, 6.146e-07, - -6.842e-06, -5.883e-06, 0.000e+00, 2.708e-06, 3.157e-06, 2.859e-06, 2.628e-06, 1.863e-06, 1.296e-06, 8.882e-07, 6.108e-07, 4.283e-07, - -4.915e-06, -4.154e-06, 0.000e+00, 1.869e-06, 2.184e-06, 1.991e-06, 1.809e-06, 1.296e-06, 1.217e-06, 8.669e-07, 5.751e-07, 3.882e-07, - -3.411e-06, -2.902e-06, 0.000e+00, 1.330e-06, 1.567e-06, 1.431e-06, 1.289e-06, 8.882e-07, 8.669e-07, 9.522e-07, 6.717e-07, 4.293e-07, - 0.000e+00, -2.128e-06, 0.000e+00, 9.186e-07, 1.084e-06, 9.839e-07, 9.020e-07, 6.108e-07, 5.751e-07, 6.717e-07, 7.911e-07, 5.493e-07, - 0.000e+00, 0.000e+00, 0.000e+00, 6.446e-07, 7.575e-07, 6.886e-07, 6.146e-07, 4.283e-07, 3.882e-07, 4.293e-07, 5.493e-07, 7.027e-07}, true)); - - psd0.add("ecal_pulse_shape_covariances", psd3); - - - edm::ParameterSetDescription pset; - pset.addNode(edm::ParameterDescription>("activeBXs", {-5,-4,-3,-2,-1,0,1,2,3,4}, true) and - edm::ParameterDescription("ampErrorCalculation", true, true) and - edm::ParameterDescription("useLumiInfoRunHeader", true, true) and - edm::ParameterDescription("doPrefitEB", false, true) and - edm::ParameterDescription("doPrefitEE", false, true) and - edm::ParameterDescription("prefitMaxChiSqEB", 25., true) and - edm::ParameterDescription("prefitMaxChiSqEE", 10., true) and - edm::ParameterDescription("timealgo", "RatioMethod", true) and - edm::ParameterDescription>("EBtimeFitParameters", {-2.015452e+00, 3.130702e+00, -1.234730e+01, 4.188921e+01, -8.283944e+01, 9.101147e+01, -5.035761e+01, 1.105621e+01}, true) and - edm::ParameterDescription>("EEtimeFitParameters", {-2.390548e+00, 3.553628e+00, -1.762341e+01, 6.767538e+01, -1.332130e+02, 1.407432e+02, -7.541106e+01, 1.620277e+01}, true) and - edm::ParameterDescription>("EBamplitudeFitParameters", {1.138,1.652}, true) and - edm::ParameterDescription>("EEamplitudeFitParameters", {1.890,1.400}, true) and - edm::ParameterDescription("EBtimeFitLimits_Lower", 0.2, true) and - edm::ParameterDescription("EBtimeFitLimits_Upper", 1.4, true) and - edm::ParameterDescription("EEtimeFitLimits_Lower", 0.2, true) and - edm::ParameterDescription("EEtimeFitLimits_Upper", 1.4, true) and - edm::ParameterDescription("EBtimeConstantTerm", .6, true) and - edm::ParameterDescription("EEtimeConstantTerm", 1.0, true) and - edm::ParameterDescription("EBtimeNconst", 28.5, true) and - edm::ParameterDescription("EEtimeNconst", 31.8, true) and - edm::ParameterDescription("outOfTimeThresholdGain12pEB", 5, true) and - edm::ParameterDescription("outOfTimeThresholdGain12mEB", 5, true) and - edm::ParameterDescription("outOfTimeThresholdGain61pEB", 5, true) and - edm::ParameterDescription("outOfTimeThresholdGain61mEB", 5, true) and - edm::ParameterDescription("outOfTimeThresholdGain12pEE", 1000, true) and - edm::ParameterDescription("outOfTimeThresholdGain12mEE", 1000, true) and - edm::ParameterDescription("outOfTimeThresholdGain61pEE", 1000, true) and - edm::ParameterDescription("outOfTimeThresholdGain61mEE", 1000, true) and - edm::ParameterDescription("amplitudeThresholdEB", 10, true) and - edm::ParameterDescription("amplitudeThresholdEE", 10, true) and - edm::ParameterDescription("ebSpikeThreshold", 1.042, true) and - edm::ParameterDescription>("ebPulseShape", {5.2e-05,-5.26e-05 , 6.66e-05, 0.1168, 0.7575, 1., 0.8876, 0.6732, 0.4741, 0.3194}, true) and - edm::ParameterDescription>("eePulseShape", {5.2e-05,-5.26e-05 , 6.66e-05, 0.1168, 0.7575, 1., 0.8876, 0.6732, 0.4741, 0.3194}, true) and - edm::ParameterDescription("kPoorRecoFlagEB", true, true) and - edm::ParameterDescription("kPoorRecoFlagEE", false, true) and - edm::ParameterDescription("chi2ThreshEB_", 65.0, true) and - edm::ParameterDescription("chi2ThreshEE_", 50.0, true) and - edm::ParameterDescription("EcalPulseShapeParameters", psd0, true)); - - return pset; + + edm::ParameterSetDescription psd0; + psd0.addNode((edm::ParameterDescription>("EBPulseShapeTemplate", {1.13979e-02, 7.58151e-01, 1.00000e+00, 8.87744e-01, 6.73548e-01, 4.74332e-01, 3.19561e-01, 2.15144e-01, 1.47464e-01, 1.01087e-01, 6.93181e-02, 4.75044e-02}, true) and + edm::ParameterDescription>("EEPulseShapeTemplate", {1.16442e-01, 7.56246e-01, 1.00000e+00, 8.97182e-01, 6.86831e-01, 4.91506e-01, 3.44111e-01, 2.45731e-01, 1.74115e-01, 1.23361e-01, 8.74288e-02, 6.19570e-02}, true))); + + psd0.addNode((edm::ParameterDescription("EEdigiCollection", "", true) and + edm::ParameterDescription("EBdigiCollection", "", true) and + edm::ParameterDescription("ESdigiCollection", "", true) and + edm::ParameterDescription("UseLCcorrection", true, false) and + edm::ParameterDescription>("EBCorrNoiseMatrixG12", {1.00000, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 }, true) and + edm::ParameterDescription>("EECorrNoiseMatrixG12", {1.00000, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 }, true) and + edm::ParameterDescription>("EBCorrNoiseMatrixG06", {1.00000, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 }, true) and + edm::ParameterDescription>("EECorrNoiseMatrixG06", {1.00000, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 }, true) and + edm::ParameterDescription>("EBCorrNoiseMatrixG01", {1.00000, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 }, true) and + edm::ParameterDescription>("EECorrNoiseMatrixG01", {1.00000, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 }, true) and + edm::ParameterDescription("EcalPreMixStage1", false, true) and + edm::ParameterDescription("EcalPreMixStage2", false, true))); + + psd0.addOptionalNode((edm::ParameterDescription>("EBPulseShapeCovariance", {3.001e-06, 1.233e-05, 0.000e+00, -4.416e-06, -4.571e-06, -3.614e-06, -2.636e-06, -1.286e-06, -8.410e-07, -5.296e-07, 0.000e+00, 0.000e+00, + 1.233e-05, 6.154e-05, 0.000e+00, -2.200e-05, -2.309e-05, -1.838e-05, -1.373e-05, -7.334e-06, -5.088e-06, -3.745e-06, -2.428e-06, 0.000e+00, + 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, + -4.416e-06, -2.200e-05, 0.000e+00, 8.319e-06, 8.545e-06, 6.792e-06, 5.059e-06, 2.678e-06, 1.816e-06, 1.223e-06, 8.245e-07, 5.589e-07, + -4.571e-06, -2.309e-05, 0.000e+00, 8.545e-06, 9.182e-06, 7.219e-06, 5.388e-06, 2.853e-06, 1.944e-06, 1.324e-06, 9.083e-07, 6.335e-07, + -3.614e-06, -1.838e-05, 0.000e+00, 6.792e-06, 7.219e-06, 6.016e-06, 4.437e-06, 2.385e-06, 1.636e-06, 1.118e-06, 7.754e-07, 5.556e-07, + -2.636e-06, -1.373e-05, 0.000e+00, 5.059e-06, 5.388e-06, 4.437e-06, 3.602e-06, 1.917e-06, 1.322e-06, 9.079e-07, 6.529e-07, 4.752e-07, + -1.286e-06, -7.334e-06, 0.000e+00, 2.678e-06, 2.853e-06, 2.385e-06, 1.917e-06, 1.375e-06, 9.100e-07, 6.455e-07, 4.693e-07, 3.657e-07, + -8.410e-07, -5.088e-06, 0.000e+00, 1.816e-06, 1.944e-06, 1.636e-06, 1.322e-06, 9.100e-07, 9.115e-07, 6.062e-07, 4.436e-07, 3.422e-07, + -5.296e-07, -3.745e-06, 0.000e+00, 1.223e-06, 1.324e-06, 1.118e-06, 9.079e-07, 6.455e-07, 6.062e-07, 7.217e-07, 4.862e-07, 3.768e-07, + 0.000e+00, -2.428e-06, 0.000e+00, 8.245e-07, 9.083e-07, 7.754e-07, 6.529e-07, 4.693e-07, 4.436e-07, 4.862e-07, 6.509e-07, 4.418e-07, + 0.000e+00, 0.000e+00, 0.000e+00, 5.589e-07, 6.335e-07, 5.556e-07, 4.752e-07, 3.657e-07, 3.422e-07, 3.768e-07, 4.418e-07, 6.142e-07}, true) and + edm::ParameterDescription>("EEPulseShapeCovariance", {3.941e-05, 3.333e-05, 0.000e+00, -1.449e-05, -1.661e-05, -1.424e-05, -1.183e-05, -6.842e-06, -4.915e-06, -3.411e-06, 0.000e+00, 0.000e+00, + 3.333e-05, 2.862e-05, 0.000e+00, -1.244e-05, -1.431e-05, -1.233e-05, -1.032e-05, -5.883e-06, -4.154e-06, -2.902e-06, -2.128e-06, 0.000e+00, + 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, 0.000e+00, + -1.449e-05, -1.244e-05, 0.000e+00, 5.840e-06, 6.649e-06, 5.720e-06, 4.812e-06, 2.708e-06, 1.869e-06, 1.330e-06, 9.186e-07, 6.446e-07, + -1.661e-05, -1.431e-05, 0.000e+00, 6.649e-06, 7.966e-06, 6.898e-06, 5.794e-06, 3.157e-06, 2.184e-06, 1.567e-06, 1.084e-06, 7.575e-07, + -1.424e-05, -1.233e-05, 0.000e+00, 5.720e-06, 6.898e-06, 6.341e-06, 5.347e-06, 2.859e-06, 1.991e-06, 1.431e-06, 9.839e-07, 6.886e-07, + -1.183e-05, -1.032e-05, 0.000e+00, 4.812e-06, 5.794e-06, 5.347e-06, 4.854e-06, 2.628e-06, 1.809e-06, 1.289e-06, 9.020e-07, 6.146e-07, + -6.842e-06, -5.883e-06, 0.000e+00, 2.708e-06, 3.157e-06, 2.859e-06, 2.628e-06, 1.863e-06, 1.296e-06, 8.882e-07, 6.108e-07, 4.283e-07, + -4.915e-06, -4.154e-06, 0.000e+00, 1.869e-06, 2.184e-06, 1.991e-06, 1.809e-06, 1.296e-06, 1.217e-06, 8.669e-07, 5.751e-07, 3.882e-07, + -3.411e-06, -2.902e-06, 0.000e+00, 1.330e-06, 1.567e-06, 1.431e-06, 1.289e-06, 8.882e-07, 8.669e-07, 9.522e-07, 6.717e-07, 4.293e-07, + 0.000e+00, -2.128e-06, 0.000e+00, 9.186e-07, 1.084e-06, 9.839e-07, 9.020e-07, 6.108e-07, 5.751e-07, 6.717e-07, 7.911e-07, 5.493e-07, + 0.000e+00, 0.000e+00, 0.000e+00, 6.446e-07, 7.575e-07, 6.886e-07, 6.146e-07, 4.283e-07, 3.882e-07, 4.293e-07, 5.493e-07, 7.027e-07}, true)), true); + + edm::ParameterSetDescription psd; + psd.addNode(edm::ParameterDescription>("activeBXs", {-5,-4,-3,-2,-1,0,1,2,3,4}, true) and + edm::ParameterDescription("ampErrorCalculation", true, true) and + edm::ParameterDescription("useLumiInfoRunHeader", true, true) and + edm::ParameterDescription("doPrefitEB", false, true) and + edm::ParameterDescription("doPrefitEE", false, true) and + edm::ParameterDescription("prefitMaxChiSqEB", 25., true) and + edm::ParameterDescription("prefitMaxChiSqEE", 10., true) and + edm::ParameterDescription("timealgo", "RatioMethod", true) and + edm::ParameterDescription>("EBtimeFitParameters", {-2.015452e+00, 3.130702e+00, -1.234730e+01, 4.188921e+01, -8.283944e+01, 9.101147e+01, -5.035761e+01, 1.105621e+01}, true) and + edm::ParameterDescription>("EEtimeFitParameters", {-2.390548e+00, 3.553628e+00, -1.762341e+01, 6.767538e+01, -1.332130e+02, 1.407432e+02, -7.541106e+01, 1.620277e+01}, true) and + edm::ParameterDescription>("EBamplitudeFitParameters", {1.138,1.652}, true) and + edm::ParameterDescription>("EEamplitudeFitParameters", {1.890,1.400}, true) and + edm::ParameterDescription("EBtimeFitLimits_Lower", 0.2, true) and + edm::ParameterDescription("EBtimeFitLimits_Upper", 1.4, true) and + edm::ParameterDescription("EEtimeFitLimits_Lower", 0.2, true) and + edm::ParameterDescription("EEtimeFitLimits_Upper", 1.4, true) and + edm::ParameterDescription("EBtimeConstantTerm", .6, true) and + edm::ParameterDescription("EEtimeConstantTerm", 1.0, true) and + edm::ParameterDescription("EBtimeNconst", 28.5, true) and + edm::ParameterDescription("EEtimeNconst", 31.8, true) and + edm::ParameterDescription("outOfTimeThresholdGain12pEB", 5, true) and + edm::ParameterDescription("outOfTimeThresholdGain12mEB", 5, true) and + edm::ParameterDescription("outOfTimeThresholdGain61pEB", 5, true) and + edm::ParameterDescription("outOfTimeThresholdGain61mEB", 5, true) and + edm::ParameterDescription("outOfTimeThresholdGain12pEE", 1000, true) and + edm::ParameterDescription("outOfTimeThresholdGain12mEE", 1000, true) and + edm::ParameterDescription("outOfTimeThresholdGain61pEE", 1000, true) and + edm::ParameterDescription("outOfTimeThresholdGain61mEE", 1000, true) and + edm::ParameterDescription("amplitudeThresholdEB", 10, true) and + edm::ParameterDescription("amplitudeThresholdEE", 10, true) and + edm::ParameterDescription("ebSpikeThreshold", 1.042, true) and + edm::ParameterDescription>("ebPulseShape", {5.2e-05,-5.26e-05 , 6.66e-05, 0.1168, 0.7575, 1., 0.8876, 0.6732, 0.4741, 0.3194}, true) and + edm::ParameterDescription>("eePulseShape", {5.2e-05,-5.26e-05 , 6.66e-05, 0.1168, 0.7575, 1., 0.8876, 0.6732, 0.4741, 0.3194}, true) and + edm::ParameterDescription("kPoorRecoFlagEB", true, true) and + edm::ParameterDescription("kPoorRecoFlagEE", false, true) and + edm::ParameterDescription("chi2ThreshEB_", 65.0, true) and + edm::ParameterDescription("chi2ThreshEE_", 50.0, true) and + edm::ParameterDescription("EcalPulseShapeParameters", psd0, true)); + + return psd; } diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc index de822b18026db..80a97d0a93908 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerRatio.cc @@ -130,11 +130,11 @@ EcalUncalibRecHitWorkerRatio::run( const edm::Event & evt, edm::ParameterSetDescription EcalUncalibRecHitWorkerRatio::getAlgoDescription() { - edm::ParameterSetDescription pset; + edm::ParameterSetDescription psd; std::vector dSet1 = {-2.390548,3.553628,-17.62341,67.67538,-133.213,140.7432,-75.41106,16.20277}; std::vector dSet2 = {-2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621}; - pset.addNode(edm::ParameterDescription("EEtimeFitLimits_Upper", 1.4, true) and + psd.addNode(edm::ParameterDescription("EEtimeFitLimits_Upper", 1.4, true) and edm::ParameterDescription("EEtimeConstantTerm", 0.18, true) and edm::ParameterDescription("EBtimeFitLimits_Lower", 0.2, true) and edm::ParameterDescription("EBtimeConstantTerm", 0.26, true) and @@ -145,7 +145,7 @@ EcalUncalibRecHitWorkerRatio::getAlgoDescription() { edm::ParameterDescription>("EBamplitudeFitParameters", {1.138,1.652}, true) and edm::ParameterDescription>("EBtimeFitParameters", dSet2, true) ); - return pset; + return psd; } #include "FWCore/Framework/interface/MakerMacros.h" diff --git a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.cc b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.cc index 488b39b9637a6..28cc203a92961 100644 --- a/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.cc +++ b/RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitWorkerWeights.cc @@ -102,14 +102,8 @@ EcalUncalibRecHitWorkerWeights::run( const edm::Event & evt, edm::ParameterSetDescription EcalUncalibRecHitWorkerWeights::getAlgoDescription() { - edm::ParameterSetDescription pset; -//pset.addNode(edm::ParameterSet("EBdigiCollection", edm::InputTag("ecalDigis","ebDigis")) and -// edm::ParameterSet("EEhitCollection", "EcalUncalibRecHitsEE") and -// edm::ParameterSet("EEdigiCollection", edm::InputTag("ecalDigis","eeDigis")) and -// edm::ParameterSet("algo", "EcalUncalibRecHitWorkerWeights") and -// edm::ParameterSet("EBhitCollection", "EcalUncalibRecHitsEB")); -// - return pset; + edm::ParameterSetDescription psd; + return psd; } #include "FWCore/Framework/interface/MakerMacros.h" From 41e8819dc228727e2f56355635b042d93239d4f7 Mon Sep 17 00:00:00 2001 From: Martin Grunewald Date: Tue, 24 Feb 2015 08:59:10 +0100 Subject: [PATCH 12/22] Update for Ecal/fillDescription/MultiFit --- .../python/HLT_50nsGRun_Famos_cff.py | 70 +--------- .../Configuration/python/HLT_50nsGRun_cff.py | 70 +--------- .../python/HLT_FULL_Famos_cff.py | 126 +++++++++--------- .../Configuration/python/HLT_FULL_cff.py | 126 +++++++++--------- .../python/HLT_Fake_Famos_cff.py | 4 +- .../Configuration/python/HLT_Fake_cff.py | 4 +- .../python/HLT_GRun_Famos_cff.py | 126 +++++++++--------- .../Configuration/python/HLT_GRun_cff.py | 126 +++++++++--------- .../Configuration/python/HLT_HIon_cff.py | 126 +++++++++--------- .../Configuration/python/HLT_PIon_cff.py | 126 +++++++++--------- .../Configuration/test/OnData_HLT_50nsGRun.py | 70 +--------- .../Configuration/test/OnData_HLT_FULL.py | 126 +++++++++--------- .../Configuration/test/OnData_HLT_Fake.py | 4 +- .../Configuration/test/OnData_HLT_GRun.py | 126 +++++++++--------- .../Configuration/test/OnData_HLT_HIon.py | 126 +++++++++--------- .../Configuration/test/OnData_HLT_PIon.py | 126 +++++++++--------- .../Configuration/test/OnMc_HLT_50nsGRun.py | 70 +--------- HLTrigger/Configuration/test/OnMc_HLT_FULL.py | 126 +++++++++--------- HLTrigger/Configuration/test/OnMc_HLT_Fake.py | 4 +- HLTrigger/Configuration/test/OnMc_HLT_GRun.py | 126 +++++++++--------- HLTrigger/Configuration/test/OnMc_HLT_HIon.py | 126 +++++++++--------- HLTrigger/Configuration/test/OnMc_HLT_PIon.py | 126 +++++++++--------- 22 files changed, 864 insertions(+), 1196 deletions(-) diff --git a/HLTrigger/Configuration/python/HLT_50nsGRun_Famos_cff.py b/HLTrigger/Configuration/python/HLT_50nsGRun_Famos_cff.py index 608f564181b66..72513013c06b6 100644 --- a/HLTrigger/Configuration/python/HLT_50nsGRun_Famos_cff.py +++ b/HLTrigger/Configuration/python/HLT_50nsGRun_Famos_cff.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/50nsGRun/V3 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/50nsGRun/V9 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms from FastSimulation.HighLevelTrigger.HLTSetup_cff import * HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V3') + tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V9') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1536,73 +1536,11 @@ ) hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - alphaEB = cms.double( 1.138 ), - alphaEE = cms.double( 1.89 ), EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - AlphaBetaFilename = cms.untracked.string( "NOFILE" ), - betaEB = cms.double( 1.655 ), - MinAmplEndcap = cms.double( 14.0 ), - MinAmplBarrel = cms.double( 8.0 ), - algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), - betaEE = cms.double( 1.4 ), - UseDynamicPedestal = cms.bool( True ), EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( True ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( True ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 25.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( False ), - doPrefitEB = cms.bool( False ) + algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), + algoPSet = cms.PSet( ) ) hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), diff --git a/HLTrigger/Configuration/python/HLT_50nsGRun_cff.py b/HLTrigger/Configuration/python/HLT_50nsGRun_cff.py index 2d0d2aa527151..2ea4e6460cca2 100644 --- a/HLTrigger/Configuration/python/HLT_50nsGRun_cff.py +++ b/HLTrigger/Configuration/python/HLT_50nsGRun_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_4_0/50nsGRun/V3 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/50nsGRun/V9 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V3') + tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V9') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1945,73 +1945,11 @@ ) hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - alphaEB = cms.double( 1.138 ), - alphaEE = cms.double( 1.89 ), EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - AlphaBetaFilename = cms.untracked.string( "NOFILE" ), - betaEB = cms.double( 1.655 ), - MinAmplEndcap = cms.double( 14.0 ), - MinAmplBarrel = cms.double( 8.0 ), - algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), - betaEE = cms.double( 1.4 ), - UseDynamicPedestal = cms.bool( True ), EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( True ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( True ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 25.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( False ), - doPrefitEB = cms.bool( False ) + algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), + algoPSet = cms.PSet( ) ) hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), diff --git a/HLTrigger/Configuration/python/HLT_FULL_Famos_cff.py b/HLTrigger/Configuration/python/HLT_FULL_Famos_cff.py index 606e4ea22a734..2a99d4f2e0f35 100644 --- a/HLTrigger/Configuration/python/HLT_FULL_Famos_cff.py +++ b/HLTrigger/Configuration/python/HLT_FULL_Famos_cff.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/HLT/V2 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/HLT/V6 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms from FastSimulation.HighLevelTrigger.HLTSetup_cff import * HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V2') + tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V6') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1526,73 +1526,67 @@ ) hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - alphaEB = cms.double( 1.138 ), - alphaEE = cms.double( 1.89 ), EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - AlphaBetaFilename = cms.untracked.string( "NOFILE" ), - betaEB = cms.double( 1.655 ), - MinAmplEndcap = cms.double( 14.0 ), - MinAmplBarrel = cms.double( 8.0 ), - algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), - betaEE = cms.double( 1.4 ), - UseDynamicPedestal = cms.bool( True ), EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( True ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( True ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 25.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( False ), - doPrefitEB = cms.bool( False ) + algo = cms.string( "EcalUncalibRecHitWorkerMultiFit" ), + algoPSet = cms.PSet( + outOfTimeThresholdGain61pEB = cms.double( 5.0 ), + eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EcalPulseShapeParameters = cms.PSet( + EcalPreMixStage2 = cms.bool( False ), + EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), + EcalPreMixStage1 = cms.bool( False ), + EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), + EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), + EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), + EBdigiCollection = cms.string( "" ), + EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), + EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), + ESdigiCollection = cms.string( "" ), + EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), + EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), + EEdigiCollection = cms.string( "" ), + EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), + EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), + UseLCcorrection = cms.untracked.bool( True ) + ), + EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), + activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), + amplitudeThresholdEE = cms.double( 10.0 ), + EBtimeConstantTerm = cms.double( 0.6 ), + EEtimeFitLimits_Lower = cms.double( 0.2 ), + outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), + ebSpikeThreshold = cms.double( 1.042 ), + EBtimeNconst = cms.double( 28.5 ), + ampErrorCalculation = cms.bool( False ), + kPoorRecoFlagEB = cms.bool( True ), + ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EBtimeFitLimits_Lower = cms.double( 0.2 ), + kPoorRecoFlagEE = cms.bool( False ), + chi2ThreshEB_ = cms.double( 65.0 ), + EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), + useLumiInfoRunHeader = cms.bool( False ), + outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12mEB = cms.double( 5.0 ), + EEtimeFitLimits_Upper = cms.double( 1.4 ), + prefitMaxChiSqEB = cms.double( 100.0 ), + EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), + prefitMaxChiSqEE = cms.double( 10.0 ), + EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), + EBtimeFitLimits_Upper = cms.double( 1.4 ), + timealgo = cms.string( "RatioMethod" ), + amplitudeThresholdEB = cms.double( 10.0 ), + outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12pEB = cms.double( 5.0 ), + EEtimeNconst = cms.double( 31.8 ), + outOfTimeThresholdGain61mEB = cms.double( 5.0 ), + outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), + EEtimeConstantTerm = cms.double( 1.0 ), + chi2ThreshEE_ = cms.double( 50.0 ), + doPrefitEE = cms.bool( True ), + doPrefitEB = cms.bool( True ) + ) ) hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), diff --git a/HLTrigger/Configuration/python/HLT_FULL_cff.py b/HLTrigger/Configuration/python/HLT_FULL_cff.py index 4fcaaa296cc1c..1c1196bec9e72 100644 --- a/HLTrigger/Configuration/python/HLT_FULL_cff.py +++ b/HLTrigger/Configuration/python/HLT_FULL_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_4_0/HLT/V2 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/HLT/V6 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V2') + tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V6') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1958,73 +1958,67 @@ ) hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - alphaEB = cms.double( 1.138 ), - alphaEE = cms.double( 1.89 ), EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - AlphaBetaFilename = cms.untracked.string( "NOFILE" ), - betaEB = cms.double( 1.655 ), - MinAmplEndcap = cms.double( 14.0 ), - MinAmplBarrel = cms.double( 8.0 ), - algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), - betaEE = cms.double( 1.4 ), - UseDynamicPedestal = cms.bool( True ), EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( True ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( True ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 25.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( False ), - doPrefitEB = cms.bool( False ) + algo = cms.string( "EcalUncalibRecHitWorkerMultiFit" ), + algoPSet = cms.PSet( + outOfTimeThresholdGain61pEB = cms.double( 5.0 ), + eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EcalPulseShapeParameters = cms.PSet( + EcalPreMixStage2 = cms.bool( False ), + EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), + EcalPreMixStage1 = cms.bool( False ), + EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), + EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), + EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), + EBdigiCollection = cms.string( "" ), + EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), + EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), + ESdigiCollection = cms.string( "" ), + EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), + EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), + EEdigiCollection = cms.string( "" ), + EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), + EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), + UseLCcorrection = cms.untracked.bool( True ) + ), + EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), + activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), + amplitudeThresholdEE = cms.double( 10.0 ), + EBtimeConstantTerm = cms.double( 0.6 ), + EEtimeFitLimits_Lower = cms.double( 0.2 ), + outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), + ebSpikeThreshold = cms.double( 1.042 ), + EBtimeNconst = cms.double( 28.5 ), + ampErrorCalculation = cms.bool( False ), + kPoorRecoFlagEB = cms.bool( True ), + ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EBtimeFitLimits_Lower = cms.double( 0.2 ), + kPoorRecoFlagEE = cms.bool( False ), + chi2ThreshEB_ = cms.double( 65.0 ), + EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), + useLumiInfoRunHeader = cms.bool( False ), + outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12mEB = cms.double( 5.0 ), + EEtimeFitLimits_Upper = cms.double( 1.4 ), + prefitMaxChiSqEB = cms.double( 100.0 ), + EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), + prefitMaxChiSqEE = cms.double( 10.0 ), + EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), + EBtimeFitLimits_Upper = cms.double( 1.4 ), + timealgo = cms.string( "RatioMethod" ), + amplitudeThresholdEB = cms.double( 10.0 ), + outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12pEB = cms.double( 5.0 ), + EEtimeNconst = cms.double( 31.8 ), + outOfTimeThresholdGain61mEB = cms.double( 5.0 ), + outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), + EEtimeConstantTerm = cms.double( 1.0 ), + chi2ThreshEE_ = cms.double( 50.0 ), + doPrefitEE = cms.bool( True ), + doPrefitEB = cms.bool( True ) + ) ) hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), diff --git a/HLTrigger/Configuration/python/HLT_Fake_Famos_cff.py b/HLTrigger/Configuration/python/HLT_Fake_Famos_cff.py index d8bc8310722b9..e3d01cc213aff 100644 --- a/HLTrigger/Configuration/python/HLT_Fake_Famos_cff.py +++ b/HLTrigger/Configuration/python/HLT_Fake_Famos_cff.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/Fake/V2 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/Fake/V3 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms from FastSimulation.HighLevelTrigger.HLTSetup_cff import * HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/Fake/V2') + tableName = cms.string('/dev/CMSSW_7_4_0/Fake/V3') ) hltGetConditions = cms.EDAnalyzer( "EventSetupRecordDataGetter", diff --git a/HLTrigger/Configuration/python/HLT_Fake_cff.py b/HLTrigger/Configuration/python/HLT_Fake_cff.py index b01e09d6add62..6448a6d8b4e76 100644 --- a/HLTrigger/Configuration/python/HLT_Fake_cff.py +++ b/HLTrigger/Configuration/python/HLT_Fake_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_4_0/Fake/V2 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/Fake/V3 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/Fake/V2') + tableName = cms.string('/dev/CMSSW_7_4_0/Fake/V3') ) streams = cms.PSet( A = cms.vstring( 'InitialPD' ) ) diff --git a/HLTrigger/Configuration/python/HLT_GRun_Famos_cff.py b/HLTrigger/Configuration/python/HLT_GRun_Famos_cff.py index 128a59cbac219..c0778df53d829 100644 --- a/HLTrigger/Configuration/python/HLT_GRun_Famos_cff.py +++ b/HLTrigger/Configuration/python/HLT_GRun_Famos_cff.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/GRun/V1 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/GRun/V4 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms from FastSimulation.HighLevelTrigger.HLTSetup_cff import * HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V1') + tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V4') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1526,73 +1526,67 @@ ) hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - alphaEB = cms.double( 1.138 ), - alphaEE = cms.double( 1.89 ), EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - AlphaBetaFilename = cms.untracked.string( "NOFILE" ), - betaEB = cms.double( 1.655 ), - MinAmplEndcap = cms.double( 14.0 ), - MinAmplBarrel = cms.double( 8.0 ), - algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), - betaEE = cms.double( 1.4 ), - UseDynamicPedestal = cms.bool( True ), EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( True ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( True ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 25.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( False ), - doPrefitEB = cms.bool( False ) + algo = cms.string( "EcalUncalibRecHitWorkerMultiFit" ), + algoPSet = cms.PSet( + outOfTimeThresholdGain61pEB = cms.double( 5.0 ), + eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EcalPulseShapeParameters = cms.PSet( + EcalPreMixStage2 = cms.bool( False ), + EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), + EcalPreMixStage1 = cms.bool( False ), + EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), + EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), + EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), + EBdigiCollection = cms.string( "" ), + EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), + EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), + ESdigiCollection = cms.string( "" ), + EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), + EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), + EEdigiCollection = cms.string( "" ), + EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), + EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), + UseLCcorrection = cms.untracked.bool( True ) + ), + EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), + activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), + amplitudeThresholdEE = cms.double( 10.0 ), + EBtimeConstantTerm = cms.double( 0.6 ), + EEtimeFitLimits_Lower = cms.double( 0.2 ), + outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), + ebSpikeThreshold = cms.double( 1.042 ), + EBtimeNconst = cms.double( 28.5 ), + ampErrorCalculation = cms.bool( False ), + kPoorRecoFlagEB = cms.bool( True ), + ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EBtimeFitLimits_Lower = cms.double( 0.2 ), + kPoorRecoFlagEE = cms.bool( False ), + chi2ThreshEB_ = cms.double( 65.0 ), + EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), + useLumiInfoRunHeader = cms.bool( False ), + outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12mEB = cms.double( 5.0 ), + EEtimeFitLimits_Upper = cms.double( 1.4 ), + prefitMaxChiSqEB = cms.double( 100.0 ), + EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), + prefitMaxChiSqEE = cms.double( 10.0 ), + EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), + EBtimeFitLimits_Upper = cms.double( 1.4 ), + timealgo = cms.string( "RatioMethod" ), + amplitudeThresholdEB = cms.double( 10.0 ), + outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12pEB = cms.double( 5.0 ), + EEtimeNconst = cms.double( 31.8 ), + outOfTimeThresholdGain61mEB = cms.double( 5.0 ), + outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), + EEtimeConstantTerm = cms.double( 1.0 ), + chi2ThreshEE_ = cms.double( 50.0 ), + doPrefitEE = cms.bool( True ), + doPrefitEB = cms.bool( True ) + ) ) hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), diff --git a/HLTrigger/Configuration/python/HLT_GRun_cff.py b/HLTrigger/Configuration/python/HLT_GRun_cff.py index faffd550c051f..6b7d21c3c22eb 100644 --- a/HLTrigger/Configuration/python/HLT_GRun_cff.py +++ b/HLTrigger/Configuration/python/HLT_GRun_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_4_0/GRun/V1 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/GRun/V4 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V1') + tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V4') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1930,73 +1930,67 @@ ) hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - alphaEB = cms.double( 1.138 ), - alphaEE = cms.double( 1.89 ), EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - AlphaBetaFilename = cms.untracked.string( "NOFILE" ), - betaEB = cms.double( 1.655 ), - MinAmplEndcap = cms.double( 14.0 ), - MinAmplBarrel = cms.double( 8.0 ), - algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), - betaEE = cms.double( 1.4 ), - UseDynamicPedestal = cms.bool( True ), EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( True ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( True ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 25.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( False ), - doPrefitEB = cms.bool( False ) + algo = cms.string( "EcalUncalibRecHitWorkerMultiFit" ), + algoPSet = cms.PSet( + outOfTimeThresholdGain61pEB = cms.double( 5.0 ), + eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EcalPulseShapeParameters = cms.PSet( + EcalPreMixStage2 = cms.bool( False ), + EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), + EcalPreMixStage1 = cms.bool( False ), + EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), + EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), + EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), + EBdigiCollection = cms.string( "" ), + EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), + EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), + ESdigiCollection = cms.string( "" ), + EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), + EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), + EEdigiCollection = cms.string( "" ), + EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), + EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), + UseLCcorrection = cms.untracked.bool( True ) + ), + EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), + activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), + amplitudeThresholdEE = cms.double( 10.0 ), + EBtimeConstantTerm = cms.double( 0.6 ), + EEtimeFitLimits_Lower = cms.double( 0.2 ), + outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), + ebSpikeThreshold = cms.double( 1.042 ), + EBtimeNconst = cms.double( 28.5 ), + ampErrorCalculation = cms.bool( False ), + kPoorRecoFlagEB = cms.bool( True ), + ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EBtimeFitLimits_Lower = cms.double( 0.2 ), + kPoorRecoFlagEE = cms.bool( False ), + chi2ThreshEB_ = cms.double( 65.0 ), + EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), + useLumiInfoRunHeader = cms.bool( False ), + outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12mEB = cms.double( 5.0 ), + EEtimeFitLimits_Upper = cms.double( 1.4 ), + prefitMaxChiSqEB = cms.double( 100.0 ), + EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), + prefitMaxChiSqEE = cms.double( 10.0 ), + EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), + EBtimeFitLimits_Upper = cms.double( 1.4 ), + timealgo = cms.string( "RatioMethod" ), + amplitudeThresholdEB = cms.double( 10.0 ), + outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12pEB = cms.double( 5.0 ), + EEtimeNconst = cms.double( 31.8 ), + outOfTimeThresholdGain61mEB = cms.double( 5.0 ), + outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), + EEtimeConstantTerm = cms.double( 1.0 ), + chi2ThreshEE_ = cms.double( 50.0 ), + doPrefitEE = cms.bool( True ), + doPrefitEB = cms.bool( True ) + ) ) hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), diff --git a/HLTrigger/Configuration/python/HLT_HIon_cff.py b/HLTrigger/Configuration/python/HLT_HIon_cff.py index f682c5bd91dd3..c1396a600fc65 100644 --- a/HLTrigger/Configuration/python/HLT_HIon_cff.py +++ b/HLTrigger/Configuration/python/HLT_HIon_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_4_0/HIon/V1 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/HIon/V4 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HIon/V1') + tableName = cms.string('/dev/CMSSW_7_4_0/HIon/V4') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1629,73 +1629,67 @@ ) hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - alphaEB = cms.double( 1.138 ), - alphaEE = cms.double( 1.89 ), EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - AlphaBetaFilename = cms.untracked.string( "NOFILE" ), - betaEB = cms.double( 1.655 ), - MinAmplEndcap = cms.double( 14.0 ), - MinAmplBarrel = cms.double( 8.0 ), - algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), - betaEE = cms.double( 1.4 ), - UseDynamicPedestal = cms.bool( True ), EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( True ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( True ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 25.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( False ), - doPrefitEB = cms.bool( False ) + algo = cms.string( "EcalUncalibRecHitWorkerMultiFit" ), + algoPSet = cms.PSet( + outOfTimeThresholdGain61pEB = cms.double( 5.0 ), + eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EcalPulseShapeParameters = cms.PSet( + EcalPreMixStage2 = cms.bool( False ), + EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), + EcalPreMixStage1 = cms.bool( False ), + EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), + EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), + EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), + EBdigiCollection = cms.string( "" ), + EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), + EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), + ESdigiCollection = cms.string( "" ), + EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), + EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), + EEdigiCollection = cms.string( "" ), + EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), + EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), + UseLCcorrection = cms.untracked.bool( True ) + ), + EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), + activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), + amplitudeThresholdEE = cms.double( 10.0 ), + EBtimeConstantTerm = cms.double( 0.6 ), + EEtimeFitLimits_Lower = cms.double( 0.2 ), + outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), + ebSpikeThreshold = cms.double( 1.042 ), + EBtimeNconst = cms.double( 28.5 ), + ampErrorCalculation = cms.bool( False ), + kPoorRecoFlagEB = cms.bool( True ), + ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EBtimeFitLimits_Lower = cms.double( 0.2 ), + kPoorRecoFlagEE = cms.bool( False ), + chi2ThreshEB_ = cms.double( 65.0 ), + EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), + useLumiInfoRunHeader = cms.bool( False ), + outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12mEB = cms.double( 5.0 ), + EEtimeFitLimits_Upper = cms.double( 1.4 ), + prefitMaxChiSqEB = cms.double( 100.0 ), + EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), + prefitMaxChiSqEE = cms.double( 10.0 ), + EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), + EBtimeFitLimits_Upper = cms.double( 1.4 ), + timealgo = cms.string( "RatioMethod" ), + amplitudeThresholdEB = cms.double( 10.0 ), + outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12pEB = cms.double( 5.0 ), + EEtimeNconst = cms.double( 31.8 ), + outOfTimeThresholdGain61mEB = cms.double( 5.0 ), + outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), + EEtimeConstantTerm = cms.double( 1.0 ), + chi2ThreshEE_ = cms.double( 50.0 ), + doPrefitEE = cms.bool( True ), + doPrefitEB = cms.bool( True ) + ) ) hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), diff --git a/HLTrigger/Configuration/python/HLT_PIon_cff.py b/HLTrigger/Configuration/python/HLT_PIon_cff.py index f726f522697f3..ad3f9b174636d 100644 --- a/HLTrigger/Configuration/python/HLT_PIon_cff.py +++ b/HLTrigger/Configuration/python/HLT_PIon_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_4_0/PIon/V1 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/PIon/V4 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/PIon/V1') + tableName = cms.string('/dev/CMSSW_7_4_0/PIon/V4') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1629,73 +1629,67 @@ ) hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - alphaEB = cms.double( 1.138 ), - alphaEE = cms.double( 1.89 ), EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - AlphaBetaFilename = cms.untracked.string( "NOFILE" ), - betaEB = cms.double( 1.655 ), - MinAmplEndcap = cms.double( 14.0 ), - MinAmplBarrel = cms.double( 8.0 ), - algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), - betaEE = cms.double( 1.4 ), - UseDynamicPedestal = cms.bool( True ), EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( True ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( True ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 25.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( False ), - doPrefitEB = cms.bool( False ) + algo = cms.string( "EcalUncalibRecHitWorkerMultiFit" ), + algoPSet = cms.PSet( + outOfTimeThresholdGain61pEB = cms.double( 5.0 ), + eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EcalPulseShapeParameters = cms.PSet( + EcalPreMixStage2 = cms.bool( False ), + EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), + EcalPreMixStage1 = cms.bool( False ), + EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), + EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), + EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), + EBdigiCollection = cms.string( "" ), + EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), + EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), + ESdigiCollection = cms.string( "" ), + EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), + EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), + EEdigiCollection = cms.string( "" ), + EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), + EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), + UseLCcorrection = cms.untracked.bool( True ) + ), + EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), + activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), + amplitudeThresholdEE = cms.double( 10.0 ), + EBtimeConstantTerm = cms.double( 0.6 ), + EEtimeFitLimits_Lower = cms.double( 0.2 ), + outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), + ebSpikeThreshold = cms.double( 1.042 ), + EBtimeNconst = cms.double( 28.5 ), + ampErrorCalculation = cms.bool( False ), + kPoorRecoFlagEB = cms.bool( True ), + ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EBtimeFitLimits_Lower = cms.double( 0.2 ), + kPoorRecoFlagEE = cms.bool( False ), + chi2ThreshEB_ = cms.double( 65.0 ), + EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), + useLumiInfoRunHeader = cms.bool( False ), + outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12mEB = cms.double( 5.0 ), + EEtimeFitLimits_Upper = cms.double( 1.4 ), + prefitMaxChiSqEB = cms.double( 100.0 ), + EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), + prefitMaxChiSqEE = cms.double( 10.0 ), + EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), + EBtimeFitLimits_Upper = cms.double( 1.4 ), + timealgo = cms.string( "RatioMethod" ), + amplitudeThresholdEB = cms.double( 10.0 ), + outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12pEB = cms.double( 5.0 ), + EEtimeNconst = cms.double( 31.8 ), + outOfTimeThresholdGain61mEB = cms.double( 5.0 ), + outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), + EEtimeConstantTerm = cms.double( 1.0 ), + chi2ThreshEE_ = cms.double( 50.0 ), + doPrefitEE = cms.bool( True ), + doPrefitEB = cms.bool( True ) + ) ) hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), diff --git a/HLTrigger/Configuration/test/OnData_HLT_50nsGRun.py b/HLTrigger/Configuration/test/OnData_HLT_50nsGRun.py index c4d6f82188c9e..b0782430f67c1 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_50nsGRun.py +++ b/HLTrigger/Configuration/test/OnData_HLT_50nsGRun.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/50nsGRun/V3 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/50nsGRun/V9 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLT50nsGRun" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V3') + tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V9') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2441,73 +2441,11 @@ ) process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - alphaEB = cms.double( 1.138 ), - alphaEE = cms.double( 1.89 ), EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - AlphaBetaFilename = cms.untracked.string( "NOFILE" ), - betaEB = cms.double( 1.655 ), - MinAmplEndcap = cms.double( 14.0 ), - MinAmplBarrel = cms.double( 8.0 ), - algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), - betaEE = cms.double( 1.4 ), - UseDynamicPedestal = cms.bool( True ), EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( True ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( True ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 25.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( False ), - doPrefitEB = cms.bool( False ) + algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), + algoPSet = cms.PSet( ) ) process.hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), diff --git a/HLTrigger/Configuration/test/OnData_HLT_FULL.py b/HLTrigger/Configuration/test/OnData_HLT_FULL.py index e986dfff31d2f..a30e721da6eaa 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_FULL.py +++ b/HLTrigger/Configuration/test/OnData_HLT_FULL.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/HLT/V2 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/HLT/V6 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTFULL" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V2') + tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V6') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2454,73 +2454,67 @@ ) process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - alphaEB = cms.double( 1.138 ), - alphaEE = cms.double( 1.89 ), EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - AlphaBetaFilename = cms.untracked.string( "NOFILE" ), - betaEB = cms.double( 1.655 ), - MinAmplEndcap = cms.double( 14.0 ), - MinAmplBarrel = cms.double( 8.0 ), - algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), - betaEE = cms.double( 1.4 ), - UseDynamicPedestal = cms.bool( True ), EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( True ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( True ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 25.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( False ), - doPrefitEB = cms.bool( False ) + algo = cms.string( "EcalUncalibRecHitWorkerMultiFit" ), + algoPSet = cms.PSet( + outOfTimeThresholdGain61pEB = cms.double( 5.0 ), + eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EcalPulseShapeParameters = cms.PSet( + EcalPreMixStage2 = cms.bool( False ), + EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), + EcalPreMixStage1 = cms.bool( False ), + EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), + EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), + EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), + EBdigiCollection = cms.string( "" ), + EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), + EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), + ESdigiCollection = cms.string( "" ), + EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), + EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), + EEdigiCollection = cms.string( "" ), + EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), + EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), + UseLCcorrection = cms.untracked.bool( True ) + ), + EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), + activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), + amplitudeThresholdEE = cms.double( 10.0 ), + EBtimeConstantTerm = cms.double( 0.6 ), + EEtimeFitLimits_Lower = cms.double( 0.2 ), + outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), + ebSpikeThreshold = cms.double( 1.042 ), + EBtimeNconst = cms.double( 28.5 ), + ampErrorCalculation = cms.bool( False ), + kPoorRecoFlagEB = cms.bool( True ), + ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EBtimeFitLimits_Lower = cms.double( 0.2 ), + kPoorRecoFlagEE = cms.bool( False ), + chi2ThreshEB_ = cms.double( 65.0 ), + EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), + useLumiInfoRunHeader = cms.bool( False ), + outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12mEB = cms.double( 5.0 ), + EEtimeFitLimits_Upper = cms.double( 1.4 ), + prefitMaxChiSqEB = cms.double( 100.0 ), + EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), + prefitMaxChiSqEE = cms.double( 10.0 ), + EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), + EBtimeFitLimits_Upper = cms.double( 1.4 ), + timealgo = cms.string( "RatioMethod" ), + amplitudeThresholdEB = cms.double( 10.0 ), + outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12pEB = cms.double( 5.0 ), + EEtimeNconst = cms.double( 31.8 ), + outOfTimeThresholdGain61mEB = cms.double( 5.0 ), + outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), + EEtimeConstantTerm = cms.double( 1.0 ), + chi2ThreshEE_ = cms.double( 50.0 ), + doPrefitEE = cms.bool( True ), + doPrefitEB = cms.bool( True ) + ) ) process.hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), diff --git a/HLTrigger/Configuration/test/OnData_HLT_Fake.py b/HLTrigger/Configuration/test/OnData_HLT_Fake.py index b4c28cd5887f3..aebefa45e2d3f 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_Fake.py +++ b/HLTrigger/Configuration/test/OnData_HLT_Fake.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/Fake/V2 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/Fake/V3 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTFake" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/Fake/V2') + tableName = cms.string('/dev/CMSSW_7_4_0/Fake/V3') ) process.streams = cms.PSet( A = cms.vstring( 'InitialPD' ) ) diff --git a/HLTrigger/Configuration/test/OnData_HLT_GRun.py b/HLTrigger/Configuration/test/OnData_HLT_GRun.py index b91d0556234c4..79dea4467e723 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_GRun.py +++ b/HLTrigger/Configuration/test/OnData_HLT_GRun.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/GRun/V1 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/GRun/V4 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTGRun" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V1') + tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V4') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2426,73 +2426,67 @@ ) process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - alphaEB = cms.double( 1.138 ), - alphaEE = cms.double( 1.89 ), EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - AlphaBetaFilename = cms.untracked.string( "NOFILE" ), - betaEB = cms.double( 1.655 ), - MinAmplEndcap = cms.double( 14.0 ), - MinAmplBarrel = cms.double( 8.0 ), - algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), - betaEE = cms.double( 1.4 ), - UseDynamicPedestal = cms.bool( True ), EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( True ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( True ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 25.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( False ), - doPrefitEB = cms.bool( False ) + algo = cms.string( "EcalUncalibRecHitWorkerMultiFit" ), + algoPSet = cms.PSet( + outOfTimeThresholdGain61pEB = cms.double( 5.0 ), + eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EcalPulseShapeParameters = cms.PSet( + EcalPreMixStage2 = cms.bool( False ), + EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), + EcalPreMixStage1 = cms.bool( False ), + EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), + EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), + EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), + EBdigiCollection = cms.string( "" ), + EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), + EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), + ESdigiCollection = cms.string( "" ), + EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), + EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), + EEdigiCollection = cms.string( "" ), + EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), + EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), + UseLCcorrection = cms.untracked.bool( True ) + ), + EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), + activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), + amplitudeThresholdEE = cms.double( 10.0 ), + EBtimeConstantTerm = cms.double( 0.6 ), + EEtimeFitLimits_Lower = cms.double( 0.2 ), + outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), + ebSpikeThreshold = cms.double( 1.042 ), + EBtimeNconst = cms.double( 28.5 ), + ampErrorCalculation = cms.bool( False ), + kPoorRecoFlagEB = cms.bool( True ), + ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EBtimeFitLimits_Lower = cms.double( 0.2 ), + kPoorRecoFlagEE = cms.bool( False ), + chi2ThreshEB_ = cms.double( 65.0 ), + EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), + useLumiInfoRunHeader = cms.bool( False ), + outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12mEB = cms.double( 5.0 ), + EEtimeFitLimits_Upper = cms.double( 1.4 ), + prefitMaxChiSqEB = cms.double( 100.0 ), + EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), + prefitMaxChiSqEE = cms.double( 10.0 ), + EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), + EBtimeFitLimits_Upper = cms.double( 1.4 ), + timealgo = cms.string( "RatioMethod" ), + amplitudeThresholdEB = cms.double( 10.0 ), + outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12pEB = cms.double( 5.0 ), + EEtimeNconst = cms.double( 31.8 ), + outOfTimeThresholdGain61mEB = cms.double( 5.0 ), + outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), + EEtimeConstantTerm = cms.double( 1.0 ), + chi2ThreshEE_ = cms.double( 50.0 ), + doPrefitEE = cms.bool( True ), + doPrefitEB = cms.bool( True ) + ) ) process.hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), diff --git a/HLTrigger/Configuration/test/OnData_HLT_HIon.py b/HLTrigger/Configuration/test/OnData_HLT_HIon.py index a32b5a4ae556f..07380627b58e8 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_HIon.py +++ b/HLTrigger/Configuration/test/OnData_HLT_HIon.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/HIon/V1 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/HIon/V4 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTHIon" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HIon/V1') + tableName = cms.string('/dev/CMSSW_7_4_0/HIon/V4') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2125,73 +2125,67 @@ ) process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - alphaEB = cms.double( 1.138 ), - alphaEE = cms.double( 1.89 ), EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - AlphaBetaFilename = cms.untracked.string( "NOFILE" ), - betaEB = cms.double( 1.655 ), - MinAmplEndcap = cms.double( 14.0 ), - MinAmplBarrel = cms.double( 8.0 ), - algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), - betaEE = cms.double( 1.4 ), - UseDynamicPedestal = cms.bool( True ), EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( True ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( True ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 25.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( False ), - doPrefitEB = cms.bool( False ) + algo = cms.string( "EcalUncalibRecHitWorkerMultiFit" ), + algoPSet = cms.PSet( + outOfTimeThresholdGain61pEB = cms.double( 5.0 ), + eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EcalPulseShapeParameters = cms.PSet( + EcalPreMixStage2 = cms.bool( False ), + EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), + EcalPreMixStage1 = cms.bool( False ), + EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), + EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), + EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), + EBdigiCollection = cms.string( "" ), + EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), + EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), + ESdigiCollection = cms.string( "" ), + EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), + EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), + EEdigiCollection = cms.string( "" ), + EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), + EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), + UseLCcorrection = cms.untracked.bool( True ) + ), + EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), + activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), + amplitudeThresholdEE = cms.double( 10.0 ), + EBtimeConstantTerm = cms.double( 0.6 ), + EEtimeFitLimits_Lower = cms.double( 0.2 ), + outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), + ebSpikeThreshold = cms.double( 1.042 ), + EBtimeNconst = cms.double( 28.5 ), + ampErrorCalculation = cms.bool( False ), + kPoorRecoFlagEB = cms.bool( True ), + ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EBtimeFitLimits_Lower = cms.double( 0.2 ), + kPoorRecoFlagEE = cms.bool( False ), + chi2ThreshEB_ = cms.double( 65.0 ), + EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), + useLumiInfoRunHeader = cms.bool( False ), + outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12mEB = cms.double( 5.0 ), + EEtimeFitLimits_Upper = cms.double( 1.4 ), + prefitMaxChiSqEB = cms.double( 100.0 ), + EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), + prefitMaxChiSqEE = cms.double( 10.0 ), + EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), + EBtimeFitLimits_Upper = cms.double( 1.4 ), + timealgo = cms.string( "RatioMethod" ), + amplitudeThresholdEB = cms.double( 10.0 ), + outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12pEB = cms.double( 5.0 ), + EEtimeNconst = cms.double( 31.8 ), + outOfTimeThresholdGain61mEB = cms.double( 5.0 ), + outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), + EEtimeConstantTerm = cms.double( 1.0 ), + chi2ThreshEE_ = cms.double( 50.0 ), + doPrefitEE = cms.bool( True ), + doPrefitEB = cms.bool( True ) + ) ) process.hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), diff --git a/HLTrigger/Configuration/test/OnData_HLT_PIon.py b/HLTrigger/Configuration/test/OnData_HLT_PIon.py index c94633f2154fc..d315d49edd479 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_PIon.py +++ b/HLTrigger/Configuration/test/OnData_HLT_PIon.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/PIon/V1 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/PIon/V4 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTPIon" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/PIon/V1') + tableName = cms.string('/dev/CMSSW_7_4_0/PIon/V4') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2125,73 +2125,67 @@ ) process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - alphaEB = cms.double( 1.138 ), - alphaEE = cms.double( 1.89 ), EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - AlphaBetaFilename = cms.untracked.string( "NOFILE" ), - betaEB = cms.double( 1.655 ), - MinAmplEndcap = cms.double( 14.0 ), - MinAmplBarrel = cms.double( 8.0 ), - algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), - betaEE = cms.double( 1.4 ), - UseDynamicPedestal = cms.bool( True ), EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( True ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( True ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 25.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( False ), - doPrefitEB = cms.bool( False ) + algo = cms.string( "EcalUncalibRecHitWorkerMultiFit" ), + algoPSet = cms.PSet( + outOfTimeThresholdGain61pEB = cms.double( 5.0 ), + eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EcalPulseShapeParameters = cms.PSet( + EcalPreMixStage2 = cms.bool( False ), + EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), + EcalPreMixStage1 = cms.bool( False ), + EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), + EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), + EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), + EBdigiCollection = cms.string( "" ), + EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), + EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), + ESdigiCollection = cms.string( "" ), + EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), + EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), + EEdigiCollection = cms.string( "" ), + EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), + EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), + UseLCcorrection = cms.untracked.bool( True ) + ), + EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), + activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), + amplitudeThresholdEE = cms.double( 10.0 ), + EBtimeConstantTerm = cms.double( 0.6 ), + EEtimeFitLimits_Lower = cms.double( 0.2 ), + outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), + ebSpikeThreshold = cms.double( 1.042 ), + EBtimeNconst = cms.double( 28.5 ), + ampErrorCalculation = cms.bool( False ), + kPoorRecoFlagEB = cms.bool( True ), + ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EBtimeFitLimits_Lower = cms.double( 0.2 ), + kPoorRecoFlagEE = cms.bool( False ), + chi2ThreshEB_ = cms.double( 65.0 ), + EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), + useLumiInfoRunHeader = cms.bool( False ), + outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12mEB = cms.double( 5.0 ), + EEtimeFitLimits_Upper = cms.double( 1.4 ), + prefitMaxChiSqEB = cms.double( 100.0 ), + EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), + prefitMaxChiSqEE = cms.double( 10.0 ), + EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), + EBtimeFitLimits_Upper = cms.double( 1.4 ), + timealgo = cms.string( "RatioMethod" ), + amplitudeThresholdEB = cms.double( 10.0 ), + outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12pEB = cms.double( 5.0 ), + EEtimeNconst = cms.double( 31.8 ), + outOfTimeThresholdGain61mEB = cms.double( 5.0 ), + outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), + EEtimeConstantTerm = cms.double( 1.0 ), + chi2ThreshEE_ = cms.double( 50.0 ), + doPrefitEE = cms.bool( True ), + doPrefitEB = cms.bool( True ) + ) ) process.hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), diff --git a/HLTrigger/Configuration/test/OnMc_HLT_50nsGRun.py b/HLTrigger/Configuration/test/OnMc_HLT_50nsGRun.py index a41dd25a56b64..f49efd5b4936f 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_50nsGRun.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_50nsGRun.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/50nsGRun/V3 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/50nsGRun/V9 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLT50nsGRun" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V3') + tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V9') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2441,73 +2441,11 @@ ) process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - alphaEB = cms.double( 1.138 ), - alphaEE = cms.double( 1.89 ), EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - AlphaBetaFilename = cms.untracked.string( "NOFILE" ), - betaEB = cms.double( 1.655 ), - MinAmplEndcap = cms.double( 14.0 ), - MinAmplBarrel = cms.double( 8.0 ), - algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), - betaEE = cms.double( 1.4 ), - UseDynamicPedestal = cms.bool( True ), EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( True ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( True ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 25.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( False ), - doPrefitEB = cms.bool( False ) + algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), + algoPSet = cms.PSet( ) ) process.hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), diff --git a/HLTrigger/Configuration/test/OnMc_HLT_FULL.py b/HLTrigger/Configuration/test/OnMc_HLT_FULL.py index e4dd68844ab6e..3d9001490d322 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_FULL.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_FULL.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/HLT/V2 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/HLT/V6 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTFULL" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V2') + tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V6') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2454,73 +2454,67 @@ ) process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - alphaEB = cms.double( 1.138 ), - alphaEE = cms.double( 1.89 ), EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - AlphaBetaFilename = cms.untracked.string( "NOFILE" ), - betaEB = cms.double( 1.655 ), - MinAmplEndcap = cms.double( 14.0 ), - MinAmplBarrel = cms.double( 8.0 ), - algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), - betaEE = cms.double( 1.4 ), - UseDynamicPedestal = cms.bool( True ), EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( True ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( True ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 25.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( False ), - doPrefitEB = cms.bool( False ) + algo = cms.string( "EcalUncalibRecHitWorkerMultiFit" ), + algoPSet = cms.PSet( + outOfTimeThresholdGain61pEB = cms.double( 5.0 ), + eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EcalPulseShapeParameters = cms.PSet( + EcalPreMixStage2 = cms.bool( False ), + EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), + EcalPreMixStage1 = cms.bool( False ), + EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), + EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), + EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), + EBdigiCollection = cms.string( "" ), + EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), + EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), + ESdigiCollection = cms.string( "" ), + EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), + EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), + EEdigiCollection = cms.string( "" ), + EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), + EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), + UseLCcorrection = cms.untracked.bool( True ) + ), + EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), + activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), + amplitudeThresholdEE = cms.double( 10.0 ), + EBtimeConstantTerm = cms.double( 0.6 ), + EEtimeFitLimits_Lower = cms.double( 0.2 ), + outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), + ebSpikeThreshold = cms.double( 1.042 ), + EBtimeNconst = cms.double( 28.5 ), + ampErrorCalculation = cms.bool( False ), + kPoorRecoFlagEB = cms.bool( True ), + ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EBtimeFitLimits_Lower = cms.double( 0.2 ), + kPoorRecoFlagEE = cms.bool( False ), + chi2ThreshEB_ = cms.double( 65.0 ), + EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), + useLumiInfoRunHeader = cms.bool( False ), + outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12mEB = cms.double( 5.0 ), + EEtimeFitLimits_Upper = cms.double( 1.4 ), + prefitMaxChiSqEB = cms.double( 100.0 ), + EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), + prefitMaxChiSqEE = cms.double( 10.0 ), + EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), + EBtimeFitLimits_Upper = cms.double( 1.4 ), + timealgo = cms.string( "RatioMethod" ), + amplitudeThresholdEB = cms.double( 10.0 ), + outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12pEB = cms.double( 5.0 ), + EEtimeNconst = cms.double( 31.8 ), + outOfTimeThresholdGain61mEB = cms.double( 5.0 ), + outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), + EEtimeConstantTerm = cms.double( 1.0 ), + chi2ThreshEE_ = cms.double( 50.0 ), + doPrefitEE = cms.bool( True ), + doPrefitEB = cms.bool( True ) + ) ) process.hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), diff --git a/HLTrigger/Configuration/test/OnMc_HLT_Fake.py b/HLTrigger/Configuration/test/OnMc_HLT_Fake.py index e867170a69aae..eeeec6770c9bc 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_Fake.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_Fake.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/Fake/V2 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/Fake/V3 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTFake" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/Fake/V2') + tableName = cms.string('/dev/CMSSW_7_4_0/Fake/V3') ) process.streams = cms.PSet( A = cms.vstring( 'InitialPD' ) ) diff --git a/HLTrigger/Configuration/test/OnMc_HLT_GRun.py b/HLTrigger/Configuration/test/OnMc_HLT_GRun.py index f5724d9309f52..3dc3cebffe914 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_GRun.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_GRun.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/GRun/V1 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/GRun/V4 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTGRun" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V1') + tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V4') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2426,73 +2426,67 @@ ) process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - alphaEB = cms.double( 1.138 ), - alphaEE = cms.double( 1.89 ), EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - AlphaBetaFilename = cms.untracked.string( "NOFILE" ), - betaEB = cms.double( 1.655 ), - MinAmplEndcap = cms.double( 14.0 ), - MinAmplBarrel = cms.double( 8.0 ), - algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), - betaEE = cms.double( 1.4 ), - UseDynamicPedestal = cms.bool( True ), EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( True ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( True ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 25.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( False ), - doPrefitEB = cms.bool( False ) + algo = cms.string( "EcalUncalibRecHitWorkerMultiFit" ), + algoPSet = cms.PSet( + outOfTimeThresholdGain61pEB = cms.double( 5.0 ), + eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EcalPulseShapeParameters = cms.PSet( + EcalPreMixStage2 = cms.bool( False ), + EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), + EcalPreMixStage1 = cms.bool( False ), + EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), + EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), + EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), + EBdigiCollection = cms.string( "" ), + EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), + EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), + ESdigiCollection = cms.string( "" ), + EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), + EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), + EEdigiCollection = cms.string( "" ), + EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), + EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), + UseLCcorrection = cms.untracked.bool( True ) + ), + EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), + activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), + amplitudeThresholdEE = cms.double( 10.0 ), + EBtimeConstantTerm = cms.double( 0.6 ), + EEtimeFitLimits_Lower = cms.double( 0.2 ), + outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), + ebSpikeThreshold = cms.double( 1.042 ), + EBtimeNconst = cms.double( 28.5 ), + ampErrorCalculation = cms.bool( False ), + kPoorRecoFlagEB = cms.bool( True ), + ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EBtimeFitLimits_Lower = cms.double( 0.2 ), + kPoorRecoFlagEE = cms.bool( False ), + chi2ThreshEB_ = cms.double( 65.0 ), + EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), + useLumiInfoRunHeader = cms.bool( False ), + outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12mEB = cms.double( 5.0 ), + EEtimeFitLimits_Upper = cms.double( 1.4 ), + prefitMaxChiSqEB = cms.double( 100.0 ), + EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), + prefitMaxChiSqEE = cms.double( 10.0 ), + EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), + EBtimeFitLimits_Upper = cms.double( 1.4 ), + timealgo = cms.string( "RatioMethod" ), + amplitudeThresholdEB = cms.double( 10.0 ), + outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12pEB = cms.double( 5.0 ), + EEtimeNconst = cms.double( 31.8 ), + outOfTimeThresholdGain61mEB = cms.double( 5.0 ), + outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), + EEtimeConstantTerm = cms.double( 1.0 ), + chi2ThreshEE_ = cms.double( 50.0 ), + doPrefitEE = cms.bool( True ), + doPrefitEB = cms.bool( True ) + ) ) process.hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), diff --git a/HLTrigger/Configuration/test/OnMc_HLT_HIon.py b/HLTrigger/Configuration/test/OnMc_HLT_HIon.py index e7efaac5b2eda..4b01164a3b845 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_HIon.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_HIon.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/HIon/V1 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/HIon/V4 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTHIon" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HIon/V1') + tableName = cms.string('/dev/CMSSW_7_4_0/HIon/V4') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2125,73 +2125,67 @@ ) process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - alphaEB = cms.double( 1.138 ), - alphaEE = cms.double( 1.89 ), EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - AlphaBetaFilename = cms.untracked.string( "NOFILE" ), - betaEB = cms.double( 1.655 ), - MinAmplEndcap = cms.double( 14.0 ), - MinAmplBarrel = cms.double( 8.0 ), - algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), - betaEE = cms.double( 1.4 ), - UseDynamicPedestal = cms.bool( True ), EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( True ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( True ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 25.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( False ), - doPrefitEB = cms.bool( False ) + algo = cms.string( "EcalUncalibRecHitWorkerMultiFit" ), + algoPSet = cms.PSet( + outOfTimeThresholdGain61pEB = cms.double( 5.0 ), + eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EcalPulseShapeParameters = cms.PSet( + EcalPreMixStage2 = cms.bool( False ), + EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), + EcalPreMixStage1 = cms.bool( False ), + EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), + EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), + EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), + EBdigiCollection = cms.string( "" ), + EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), + EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), + ESdigiCollection = cms.string( "" ), + EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), + EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), + EEdigiCollection = cms.string( "" ), + EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), + EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), + UseLCcorrection = cms.untracked.bool( True ) + ), + EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), + activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), + amplitudeThresholdEE = cms.double( 10.0 ), + EBtimeConstantTerm = cms.double( 0.6 ), + EEtimeFitLimits_Lower = cms.double( 0.2 ), + outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), + ebSpikeThreshold = cms.double( 1.042 ), + EBtimeNconst = cms.double( 28.5 ), + ampErrorCalculation = cms.bool( False ), + kPoorRecoFlagEB = cms.bool( True ), + ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EBtimeFitLimits_Lower = cms.double( 0.2 ), + kPoorRecoFlagEE = cms.bool( False ), + chi2ThreshEB_ = cms.double( 65.0 ), + EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), + useLumiInfoRunHeader = cms.bool( False ), + outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12mEB = cms.double( 5.0 ), + EEtimeFitLimits_Upper = cms.double( 1.4 ), + prefitMaxChiSqEB = cms.double( 100.0 ), + EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), + prefitMaxChiSqEE = cms.double( 10.0 ), + EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), + EBtimeFitLimits_Upper = cms.double( 1.4 ), + timealgo = cms.string( "RatioMethod" ), + amplitudeThresholdEB = cms.double( 10.0 ), + outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12pEB = cms.double( 5.0 ), + EEtimeNconst = cms.double( 31.8 ), + outOfTimeThresholdGain61mEB = cms.double( 5.0 ), + outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), + EEtimeConstantTerm = cms.double( 1.0 ), + chi2ThreshEE_ = cms.double( 50.0 ), + doPrefitEE = cms.bool( True ), + doPrefitEB = cms.bool( True ) + ) ) process.hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), diff --git a/HLTrigger/Configuration/test/OnMc_HLT_PIon.py b/HLTrigger/Configuration/test/OnMc_HLT_PIon.py index 717a300cf81f6..7395501f19780 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_PIon.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_PIon.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/PIon/V1 (CMSSW_7_4_0_pre7) +# /dev/CMSSW_7_4_0/PIon/V4 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTPIon" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/PIon/V1') + tableName = cms.string('/dev/CMSSW_7_4_0/PIon/V4') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2125,73 +2125,67 @@ ) process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - alphaEB = cms.double( 1.138 ), - alphaEE = cms.double( 1.89 ), EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - AlphaBetaFilename = cms.untracked.string( "NOFILE" ), - betaEB = cms.double( 1.655 ), - MinAmplEndcap = cms.double( 14.0 ), - MinAmplBarrel = cms.double( 8.0 ), - algo = cms.string( "EcalUncalibRecHitWorkerWeights" ), - betaEE = cms.double( 1.4 ), - UseDynamicPedestal = cms.bool( True ), EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( True ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( True ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 25.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( False ), - doPrefitEB = cms.bool( False ) + algo = cms.string( "EcalUncalibRecHitWorkerMultiFit" ), + algoPSet = cms.PSet( + outOfTimeThresholdGain61pEB = cms.double( 5.0 ), + eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EcalPulseShapeParameters = cms.PSet( + EcalPreMixStage2 = cms.bool( False ), + EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), + EcalPreMixStage1 = cms.bool( False ), + EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), + EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), + EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), + EBdigiCollection = cms.string( "" ), + EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), + EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), + ESdigiCollection = cms.string( "" ), + EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), + EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), + EEdigiCollection = cms.string( "" ), + EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), + EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), + UseLCcorrection = cms.untracked.bool( True ) + ), + EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), + activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), + amplitudeThresholdEE = cms.double( 10.0 ), + EBtimeConstantTerm = cms.double( 0.6 ), + EEtimeFitLimits_Lower = cms.double( 0.2 ), + outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), + ebSpikeThreshold = cms.double( 1.042 ), + EBtimeNconst = cms.double( 28.5 ), + ampErrorCalculation = cms.bool( False ), + kPoorRecoFlagEB = cms.bool( True ), + ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), + EBtimeFitLimits_Lower = cms.double( 0.2 ), + kPoorRecoFlagEE = cms.bool( False ), + chi2ThreshEB_ = cms.double( 65.0 ), + EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), + useLumiInfoRunHeader = cms.bool( False ), + outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12mEB = cms.double( 5.0 ), + EEtimeFitLimits_Upper = cms.double( 1.4 ), + prefitMaxChiSqEB = cms.double( 100.0 ), + EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), + prefitMaxChiSqEE = cms.double( 10.0 ), + EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), + EBtimeFitLimits_Upper = cms.double( 1.4 ), + timealgo = cms.string( "RatioMethod" ), + amplitudeThresholdEB = cms.double( 10.0 ), + outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), + outOfTimeThresholdGain12pEB = cms.double( 5.0 ), + EEtimeNconst = cms.double( 31.8 ), + outOfTimeThresholdGain61mEB = cms.double( 5.0 ), + outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), + EEtimeConstantTerm = cms.double( 1.0 ), + chi2ThreshEE_ = cms.double( 50.0 ), + doPrefitEE = cms.bool( True ), + doPrefitEB = cms.bool( True ) + ) ) process.hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), From 4e4470eb36570ccdaf47f9bda97d266d824ab079 Mon Sep 17 00:00:00 2001 From: Andrea Date: Thu, 26 Feb 2015 14:57:10 +0100 Subject: [PATCH 13/22] Muon HLT paths for the HIon menu, CMSHLT-198 --- .../python/HLT_50nsGRun_Famos_cff.py | 40 +- .../Configuration/python/HLT_50nsGRun_cff.py | 40 +- .../python/HLT_FULL_Famos_cff.py | 1248 ++- .../Configuration/python/HLT_FULL_cff.py | 1262 ++- .../python/HLT_GRun_Famos_cff.py | 20 +- .../Configuration/python/HLT_GRun_cff.py | 20 +- .../Configuration/python/HLT_HIon_cff.py | 7823 ++++------------ .../Configuration/python/HLT_PIon_cff.py | 4 +- .../python/HLTrigger_Datasets_HIon_cff.py | 28 +- HLTrigger/Configuration/tables/HIon.txt | 21 +- .../Configuration/test/OnData_HLT_50nsGRun.py | 40 +- .../Configuration/test/OnData_HLT_FULL.py | 1279 ++- .../Configuration/test/OnData_HLT_GRun.py | 20 +- .../Configuration/test/OnData_HLT_HIon.py | 7839 ++++------------- .../Configuration/test/OnData_HLT_PIon.py | 4 +- .../Configuration/test/OnMc_HLT_50nsGRun.py | 40 +- HLTrigger/Configuration/test/OnMc_HLT_FULL.py | 1279 ++- HLTrigger/Configuration/test/OnMc_HLT_GRun.py | 20 +- HLTrigger/Configuration/test/OnMc_HLT_HIon.py | 7839 ++++------------- HLTrigger/Configuration/test/OnMc_HLT_PIon.py | 4 +- .../Configuration/test/runIntegration.csh | 2 +- HLTrigger/Configuration/test/runOne.csh | 2 +- L1Trigger/L1TCommon/python/customsPostLS1.py | 3 +- 23 files changed, 10042 insertions(+), 18835 deletions(-) diff --git a/HLTrigger/Configuration/python/HLT_50nsGRun_Famos_cff.py b/HLTrigger/Configuration/python/HLT_50nsGRun_Famos_cff.py index 72513013c06b6..3c0253d9c3fad 100644 --- a/HLTrigger/Configuration/python/HLT_50nsGRun_Famos_cff.py +++ b/HLTrigger/Configuration/python/HLT_50nsGRun_Famos_cff.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/50nsGRun/V9 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/50nsGRun/V11 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms from FastSimulation.HighLevelTrigger.HLTSetup_cff import * HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V9') + tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V11') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -158,7 +158,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), MeasurementTrackerName = cms.string( "hltIter4ESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator16" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator16" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -173,7 +173,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), MeasurementTrackerName = cms.string( "hltIter3ESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator16" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator16" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -187,7 +187,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), MeasurementTrackerName = cms.string( "hltIter2ESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator16" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator16" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -201,7 +201,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), MeasurementTrackerName = cms.string( "hltIter1ESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator16" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator16" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -229,7 +229,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialOpposite" ), MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -259,7 +259,7 @@ useSeedLayer = cms.bool( True ), deltaEta = cms.double( -1.0 ), deltaPhi = cms.double( -1.0 ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), rescaleErrorIfFail = cms.double( 1.0 ), propagatorProximity = cms.string( "SteppingHelixPropagatorAny" ), updator = cms.string( "hltESPKFUpdator" ), @@ -278,7 +278,7 @@ useSeedLayer = cms.bool( False ), deltaEta = cms.double( -1.0 ), deltaPhi = cms.double( -1.0 ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), rescaleErrorIfFail = cms.double( 1.0 ), propagatorProximity = cms.string( "SteppingHelixPropagatorAny" ), updator = cms.string( "hltESPKFUpdator" ), @@ -300,7 +300,7 @@ maxCand = cms.int32( 2 ), ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator9" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator9" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -343,7 +343,7 @@ maxCand = cms.int32( 4 ), ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( True ), @@ -356,7 +356,7 @@ maxCand = cms.int32( 2 ), ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -8569,8 +8569,8 @@ reqOppCharge = cms.untracked.bool( False ), nZcandcut = cms.int32( 1 ) ) -hltL1sL1SingleIsoEG18 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG18" ), +hltL1sL1SingleIsoEG20er = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG20er" ), saveTags = cms.bool( True ), L1MuonCollectionTag = cms.InputTag( "l1extraParticles" ), L1UseL1TriggerObjectMaps = cms.bool( True ), @@ -8585,7 +8585,7 @@ L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), offset = cms.uint32( 0 ) ) -hltEGL1SingleIsoEG18erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", +hltEGL1SingleIsoEG20erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", doIsolated = cms.bool( False ), endcap_end = cms.double( 2.17 ), saveTags = cms.bool( False ), @@ -8595,7 +8595,7 @@ candIsolatedTag = cms.InputTag( "hltEgammaCandidates" ), region_phi_size = cms.double( 1.044 ), region_eta_size = cms.double( 0.522 ), - L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG18" ), + L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG20er" ), candNonIsolatedTag = cms.InputTag( "" ), l1NonIsolatedTag = cms.InputTag( 'l1extraParticles','NonIsolated' ), ncandcut = cms.int32( 1 ) @@ -8605,7 +8605,7 @@ L1NonIsoCand = cms.InputTag( "" ), relaxed = cms.untracked.bool( False ), L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - inputTag = cms.InputTag( "hltEGL1SingleIsoEG18erFilter" ), + inputTag = cms.InputTag( "hltEGL1SingleIsoEG20erFilter" ), etcutEB = cms.double( 22.0 ), etcutEE = cms.double( 22.0 ), ncandcut = cms.int32( 1 ) @@ -28208,7 +28208,7 @@ tanhSO10ForwardThres = cms.double( 1.0 ), L1IsoPixelSeedsTag = cms.InputTag( "hltEgammaElectronPixelSeedsUnseeded" ), L1NonIsoCand = cms.InputTag( "" ), - ncandcut = cms.int32( 1 ), + ncandcut = cms.int32( 2 ), tanhSO10BarrelThres = cms.double( 0.35 ), s_a_rF = cms.double( 0.04 ), L1NonIsoPixelSeedsTag = cms.InputTag( "" ), @@ -31469,7 +31469,7 @@ HLTTrackReconstructionIter02 = cms.Sequence( HLTPixelTrackingL3Muon + HLTDoLocalStripSequence + HLTIterativeTrackingL3MuonIter02 ) HLTDoublePho85Sequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleEG40ORL1SingleEG35Filter + hltEG85EtFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEG85HEFilter + HLTPFClusteringForEgammaUnseeded + hltEgammaCandidatesUnseeded + hltEgammaCandidatesWrapperUnseeded + hltDiEG85EtUnseededFilter + hltEgammaHoverEUnseeded + hltDiEG85HEUnseededFilter ) HLTEle20WP60Ele8Mass55Sequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleEG20Filter + hltEle20WP60Ele8EtFilter + hltEgammaClusterShape + hltEle20WP60Ele8ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEle20WP60Ele8HEFilter + hltEgammaEcalPFClusterIso + hltEle20WP60Ele8EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltEle20WP60Ele8HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltEle20WP60Ele8PixelMatchFilter + HLTGsfElectronSequence + hltEle20WP60Ele8OneOEMinusOneOPFilter + hltEle20WP60Ele8DetaFilter + hltEle20WP60Ele8DphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltEle20WP60Ele8TrackIsoFilter + HLTPFClusteringForEgammaUnseeded + hltEgammaCandidatesUnseeded + hltEgammaCandidatesWrapperUnseeded + hltEle20WP60Ele8EtUnseededFilter + HLTElePixelMatchUnseededSequence + hltEle20WP60Ele8PixelMatchUnseededFilter + hltEle20WP60Ele8Mass55Filter ) -HLTSingleEle22erWP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleIsoEG18erFilter + hltSingleEG22EtFilter + hltEgammaClusterShape + hltSingleEle22WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltSingleEle22WP75HcEFilter + hltEgammaEcalPFClusterIso + hltSingleEle22WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltSingleEle22WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltSingleEle22WP75PixelMatchFilter + HLTGsfElectronSequence + hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + hltSingleEle22WP75GsfChi2Filter + hltSingleEle22WP75GsfDetaFilter + hltSingleEle22WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltSingleEle22WP75GsfTrackIsoFilter ) +HLTSingleEle22erWP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleIsoEG20erFilter + hltSingleEG22EtFilter + hltEgammaClusterShape + hltSingleEle22WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltSingleEle22WP75HcEFilter + hltEgammaEcalPFClusterIso + hltSingleEle22WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltSingleEle22WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltSingleEle22WP75PixelMatchFilter + HLTGsfElectronSequence + hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + hltSingleEle22WP75GsfChi2Filter + hltSingleEle22WP75GsfDetaFilter + hltSingleEle22WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltSingleEle22WP75GsfTrackIsoFilter ) HLTEle22WP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGRegionalL1IsoEG20erTauJet20er + hltEG22L1sIsoEG20erTauJet20erEtFilter + hltEgammaClusterShape + hltEle22WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEle22WP75HcEFilter + hltEgammaEcalPFClusterIso + hltEle22WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltEle22WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltEle22WP75PixelMatchFilter + HLTGsfElectronSequence + hltEle22WP75GsfOneOESuperMinusOneOPFilter + hltEle22WP75GsfChi2Filter + hltEle22WP75GsfDetaFilter + hltEle22WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltEle22WP75GsfTrackIsoFilter ) HLTParticleFlowSequenceForTaus = cms.Sequence( HLTPreshowerSequence + hltParticleFlowRecHitECALUnseeded + hltParticleFlowRecHitHCAL + hltParticleFlowRecHitPSUnseeded + hltParticleFlowClusterECALUncorrectedUnseeded + hltParticleFlowClusterPSUnseeded + hltParticleFlowClusterECALUnseeded + hltParticleFlowClusterHCAL + hltParticleFlowClusterHFEM + hltParticleFlowClusterHFHAD + hltLightPFTracks + hltParticleFlowBlockForTaus + hltParticleFlowForTaus ) HLTPFTriggerSequenceForTaus = cms.Sequence( HLTL2muonrecoSequence + HLTL3muonrecoSequence + HLTTrackReconstructionForPF + HLTParticleFlowSequenceForTaus + hltAK4PFJetsForTaus ) @@ -31650,7 +31650,7 @@ HLT_Dimuon6_Jpsi_NoVertexing_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMu0 + hltPreDimuon6JpsiNoVertexing + hltL1fL1DoubleMu0L1Filtered0 + HLTL2muonrecoSequence + hltL2fDoubleMu2L2PreFiltered2 + HLTL3muonrecoSequence + hltDimuon6JpsiL3Filtered + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_DoublePhoton85_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG40ORL1SingleEG35 + hltPreDoublePhoton85 + HLTDoublePho85Sequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_Ele20WP60_Ele8_Mass55_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG20 + hltPreEle20WP60Ele8Mass55 + HLTEle20WP60Ele8Mass55Sequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) -HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleIsoEG18 + hltPreEle22eta2p1WP75Gsf + HLTSingleEle22erWP75GsfSequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) +HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleIsoEG20er + hltPreEle22eta2p1WP75Gsf + HLTSingleEle22erWP75GsfSequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_Ele22_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1 = cms.Path( HLTBeginSequence + hltL1sL1IsoEG20erTauJet20er + hltPreEle22eta2p1WP75GsfLooseIsoPFTau20 + HLTEle22WP75GsfSequence + HLTRecoJetSequenceAK4PrePF + hltTauJet5 + hltOverlapFilterIsoEle22WP75GsfCaloJet5 + HLTPFTriggerSequenceForTaus + HLTIsoEle22WP75GsfLooseIsoPFTau20Sequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_Ele25WP60_SC4_Mass55_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG20 + hltPreEle25WP60SC4Mass55 + HLTEle25WP60SC4Mass55Sequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_Ele25_eta2p1_WP85_Gsf_PFMET80_boostedW_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG40ORL1SingleIsoEG30erORL1ETM70 + hltPreEle25eta2p1WP85GsfPFMET80boostedW + HLTEle25WP85GsfSequence + HLTAK4PFJetsSequence + hltPFMETProducer + hltPFMET80Filter + cms.SequencePlaceholder( "HLTEndSequence" ) ) diff --git a/HLTrigger/Configuration/python/HLT_50nsGRun_cff.py b/HLTrigger/Configuration/python/HLT_50nsGRun_cff.py index 2ea4e6460cca2..21028d25eee03 100644 --- a/HLTrigger/Configuration/python/HLT_50nsGRun_cff.py +++ b/HLTrigger/Configuration/python/HLT_50nsGRun_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_4_0/50nsGRun/V9 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/50nsGRun/V11 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V9') + tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V11') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -157,7 +157,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), MeasurementTrackerName = cms.string( "hltIter4ESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator16" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator16" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -172,7 +172,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), MeasurementTrackerName = cms.string( "hltIter3ESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator16" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator16" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -186,7 +186,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), MeasurementTrackerName = cms.string( "hltIter2ESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator16" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator16" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -200,7 +200,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), MeasurementTrackerName = cms.string( "hltIter1ESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator16" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator16" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -228,7 +228,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialOpposite" ), MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -258,7 +258,7 @@ useSeedLayer = cms.bool( True ), deltaEta = cms.double( -1.0 ), deltaPhi = cms.double( -1.0 ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), rescaleErrorIfFail = cms.double( 1.0 ), propagatorProximity = cms.string( "SteppingHelixPropagatorAny" ), updator = cms.string( "hltESPKFUpdator" ), @@ -277,7 +277,7 @@ useSeedLayer = cms.bool( False ), deltaEta = cms.double( -1.0 ), deltaPhi = cms.double( -1.0 ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), rescaleErrorIfFail = cms.double( 1.0 ), propagatorProximity = cms.string( "SteppingHelixPropagatorAny" ), updator = cms.string( "hltESPKFUpdator" ), @@ -299,7 +299,7 @@ maxCand = cms.int32( 2 ), ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator9" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator9" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -342,7 +342,7 @@ maxCand = cms.int32( 4 ), ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( True ), @@ -355,7 +355,7 @@ maxCand = cms.int32( 2 ), ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -15505,8 +15505,8 @@ reqOppCharge = cms.untracked.bool( False ), nZcandcut = cms.int32( 1 ) ) -hltL1sL1SingleIsoEG18 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG18" ), +hltL1sL1SingleIsoEG20er = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG20er" ), saveTags = cms.bool( True ), L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), L1UseL1TriggerObjectMaps = cms.bool( True ), @@ -15521,7 +15521,7 @@ L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) -hltEGL1SingleIsoEG18erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", +hltEGL1SingleIsoEG20erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", doIsolated = cms.bool( False ), endcap_end = cms.double( 2.17 ), saveTags = cms.bool( False ), @@ -15531,7 +15531,7 @@ candIsolatedTag = cms.InputTag( "hltEgammaCandidates" ), region_phi_size = cms.double( 1.044 ), region_eta_size = cms.double( 0.522 ), - L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG18" ), + L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG20er" ), candNonIsolatedTag = cms.InputTag( "" ), l1NonIsolatedTag = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), ncandcut = cms.int32( 1 ) @@ -15541,7 +15541,7 @@ L1NonIsoCand = cms.InputTag( "" ), relaxed = cms.untracked.bool( False ), L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - inputTag = cms.InputTag( "hltEGL1SingleIsoEG18erFilter" ), + inputTag = cms.InputTag( "hltEGL1SingleIsoEG20erFilter" ), etcutEB = cms.double( 22.0 ), etcutEE = cms.double( 22.0 ), ncandcut = cms.int32( 1 ) @@ -39164,7 +39164,7 @@ tanhSO10ForwardThres = cms.double( 1.0 ), L1IsoPixelSeedsTag = cms.InputTag( "hltEgammaElectronPixelSeedsUnseeded" ), L1NonIsoCand = cms.InputTag( "" ), - ncandcut = cms.int32( 1 ), + ncandcut = cms.int32( 2 ), tanhSO10BarrelThres = cms.double( 0.35 ), s_a_rF = cms.double( 0.04 ), L1NonIsoPixelSeedsTag = cms.InputTag( "" ), @@ -43388,7 +43388,7 @@ HLTTrackReconstructionIter02 = cms.Sequence( HLTPixelTrackingL3Muon + HLTDoLocalStripSequence + HLTIterativeTrackingL3MuonIter02 ) HLTDoublePho85Sequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleEG40ORL1SingleEG35Filter + hltEG85EtFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEG85HEFilter + HLTPFClusteringForEgammaUnseeded + hltEgammaCandidatesUnseeded + hltEgammaCandidatesWrapperUnseeded + hltDiEG85EtUnseededFilter + hltEgammaHoverEUnseeded + hltDiEG85HEUnseededFilter ) HLTEle20WP60Ele8Mass55Sequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleEG20Filter + hltEle20WP60Ele8EtFilter + hltEgammaClusterShape + hltEle20WP60Ele8ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEle20WP60Ele8HEFilter + hltEgammaEcalPFClusterIso + hltEle20WP60Ele8EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltEle20WP60Ele8HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltEle20WP60Ele8PixelMatchFilter + HLTGsfElectronSequence + hltEle20WP60Ele8OneOEMinusOneOPFilter + hltEle20WP60Ele8DetaFilter + hltEle20WP60Ele8DphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltEle20WP60Ele8TrackIsoFilter + HLTPFClusteringForEgammaUnseeded + hltEgammaCandidatesUnseeded + hltEgammaCandidatesWrapperUnseeded + hltEle20WP60Ele8EtUnseededFilter + HLTElePixelMatchUnseededSequence + hltEle20WP60Ele8PixelMatchUnseededFilter + hltEle20WP60Ele8Mass55Filter ) -HLTSingleEle22erWP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleIsoEG18erFilter + hltSingleEG22EtFilter + hltEgammaClusterShape + hltSingleEle22WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltSingleEle22WP75HcEFilter + hltEgammaEcalPFClusterIso + hltSingleEle22WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltSingleEle22WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltSingleEle22WP75PixelMatchFilter + HLTGsfElectronSequence + hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + hltSingleEle22WP75GsfChi2Filter + hltSingleEle22WP75GsfDetaFilter + hltSingleEle22WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltSingleEle22WP75GsfTrackIsoFilter ) +HLTSingleEle22erWP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleIsoEG20erFilter + hltSingleEG22EtFilter + hltEgammaClusterShape + hltSingleEle22WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltSingleEle22WP75HcEFilter + hltEgammaEcalPFClusterIso + hltSingleEle22WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltSingleEle22WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltSingleEle22WP75PixelMatchFilter + HLTGsfElectronSequence + hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + hltSingleEle22WP75GsfChi2Filter + hltSingleEle22WP75GsfDetaFilter + hltSingleEle22WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltSingleEle22WP75GsfTrackIsoFilter ) HLTEle22WP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGRegionalL1IsoEG20erTauJet20er + hltEG22L1sIsoEG20erTauJet20erEtFilter + hltEgammaClusterShape + hltEle22WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEle22WP75HcEFilter + hltEgammaEcalPFClusterIso + hltEle22WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltEle22WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltEle22WP75PixelMatchFilter + HLTGsfElectronSequence + hltEle22WP75GsfOneOESuperMinusOneOPFilter + hltEle22WP75GsfChi2Filter + hltEle22WP75GsfDetaFilter + hltEle22WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltEle22WP75GsfTrackIsoFilter ) HLTParticleFlowSequenceForTaus = cms.Sequence( HLTPreshowerSequence + hltParticleFlowRecHitECALUnseeded + hltParticleFlowRecHitHCAL + hltParticleFlowRecHitPSUnseeded + hltParticleFlowClusterECALUncorrectedUnseeded + hltParticleFlowClusterPSUnseeded + hltParticleFlowClusterECALUnseeded + hltParticleFlowClusterHCAL + hltParticleFlowClusterHFEM + hltParticleFlowClusterHFHAD + hltLightPFTracks + hltParticleFlowBlockForTaus + hltParticleFlowForTaus ) HLTPFTriggerSequenceForTaus = cms.Sequence( HLTL2muonrecoSequence + HLTL3muonrecoSequence + HLTTrackReconstructionForPF + HLTParticleFlowSequenceForTaus + hltAK4PFJetsForTaus ) @@ -43617,7 +43617,7 @@ HLT_Dimuon6_Jpsi_NoVertexing_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMu0 + hltPreDimuon6JpsiNoVertexing + hltL1fL1DoubleMu0L1Filtered0 + HLTL2muonrecoSequence + hltL2fDoubleMu2L2PreFiltered2 + HLTL3muonrecoSequence + hltDimuon6JpsiL3Filtered + HLTEndSequence ) HLT_DoublePhoton85_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG40ORL1SingleEG35 + hltPreDoublePhoton85 + HLTDoublePho85Sequence + HLTEndSequence ) HLT_Ele20WP60_Ele8_Mass55_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG20 + hltPreEle20WP60Ele8Mass55 + HLTEle20WP60Ele8Mass55Sequence + HLTEndSequence ) -HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleIsoEG18 + hltPreEle22eta2p1WP75Gsf + HLTSingleEle22erWP75GsfSequence + HLTEndSequence ) +HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleIsoEG20er + hltPreEle22eta2p1WP75Gsf + HLTSingleEle22erWP75GsfSequence + HLTEndSequence ) HLT_Ele22_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1 = cms.Path( HLTBeginSequence + hltL1sL1IsoEG20erTauJet20er + hltPreEle22eta2p1WP75GsfLooseIsoPFTau20 + HLTEle22WP75GsfSequence + HLTRecoJetSequenceAK4PrePF + hltTauJet5 + hltOverlapFilterIsoEle22WP75GsfCaloJet5 + HLTPFTriggerSequenceForTaus + HLTIsoEle22WP75GsfLooseIsoPFTau20Sequence + HLTEndSequence ) HLT_Ele25WP60_SC4_Mass55_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG20 + hltPreEle25WP60SC4Mass55 + HLTEle25WP60SC4Mass55Sequence + HLTEndSequence ) HLT_Ele25_eta2p1_WP85_Gsf_PFMET80_boostedW_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG40ORL1SingleIsoEG30erORL1ETM70 + hltPreEle25eta2p1WP85GsfPFMET80boostedW + HLTEle25WP85GsfSequence + HLTAK4PFJetsSequence + hltPFMETProducer + hltPFMET80Filter + HLTEndSequence ) diff --git a/HLTrigger/Configuration/python/HLT_FULL_Famos_cff.py b/HLTrigger/Configuration/python/HLT_FULL_Famos_cff.py index 2a99d4f2e0f35..1484dd13448ab 100644 --- a/HLTrigger/Configuration/python/HLT_FULL_Famos_cff.py +++ b/HLTrigger/Configuration/python/HLT_FULL_Famos_cff.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/HLT/V6 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/HLT/V10 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms from FastSimulation.HighLevelTrigger.HLTSetup_cff import * HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V6') + tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V10') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -9968,8 +9968,8 @@ reqOppCharge = cms.untracked.bool( False ), nZcandcut = cms.int32( 1 ) ) -hltL1sL1SingleIsoEG18 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG18" ), +hltL1sL1SingleIsoEG20er = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG20er" ), saveTags = cms.bool( True ), L1MuonCollectionTag = cms.InputTag( "l1extraParticles" ), L1UseL1TriggerObjectMaps = cms.bool( True ), @@ -9984,7 +9984,7 @@ L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), offset = cms.uint32( 0 ) ) -hltEGL1SingleIsoEG18erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", +hltEGL1SingleIsoEG20erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", doIsolated = cms.bool( False ), endcap_end = cms.double( 2.17 ), saveTags = cms.bool( False ), @@ -9994,7 +9994,7 @@ candIsolatedTag = cms.InputTag( "hltEgammaCandidates" ), region_phi_size = cms.double( 1.044 ), region_eta_size = cms.double( 0.522 ), - L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG18" ), + L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG20er" ), candNonIsolatedTag = cms.InputTag( "" ), l1NonIsolatedTag = cms.InputTag( 'l1extraParticles','NonIsolated' ), ncandcut = cms.int32( 1 ) @@ -10004,7 +10004,7 @@ L1NonIsoCand = cms.InputTag( "" ), relaxed = cms.untracked.bool( False ), L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - inputTag = cms.InputTag( "hltEGL1SingleIsoEG18erFilter" ), + inputTag = cms.InputTag( "hltEGL1SingleIsoEG20erFilter" ), etcutEB = cms.double( 22.0 ), etcutEE = cms.double( 22.0 ), ncandcut = cms.int32( 1 ) @@ -29552,7 +29552,7 @@ tanhSO10ForwardThres = cms.double( 1.0 ), L1IsoPixelSeedsTag = cms.InputTag( "hltEgammaElectronPixelSeedsUnseeded" ), L1NonIsoCand = cms.InputTag( "" ), - ncandcut = cms.int32( 1 ), + ncandcut = cms.int32( 2 ), tanhSO10BarrelThres = cms.double( 0.35 ), s_a_rF = cms.double( 0.04 ), L1NonIsoPixelSeedsTag = cms.InputTag( "" ), @@ -32727,6 +32727,1214 @@ L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), offset = cms.uint32( 0 ) ) +hltL1sL1DoubleMuOpenBptxAND = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_DoubleMuOpen_BptxAND" ), + saveTags = cms.bool( True ), + L1MuonCollectionTag = cms.InputTag( "l1extraParticles" ), + L1UseL1TriggerObjectMaps = cms.bool( True ), + L1UseAliasesForSeeding = cms.bool( True ), + L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), + L1CollectionsTag = cms.InputTag( "l1extraParticles" ), + L1NrBxInEvent = cms.int32( 3 ), + L1GtObjectMapTag = cms.InputTag( "simGtDigis" ), + L1TechTriggerSeeding = cms.bool( False ) +) +hltPreHIL1DoubleMu0HighQ = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), + offset = cms.uint32( 0 ) +) +hltL1fL1DoubleMu0HQL1Filtered0 = cms.EDFilter( "HLTMuonL1Filter", + saveTags = cms.bool( True ), + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1DoubleMuOpenBptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "l1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) +) +hltL1sL1SingleMu3BptxAND = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleMu3_BptxAND" ), + saveTags = cms.bool( True ), + L1MuonCollectionTag = cms.InputTag( "l1extraParticles" ), + L1UseL1TriggerObjectMaps = cms.bool( True ), + L1UseAliasesForSeeding = cms.bool( True ), + L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), + L1CollectionsTag = cms.InputTag( "l1extraParticles" ), + L1NrBxInEvent = cms.int32( 3 ), + L1GtObjectMapTag = cms.InputTag( "simGtDigis" ), + L1TechTriggerSeeding = cms.bool( False ) +) +hltPreHIL2Mu3 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIL1SingleMu3Filtered = cms.EDFilter( "HLTMuonL1Filter", + saveTags = cms.bool( False ), + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1SingleMu3BptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 1 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "l1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) +) +hltHIL2Mu3L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "offlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltPreHIL2Mu7 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIL2Mu7L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 7.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "offlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltPreHIL2Mu15 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIL2Mu15L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 15.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "offlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltPreHIL2Mu3NHitQ = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIL2Mu3N1HitQL2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 1 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "offlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltPreHIL2DoubleMu0 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIDoubleMuLevel1PathL1OpenFiltered = cms.EDFilter( "HLTMuonL1Filter", + saveTags = cms.bool( True ), + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1DoubleMuOpenBptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "l1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) +) +hltHIL2DoubleMu0L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "offlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltPreHIL2DoubleMu0NHitQ = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIL2DoubleMu0L2N1HitsFiltered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 1 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "offlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltPreHIL2DoubleMu3 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIL2DoubleMu3L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "offlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltPreHIL3Mu3 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHISiPixelClusters = cms.EDProducer( "SiPixelClusterProducer", + src = cms.InputTag( "hltSiPixelDigis" ), + ChannelThreshold = cms.int32( 1000 ), + maxNumberOfClusters = cms.int32( -1 ), + VCaltoElectronGain = cms.int32( 65 ), + MissCalibrate = cms.untracked.bool( True ), + SplitClusters = cms.bool( False ), + VCaltoElectronOffset = cms.int32( -414 ), + payloadType = cms.string( "HLT" ), + SeedThreshold = cms.int32( 1000 ), + ClusterThreshold = cms.double( 4000.0 ) +) +hltHISiPixelClustersCache = cms.EDProducer( "SiPixelClusterShapeCacheProducer", + src = cms.InputTag( "hltHISiPixelClusters" ), + onDemand = cms.bool( False ) +) +hltHISiPixelRecHits = cms.EDProducer( "SiPixelRecHitConverter", + VerboseLevel = cms.untracked.int32( 0 ), + src = cms.InputTag( "hltHISiPixelClusters" ), + CPE = cms.string( "hltESPPixelCPEGeneric" ) +) +hltHISiStripClusters = cms.EDProducer( "MeasurementTrackerEventProducer", + inactivePixelDetectorLabels = cms.VInputTag( ), + stripClusterProducer = cms.string( "hltSiStripRawToClustersFacility" ), + pixelClusterProducer = cms.string( "hltHISiPixelClusters" ), + switchOffPixelsIfEmpty = cms.bool( True ), + inactiveStripDetectorLabels = cms.VInputTag( 'hltSiStripExcludedFEDListProducer' ), + skipClusters = cms.InputTag( "" ), + measurementTracker = cms.string( "hltESPMeasurementTracker" ) +) +hltHIL3TrajSeedOIState = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + propagatorCompatibleName = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + option = cms.uint32( 3 ), + maxChi2 = cms.double( 40.0 ), + errorMatrixPset = cms.PSet( + atIP = cms.bool( True ), + action = cms.string( "use" ), + errorMatrixValuesPSet = cms.PSet( + pf3_V12 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V13 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V11 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V14 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V15 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), + pf3_V33 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + zAxis = cms.vdouble( -3.14159, 3.14159 ), + pf3_V44 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), + pf3_V22 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V23 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V45 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V55 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V34 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V35 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V25 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V24 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ) + ) + ), + propagatorName = cms.string( "hltESPSteppingHelixPropagatorAlong" ), + manySeeds = cms.bool( False ), + copyMuonRecHit = cms.bool( False ), + ComponentName = cms.string( "TSGForRoadSearch" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ) + ), + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSteppingHelixPropagatorOpposite', + 'hltESPSteppingHelixPropagatorAlong' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( ), + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( ), + PtCut = cms.double( 1.0 ) +) +hltHIL3TrackCandidateFromL2OIState = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedOIState" ), + reverseTrajectories = cms.bool( True ), + TransientInitialStateEstimatorParameters = cms.PSet( + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), + numberMeasurementsForFit = cms.int32( 4 ), + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) + ), + TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + cleanTrajectoryAfterInOut = cms.bool( False ), + useHitsSplitting = cms.bool( False ), + RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), + doSeedingRegionRebuilding = cms.bool( False ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilderSeedHit" ) ), + NavigationSchool = cms.string( "SimpleNavigationSchool" ), + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) +) +hltHIL3TkTracksFromL2OIState = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2OIState" ), + SimpleMagneticField = cms.string( "" ), + clusterRemovalInfo = cms.InputTag( "" ), + beamSpot = cms.InputTag( "offlineBeamSpot" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), + useHitsSplitting = cms.bool( False ), + MeasurementTracker = cms.string( "" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), + NavigationSchool = cms.string( "" ), + TrajectoryInEvent = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + GeometricInnerState = cms.bool( True ), + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +hltHIL3MuonsOIState = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) + ), + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "offlineBeamSpot" ) + ), + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) + ), + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) + ), + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2OIState" ), + tkTrajBeamSpot = cms.InputTag( "offlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) + ), + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "offlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) + ), + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) +) +hltHIL3TrajSeedOIHit = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + PSetNames = cms.vstring( 'skipTSG', + 'iterativeTSG' ), + L3TkCollectionA = cms.InputTag( "hltHIL3MuonsOIState" ), + iterativeTSG = cms.PSet( + ErrorRescaling = cms.double( 3.0 ), + beamSpot = cms.InputTag( "unused" ), + MaxChi2 = cms.double( 40.0 ), + errorMatrixPset = cms.PSet( + atIP = cms.bool( True ), + action = cms.string( "use" ), + errorMatrixValuesPSet = cms.PSet( + pf3_V12 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V13 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V11 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V14 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V15 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), + pf3_V33 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + zAxis = cms.vdouble( -3.14159, 3.14159 ), + pf3_V44 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), + pf3_V22 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V23 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V45 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V55 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V34 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V35 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V25 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V24 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ) + ) + ), + UpdateState = cms.bool( True ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + SelectState = cms.bool( False ), + SigmaZ = cms.double( 25.0 ), + ResetMethod = cms.string( "matrix" ), + ComponentName = cms.string( "TSGFromPropagation" ), + UseVertexState = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAnyOpposite" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ) + ), + skipTSG = cms.PSet( ), + ComponentName = cms.string( "DualByL2TSG" ) + ), + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'PropagatorWithMaterial', + 'hltESPSmartPropagatorAnyOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( ), + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( + cleanerFromSharedHits = cms.bool( True ), + ptCleaner = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + beamSpot = cms.InputTag( "offlineBeamSpot" ), + directionCleaner = cms.bool( True ) + ), + PtCut = cms.double( 1.0 ) +) +hltHIL3TrackCandidateFromL2OIHit = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedOIHit" ), + reverseTrajectories = cms.bool( True ), + TransientInitialStateEstimatorParameters = cms.PSet( + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), + numberMeasurementsForFit = cms.int32( 4 ), + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) + ), + TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + cleanTrajectoryAfterInOut = cms.bool( False ), + useHitsSplitting = cms.bool( False ), + RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), + doSeedingRegionRebuilding = cms.bool( False ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), + NavigationSchool = cms.string( "SimpleNavigationSchool" ), + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) +) +hltHIL3TkTracksFromL2OIHit = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2OIHit" ), + SimpleMagneticField = cms.string( "" ), + clusterRemovalInfo = cms.InputTag( "" ), + beamSpot = cms.InputTag( "offlineBeamSpot" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), + useHitsSplitting = cms.bool( False ), + MeasurementTracker = cms.string( "" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), + NavigationSchool = cms.string( "" ), + TrajectoryInEvent = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + GeometricInnerState = cms.bool( True ), + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +hltHIL3MuonsOIHit = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) + ), + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "offlineBeamSpot" ) + ), + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) + ), + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) + ), + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2OIHit" ), + tkTrajBeamSpot = cms.InputTag( "offlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) + ), + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "offlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) + ), + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) +) +hltHIL3TkFromL2OICombination = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit' ) +) +hltHIL3TrajSeedIOHit = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + PSetNames = cms.vstring( 'skipTSG', + 'skipTSG' ), + L3TkCollectionA = cms.InputTag( "hltHIL3TkFromL2OICombination" ), + iterativeTSG = cms.PSet( + firstTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + ComponentName = cms.string( "StandardHitTripletGenerator" ), + GeneratorPSet = cms.PSet( + useBending = cms.bool( True ), + useFixedPreFiltering = cms.bool( False ), + maxElement = cms.uint32( 0 ), + phiPreFiltering = cms.double( 0.3 ), + extraHitRPhitolerance = cms.double( 0.06 ), + useMultScattering = cms.bool( True ), + ComponentName = cms.string( "PixelTripletHLTGenerator" ), + extraHitRZtolerance = cms.double( 0.06 ), + SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) + ), + SeedingLayers = cms.InputTag( "hltPixelLayerTriplets" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ), + PSetNames = cms.vstring( 'firstTSG', + 'secondTSG' ), + ComponentName = cms.string( "CombinedTSG" ), + thirdTSG = cms.PSet( + PSetNames = cms.vstring( 'endcapTSG', + 'barrelTSG' ), + barrelTSG = cms.PSet( ), + endcapTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + maxElement = cms.uint32( 0 ), + ComponentName = cms.string( "StandardHitPairGenerator" ), + useOnDemandTracker = cms.untracked.int32( 0 ), + SeedingLayers = cms.InputTag( "hltMixedLayerPairs" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ), + etaSeparation = cms.double( 2.0 ), + ComponentName = cms.string( "DualByEtaTSG" ) + ), + secondTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + maxElement = cms.uint32( 0 ), + ComponentName = cms.string( "StandardHitPairGenerator" ), + useOnDemandTracker = cms.untracked.int32( 0 ), + SeedingLayers = cms.InputTag( "hltPixelLayerPairs" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ) + ), + skipTSG = cms.PSet( ), + ComponentName = cms.string( "DualByL2TSG" ) + ), + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'PropagatorWithMaterial' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.1 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.1 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "offlineBeamSpot" ) + ), + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( + cleanerFromSharedHits = cms.bool( True ), + ptCleaner = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + beamSpot = cms.InputTag( "offlineBeamSpot" ), + directionCleaner = cms.bool( True ) + ), + PtCut = cms.double( 1.0 ) +) +hltHIL3TrackCandidateFromL2IOHit = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedIOHit" ), + reverseTrajectories = cms.bool( False ), + TransientInitialStateEstimatorParameters = cms.PSet( + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), + numberMeasurementsForFit = cms.int32( 4 ), + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) + ), + TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + cleanTrajectoryAfterInOut = cms.bool( False ), + useHitsSplitting = cms.bool( False ), + RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), + doSeedingRegionRebuilding = cms.bool( False ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), + NavigationSchool = cms.string( "SimpleNavigationSchool" ), + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) +) +hltHIL3TkTracksFromL2IOHit = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2IOHit" ), + SimpleMagneticField = cms.string( "" ), + clusterRemovalInfo = cms.InputTag( "" ), + beamSpot = cms.InputTag( "offlineBeamSpot" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), + useHitsSplitting = cms.bool( False ), + MeasurementTracker = cms.string( "" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), + NavigationSchool = cms.string( "" ), + TrajectoryInEvent = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + GeometricInnerState = cms.bool( True ), + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +hltHIAllL3MuonsIOHit = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) + ), + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "offlineBeamSpot" ) + ), + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) + ), + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) + ), + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2IOHit" ), + tkTrajBeamSpot = cms.InputTag( "offlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) + ), + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "offlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) + ), + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) +) +hltHIL3TrajectorySeed = cms.EDProducer( "L3MuonTrajectorySeedCombiner", + labels = cms.VInputTag( 'hltHIL3TrajSeedIOHit','hltHIL3TrajSeedOIState','hltHIL3TrajSeedOIHit' ) +) +hltHIL3TrackCandidateFromL2 = cms.EDProducer( "L3TrackCandCombiner", + labels = cms.VInputTag( 'hltHIL3TrackCandidateFromL2IOHit','hltHIL3TrackCandidateFromL2OIHit','hltHIL3TrackCandidateFromL2OIState' ) +) +hltHIL3TkTracksFromL2 = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3TkTracksFromL2IOHit','hltHIL3TkTracksFromL2OIHit','hltHIL3TkTracksFromL2OIState' ) +) +hltHIL3MuonsLinksCombination = cms.EDProducer( "L3TrackLinksCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit','hltHIAllL3MuonsIOHit' ) +) +hltHIL3Muons = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit','hltHIAllL3MuonsIOHit' ) +) +hltHIL3MuonCandidates = cms.EDProducer( "L3MuonCandidateProducer", + InputLinksObjects = cms.InputTag( "hltHIL3MuonsLinksCombination" ), + InputObjects = cms.InputTag( "hltHIL3Muons" ), + MuonPtOption = cms.string( "Global" ) +) +hltHISingleMu3L3Filtered = cms.EDFilter( "HLTMuonL3PreFilter", + MaxNormalizedChi2 = cms.double( 20.0 ), + saveTags = cms.bool( True ), + PreviousCandTag = cms.InputTag( "hltHIL2Mu3L2Filtered" ), + MinNmuonHits = cms.int32( 0 ), + MinN = cms.int32( 1 ), + MinTrackPt = cms.double( 0.0 ), + MaxEta = cms.double( 2.5 ), + MaxDXYBeamSpot = cms.double( 0.1 ), + MinNhits = cms.int32( 0 ), + MinDxySig = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MaxDz = cms.double( 9999.0 ), + MaxPtDifference = cms.double( 9999.0 ), + MaxDr = cms.double( 2.0 ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + MinDXYBeamSpot = cms.double( -1.0 ), + MinDr = cms.double( -1.0 ), + BeamSpotTag = cms.InputTag( "offlineBeamSpot" ), + MinPt = cms.double( 3.0 ) +) +hltPreHIL3DoubleMuOpen = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIDimuonL2PreFiltered0 = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "offlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltHIDimuonL3FilterOpen = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( 0 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "offlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +hltPreHIL3DoubleMuOpenSS = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIDimuonL3FilterOpenSS = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( 1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "offlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +hltPreHIL3DoubleMuOpenOS = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIDimuonL3FilterOpenOS = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( -1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "offlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +hltPreHIL3DoubleMuOpenOSNoCowboy = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIDimuonL3FilterOpenOSNoCowboy = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( -1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "offlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( True ), + MinInvMass = cms.vdouble( 0.0 ) +) hltTriggerSummaryAOD = cms.EDProducer( "TriggerSummaryProducerAOD", processName = cms.string( "@" ) ) @@ -32815,7 +34023,7 @@ HLTDoublePho85Sequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleEG40ORL1SingleEG35Filter + hltEG85EtFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEG85HEFilter + HLTPFClusteringForEgammaUnseeded + hltEgammaCandidatesUnseeded + hltEgammaCandidatesWrapperUnseeded + hltDiEG85EtUnseededFilter + hltEgammaHoverEUnseeded + hltDiEG85HEUnseededFilter ) HLTEle17Ele8GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1DoubleEG1510Filter + hltEle17Ele8EtLeg1Filter + hltEle17Ele8EtLeg2Filter + hltEgammaClusterShape + hltEle17Ele8ClusterShapeLeg1Filter + hltEle17Ele8ClusterShapeLeg2Filter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEle17Ele8HELeg1Filter + hltEle17Ele8HELeg2Filter + hltEgammaEcalPFClusterIso + hltEle17Ele8EcalIsoLeg1Filter + hltEle17Ele8EcalIsoLeg2Filter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltEle17Ele8HcalIsoLeg1Filter + hltEle17Ele8HcalIsoLeg2Filter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltEle17Ele8PixelMatchLeg1Filter + hltEle17Ele8PixelMatchLeg2Filter + HLTGsfElectronSequence + hltEle17Ele8GsfDetaLeg1Filter + hltEle17Ele8GsfDetaLeg2Filter + hltEle17Ele8GsfDphiLeg1Filter + hltEle17Ele8GsfDphiLeg2Filter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltEle17Ele8GsfTrackIsoLeg1Filter + hltEle17Ele8GsfTrackIsoLeg2Filter ) HLTEle20WP60Ele8Mass55Sequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleEG20Filter + hltEle20WP60Ele8EtFilter + hltEgammaClusterShape + hltEle20WP60Ele8ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEle20WP60Ele8HEFilter + hltEgammaEcalPFClusterIso + hltEle20WP60Ele8EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltEle20WP60Ele8HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltEle20WP60Ele8PixelMatchFilter + HLTGsfElectronSequence + hltEle20WP60Ele8OneOEMinusOneOPFilter + hltEle20WP60Ele8DetaFilter + hltEle20WP60Ele8DphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltEle20WP60Ele8TrackIsoFilter + HLTPFClusteringForEgammaUnseeded + hltEgammaCandidatesUnseeded + hltEgammaCandidatesWrapperUnseeded + hltEle20WP60Ele8EtUnseededFilter + HLTElePixelMatchUnseededSequence + hltEle20WP60Ele8PixelMatchUnseededFilter + hltEle20WP60Ele8Mass55Filter ) -HLTSingleEle22erWP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleIsoEG18erFilter + hltSingleEG22EtFilter + hltEgammaClusterShape + hltSingleEle22WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltSingleEle22WP75HcEFilter + hltEgammaEcalPFClusterIso + hltSingleEle22WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltSingleEle22WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltSingleEle22WP75PixelMatchFilter + HLTGsfElectronSequence + hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + hltSingleEle22WP75GsfChi2Filter + hltSingleEle22WP75GsfDetaFilter + hltSingleEle22WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltSingleEle22WP75GsfTrackIsoFilter ) +HLTSingleEle22erWP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleIsoEG20erFilter + hltSingleEG22EtFilter + hltEgammaClusterShape + hltSingleEle22WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltSingleEle22WP75HcEFilter + hltEgammaEcalPFClusterIso + hltSingleEle22WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltSingleEle22WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltSingleEle22WP75PixelMatchFilter + HLTGsfElectronSequence + hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + hltSingleEle22WP75GsfChi2Filter + hltSingleEle22WP75GsfDetaFilter + hltSingleEle22WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltSingleEle22WP75GsfTrackIsoFilter ) HLTEle22WP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGRegionalL1IsoEG20erTauJet20er + hltEG22L1sIsoEG20erTauJet20erEtFilter + hltEgammaClusterShape + hltEle22WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEle22WP75HcEFilter + hltEgammaEcalPFClusterIso + hltEle22WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltEle22WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltEle22WP75PixelMatchFilter + HLTGsfElectronSequence + hltEle22WP75GsfOneOESuperMinusOneOPFilter + hltEle22WP75GsfChi2Filter + hltEle22WP75GsfDetaFilter + hltEle22WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltEle22WP75GsfTrackIsoFilter ) HLTLooseIsoPFTauSequence = cms.Sequence( hltTauPFJets08Region + hltTauPFJetsRecoTauChargedHadrons + hltPFTauPiZeros + hltPFTausSansRef + hltPFTaus + hltPFTauTrackFindingDiscriminator + hltPFTauLooseAbsoluteIsolationDiscriminator + hltPFTauLooseRelativeIsolationDiscriminator + hltPFTauLooseAbsOrRelIsolationDiscriminator ) HLTIsoEle22WP75GsfLooseIsoPFTau20Sequence = cms.Sequence( HLTLooseIsoPFTauSequence + hltPFTau20 + hltSelectedPFTausTrackFinding + hltPFTau20Track + hltSelectedPFTausTrackFindingLooseIsolation + hltPFTau20TrackLooseIso + hltOverlapFilterIsoEle22WP75GsfLooseIsoPFTau20 ) @@ -32962,6 +34170,11 @@ HLTEle15GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleEG5Filter + hltEG15EtFilter + hltEgammaClusterShape + hltEle15VVVLClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEle15VVVLHEFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltEle15PixelMatchFilter + HLTGsfElectronSequence + hltEle15GsfOneOEMinusOneOPFilter + hltEle15GsfMissingHitsFilter + hltEle15GsfDetaFilter + hltEle15GsfDphiFilter ) HLTMu15IsolationSequence = cms.Sequence( HLTL3muonEcalPFisorecoSequenceNoBoolsUnseeded + hltL3fL1sMu5L1f0L2f3QL3Filtered15QL3pfecalIsoRhoFilteredEB0p13EE0p10 + HLTL3muonHcalPFisorecoSequenceNoBoolsUnseeded + hltL3fL1sMu5L1f0L2f3QL3Filtered15QL3pfhcalIsoRhoFiltered0p23 + HLTTrackReconstructionForIsoL3MuonIter02 + hltMuonTkRelIsolationCut0p09Map ) HLTRecopixelvertexingForHighMultSequence = cms.Sequence( hltPixelLayerTriplets + hltPixelTracksForHighMult + hltPixelVerticesForHighMult ) +HLTDoHILocalPixelSequence = cms.Sequence( hltSiPixelDigis + hltHISiPixelClusters + hltHISiPixelClustersCache + hltHISiPixelRecHits ) +HLTDoHILocalStripSequence = cms.Sequence( hltSiStripExcludedFEDListProducer + hltSiStripRawToClustersFacility + hltHISiStripClusters ) +HLTHIL3muonTkCandidateSequence = cms.Sequence( HLTDoHILocalPixelSequence + HLTDoHILocalStripSequence + hltHIL3TrajSeedOIState + hltHIL3TrackCandidateFromL2OIState + hltHIL3TkTracksFromL2OIState + hltHIL3MuonsOIState + hltHIL3TrajSeedOIHit + hltHIL3TrackCandidateFromL2OIHit + hltHIL3TkTracksFromL2OIHit + hltHIL3MuonsOIHit + hltHIL3TkFromL2OICombination + hltHIL3TrajSeedIOHit + hltHIL3TrackCandidateFromL2IOHit + hltHIL3TkTracksFromL2IOHit + hltHIAllL3MuonsIOHit + hltHIL3TrajectorySeed + hltHIL3TrackCandidateFromL2 ) +HLTHIL3muonrecoNocandSequence = cms.Sequence( HLTHIL3muonTkCandidateSequence + hltHIL3TkTracksFromL2 + hltHIL3MuonsLinksCombination + hltHIL3Muons ) +HLTHIL3muonrecoSequence = cms.Sequence( HLTHIL3muonrecoNocandSequence + hltHIL3MuonCandidates ) HLTriggerFirstPath = cms.Path( hltGetConditions + hltGetRaw + hltBoolFalse ) HLT_AK8PFJet360TrimMod_Mass30_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleJet176ORSingleJet200 + hltPreAK8PFJet360TrimModMass30 + HLTAK8CaloJetsSequence + hltAK8SingleCaloJet260 + HLTAK8PFJetsSequence + hltAK8PFJetsCorrectedMatchedToCaloJets260 + hltAK8TrimModJets + hltAK8SinglePFJet360TrimModMass30 + cms.SequencePlaceholder( "HLTEndSequence" ) ) @@ -32996,7 +34209,7 @@ HLT_DoublePhoton85_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG40ORL1SingleEG35 + hltPreDoublePhoton85 + HLTDoublePho85Sequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_Ele17_Ele8_Gsf_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleEG1510 + hltPreEle17Ele8Gsf + HLTEle17Ele8GsfSequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_Ele20WP60_Ele8_Mass55_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG20 + hltPreEle20WP60Ele8Mass55 + HLTEle20WP60Ele8Mass55Sequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) -HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleIsoEG18 + hltPreEle22eta2p1WP75Gsf + HLTSingleEle22erWP75GsfSequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) +HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleIsoEG20er + hltPreEle22eta2p1WP75Gsf + HLTSingleEle22erWP75GsfSequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_Ele22_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1 = cms.Path( HLTBeginSequence + hltL1sL1IsoEG20erTauJet20er + hltPreEle22eta2p1WP75GsfLooseIsoPFTau20 + HLTEle22WP75GsfSequence + HLTRecoJetSequenceAK4PrePF + hltTauJet5 + hltOverlapFilterIsoEle22WP75GsfCaloJet5 + HLTPFTriggerSequenceForTaus + HLTIsoEle22WP75GsfLooseIsoPFTau20Sequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_Ele25WP60_SC4_Mass55_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG20 + hltPreEle25WP60SC4Mass55 + HLTEle25WP60SC4Mass55Sequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_Ele25_eta2p1_WP85_Gsf_PFMET80_boostedW_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG40ORL1SingleIsoEG30erORL1ETM70 + hltPreEle25eta2p1WP85GsfPFMET80boostedW + HLTEle25WP85GsfSequence + HLTAK4PFJetsSequence + hltPFMETProducer + hltPFMET80Filter + cms.SequencePlaceholder( "HLTEndSequence" ) ) @@ -33257,10 +34470,23 @@ HLT_Physics_v1 = cms.Path( HLTBeginSequence + hltPrePhysics + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_ReducedIterativeTracking_v1 = cms.Path( HLTBeginSequence + hltPreReducedIterativeTracking + HLTRecoJetSequenceAK4PrePF + HLTDoLocalPixelSequence + HLTRecopixelvertexingSequence + HLTDoLocalStripSequence + HLTIterativeTrackingIter02 + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_ZeroBias_v1 = cms.Path( HLTBeginSequence + hltL1sL1ZeroBias + hltPreZeroBias + cms.SequencePlaceholder( "HLTEndSequence" ) ) +HLT_HIL1DoubleMu0_HighQ_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL1DoubleMu0HighQ + hltL1fL1DoubleMu0HQL1Filtered0 + cms.SequencePlaceholder( "HLTEndSequence" ) ) +HLT_HIL2Mu3_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleMu3BptxAND + hltPreHIL2Mu3 + hltHIL1SingleMu3Filtered + HLTL2muonrecoSequence + hltHIL2Mu3L2Filtered + cms.SequencePlaceholder( "HLTEndSequence" ) ) +HLT_HIL2Mu7_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleMu3BptxAND + hltPreHIL2Mu7 + hltHIL1SingleMu3Filtered + HLTL2muonrecoSequence + hltHIL2Mu7L2Filtered + cms.SequencePlaceholder( "HLTEndSequence" ) ) +HLT_HIL2Mu15_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleMu3BptxAND + hltPreHIL2Mu15 + hltHIL1SingleMu3Filtered + HLTL2muonrecoSequence + hltHIL2Mu15L2Filtered + cms.SequencePlaceholder( "HLTEndSequence" ) ) +HLT_HIL2Mu3_NHitQ_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleMu3BptxAND + hltPreHIL2Mu3NHitQ + hltHIL1SingleMu3Filtered + HLTL2muonrecoSequence + hltHIL2Mu3N1HitQL2Filtered + cms.SequencePlaceholder( "HLTEndSequence" ) ) +HLT_HIL2DoubleMu0_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL2DoubleMu0 + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIL2DoubleMu0L2Filtered + cms.SequencePlaceholder( "HLTEndSequence" ) ) +HLT_HIL2DoubleMu0_NHitQ_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL2DoubleMu0NHitQ + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIL2DoubleMu0L2N1HitsFiltered + cms.SequencePlaceholder( "HLTEndSequence" ) ) +HLT_HIL2DoubleMu3_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL2DoubleMu3 + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIL2DoubleMu3L2Filtered + cms.SequencePlaceholder( "HLTEndSequence" ) ) +HLT_HIL3Mu3_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleMu3BptxAND + hltPreHIL3Mu3 + hltHIL1SingleMu3Filtered + HLTL2muonrecoSequence + hltHIL2Mu3L2Filtered + HLTHIL3muonrecoSequence + hltHISingleMu3L3Filtered + cms.SequencePlaceholder( "HLTEndSequence" ) ) +HLT_HIL3DoubleMuOpen_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL3DoubleMuOpen + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIDimuonL2PreFiltered0 + HLTHIL3muonrecoSequence + hltHIDimuonL3FilterOpen + cms.SequencePlaceholder( "HLTEndSequence" ) ) +HLT_HIL3DoubleMuOpen_SS_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL3DoubleMuOpenSS + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIDimuonL2PreFiltered0 + HLTHIL3muonrecoSequence + hltHIDimuonL3FilterOpenSS + cms.SequencePlaceholder( "HLTEndSequence" ) ) +HLT_HIL3DoubleMuOpen_OS_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL3DoubleMuOpenOS + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIDimuonL2PreFiltered0 + HLTHIL3muonrecoSequence + hltHIDimuonL3FilterOpenOS + cms.SequencePlaceholder( "HLTEndSequence" ) ) +HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL3DoubleMuOpenOSNoCowboy + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIDimuonL2PreFiltered0 + HLTHIL3muonrecoSequence + hltHIDimuonL3FilterOpenOSNoCowboy + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLTriggerFinalPath = cms.Path( HLTBeginSequence + hltScalersRawToDigi + hltFEDSelector + hltTriggerSummaryAOD + hltTriggerSummaryRAW ) -HLTSchedule = cms.Schedule( *(HLTriggerFirstPath, HLT_AK8PFJet360TrimMod_Mass30_v1, HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1, HLT_BTagCSV07_v1, HLT_CaloJet260_v1, HLT_CaloJet500_NoJetID_v1, HLT_Dimuon13_PsiPrime_v1, HLT_Dimuon13_Upsilon_v1, HLT_Dimuon20_Jpsi_v1, HLT_DoubleEle24_22_eta2p1_WP75_Gsf_v1, HLT_DoubleEle33_CaloIdL_GsfTrkIdVL_MW_v1, HLT_DoubleEle33_CaloIdL_GsfTrkIdVL_v1, HLT_DoubleMediumIsoPFTau40_Trk1_eta2p1_Reg_v1, HLT_DoubleMediumIsoPFTau40_Trk1_eta2p1_v1, HLT_DoubleMu4_3_Bs_v1, HLT_DoubleMu4_3_Jpsi_Displaced_v1, HLT_DoubleMu4_JpsiTrk_Displaced_v1, HLT_DoubleMu4_LowMassNonResonantTrk_Displaced_v1, HLT_DoubleMu4_PsiPrimeTrk_Displaced_v1, HLT_Mu7p5_L2Mu2_Jpsi_v1, HLT_Mu7p5_L2Mu2_Upsilon_v1, HLT_Mu7p5_Track2_Jpsi_v1, HLT_Mu7p5_Track3p5_Jpsi_v1, HLT_Mu7p5_Track7_Jpsi_v1, HLT_Mu7p5_Track2_Upsilon_v1, HLT_Mu7p5_Track3p5_Upsilon_v1, HLT_Mu7p5_Track7_Upsilon_v1, HLT_Dimuon0er16_Jpsi_NoOS_NoVertexing_v1, HLT_Dimuon0er16_Jpsi_NoVertexing_v1, HLT_Dimuon6_Jpsi_NoVertexing_v1, HLT_DoublePhoton85_v1, HLT_Ele17_Ele8_Gsf_v1, HLT_Ele20WP60_Ele8_Mass55_v1, HLT_Ele22_eta2p1_WP75_Gsf_v1, HLT_Ele22_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1, HLT_Ele25WP60_SC4_Mass55_v1, HLT_Ele25_eta2p1_WP85_Gsf_PFMET80_boostedW_v1, HLT_Ele35_eta2p1_WP85_Gsf_v1, HLT_Ele40_eta2p1_WP85_Gsf_v1, HLT_Ele27_WP85_Gsf_v1, HLT_Ele27_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1, HLT_Ele27_eta2p1_WP75_Gsf_DoubleMediumIsoPFTau40_Trk1_eta2p1_Reg_v1, HLT_Ele27_eta2p1_WP75_Gsf_CentralPFJet30_BTagCSV07_v1, HLT_Ele27_eta2p1_WP75_Gsf_TriCentralPFJet30_v1, HLT_Ele27_eta2p1_WP75_Gsf_TriCentralPFJet50_40_30_v1, HLT_Ele27_eta2p1_WP75_Gsf_v1, HLT_Ele32_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1, HLT_Ele32_eta2p1_WP75_Gsf_DoubleMediumIsoPFTau40_Trk1_eta2p1_Reg_v1, HLT_Ele32_eta2p1_WP75_Gsf_CentralPFJet30_BTagCSV07_v1, HLT_Ele32_eta2p1_WP75_Gsf_TriCentralPFJet30_v1, HLT_Ele32_eta2p1_WP75_Gsf_TriCentralPFJet50_40_30_v1, HLT_Ele32_eta2p1_WP75_Gsf_v1, HLT_Ele45_CaloIdVT_GsfTrkIdT_PFJet200_PFJet50_v1, HLT_Ele105_CaloIdVT_GsfTrkIdT_v1, HLT_HT650_v1, HLT_Mu16_eta2p1_CaloMET30_v1, HLT_IsoMu16_eta2p1_CaloMET30_v1, HLT_IsoMu16_eta2p1_CaloMET30_LooseIsoPFTau50_Trk30_eta2p1_v1, HLT_IsoMu17_eta2p1_v1, HLT_IsoMu17_eta2p1_LooseIsoPFTau20_v1, HLT_IsoMu17_eta2p1_LooseIsoPFTau20_SingleL1_v1, HLT_IsoMu17_eta2p1_MediumIsoPFTau40_Trk1_eta2p1_Reg_v1, HLT_DoubleIsoMu17_eta2p1_v1, HLT_IsoMu24_eta2p1_LooseIsoPFTau20_v1, HLT_IsoMu20_eta2p1_CentralPFJet30_BTagCSV07_v1, HLT_IsoMu20_eta2p1_TriCentralPFJet30_v1, HLT_IsoMu20_eta2p1_TriCentralPFJet50_40_30_v1, HLT_IsoMu20_v1, HLT_IsoMu20_eta2p1_v1, HLT_IsoMu24_eta2p1_CentralPFJet30_BTagCSV07_v1, HLT_IsoMu24_eta2p1_TriCentralPFJet30_v1, HLT_IsoMu24_eta2p1_TriCentralPFJet50_40_30_v1, HLT_IsoMu24_eta2p1_v1, HLT_IsoMu27_v1, HLT_IsoTkMu20_v1, HLT_IsoTkMu20_eta2p1_v1, HLT_IsoTkMu24_eta2p1_v1, HLT_IsoTkMu27_v1, HLT_IterativeTracking_v1, HLT_L2DoubleMu23_NoVertex_v1, HLT_L2DoubleMu28_NoVertex_2Cha_Angle2p5_Mass10_v1, HLT_L2DoubleMu38_NoVertex_2Cha_Angle2p5_Mass10_v1, HLT_LooseIsoPFTau50_Trk30_eta2p1_v1, HLT_LooseIsoPFTau50_Trk30_eta2p1_MET120_v1, HLT_LooseIsoPFTau50_Trk30_eta2p1_MET80_v1, HLT_Mu17_Mu8_DZ_v1, HLT_Mu17_NoFilters_v1, HLT_Mu17_TkMu8_DZ_v1, HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v1, HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v1, HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_v1, HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_DZ_v1, HLT_Mu25_TkMu0_dEta18_Onia_v1, HLT_Mu27_TkMu8_v1, HLT_Mu30_TkMu11_v1, HLT_Mu40_TkMu11_v1, HLT_Mu40_eta2p1_PFJet200_PFJet50_v1, HLT_Mu20_v1, HLT_TkMu20_v1, HLT_Mu24_eta2p1_v1, HLT_TkMu24_eta2p1_v1, HLT_Mu27_v1, HLT_TkMu27_v1, HLT_Mu50_v1, HLT_Mu45_eta2p1_v1, HLT_PFHT350_PFMET120_NoiseCleaned_v1, HLT_PFHT550_4Jet_v1, HLT_PFHT650_4Jet_v1, HLT_PFHT750_4Jet_v1, HLT_PFHT350_v1, HLT_PFHT600_v1, HLT_PFHT650_v1, HLT_PFHT900_v1, HLT_PFJet40_v1, HLT_PFJet60_v1, HLT_PFJet80_v1, HLT_PFJet140_v1, HLT_PFJet200_v1, HLT_PFJet260_v1, HLT_PFJet320_v1, HLT_PFJet400_v1, HLT_PFJet450_v1, HLT_PFJet500_v1, HLT_DiPFJetAve30_HFJEC_v1, HLT_DiPFJetAve60_HFJEC_v1, HLT_DiPFJetAve80_HFJEC_v1, HLT_DiPFJetAve100_HFJEC_v1, HLT_DiPFJetAve160_HFJEC_v1, HLT_DiPFJetAve220_HFJEC_v1, HLT_DiPFJetAve300_HFJEC_v1, HLT_DiPFJet40_DEta3p5_MJJ600_PFMETNoMu140_v1, HLT_DiPFJet40_DEta3p5_MJJ600_PFMETNoMu80_v1, HLT_DiCentralPFJet70_PFMET120_NoiseCleaned_v1, HLT_HT200_v1, HLT_HT250_v1, HLT_HT300_v1, HLT_HT350_v1, HLT_HT400_v1, HLT_PFHT200_DiPFJet90_PFAlphaT0p57_v1, HLT_PFHT250_DiPFJet90_PFAlphaT0p55_v1, HLT_PFHT300_DiPFJet90_PFAlphaT0p53_v1, HLT_PFHT350_DiPFJet90_PFAlphaT0p52_v1, HLT_PFHT400_DiPFJet90_PFAlphaT0p51_v1, HLT_MET75_IsoTrk50_v1, HLT_MET90_IsoTrk50_v1, HLT_PFMET120_NoiseCleaned_BTagCSV07_v1, HLT_PFMET120_NoiseCleaned_Mu5_v1, HLT_PFMET170_NoiseCleaned_v1, HLT_PFMET90_PFMHT90_IDLoose_v1, HLT_PFMET100_PFMHT100_IDLoose_v1, HLT_PFMET110_PFMHT110_IDLoose_v1, HLT_PFMET120_PFMHT120_IDLoose_v1, HLT_CaloMHTNoPU90_PFMET90_PFMHT90_IDLoose_BTagCSV0p7_v1, HLT_CaloMHTNoPU90_PFMET90_PFMHT90_IDLoose_v1, HLT_QuadPFJet_DoubleBTagCSV_VBF_Mqq200_v1, HLT_QuadPFJet_SingleBTagCSV_VBF_Mqq460_v1, HLT_QuadPFJet_DoubleBTagCSV_VBF_Mqq240_v1, HLT_QuadPFJet_SingleBTagCSV_VBF_Mqq500_v1, HLT_QuadPFJet_VBF_v1, HLT_L1_TripleJet_VBF_v1, HLT_QuadJet45_TripleCSV0p5_v1, HLT_QuadJet45_DoubleCSV0p5_v1, HLT_DoubleJet90_Double30_TripleCSV0p5_v1, HLT_DoubleJet90_Double30_DoubleCSV0p5_v1, HLT_PFchMET90_NoiseCleaned_v1, HLT_Photon135_PFMET100_NoiseCleaned_v1, HLT_Photon20_CaloIdVL_IsoL_v1, HLT_Photon22_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon22_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon250_NoHE_v1, HLT_Photon300_NoHE_v1, HLT_Photon26_R9Id85_OR_CaloId24b40e_Iso50T80L_Photon16_AND_HE10_R9Id65_Eta2_Mass60_v1, HLT_Photon36_R9Id85_OR_CaloId24b40e_Iso50T80L_Photon22_AND_HE10_R9Id65_Eta2_Mass15_v1, HLT_Photon36_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon36_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon50_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon50_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon75_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon75_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon90_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon90_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon120_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon120_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Mu8_TrkIsoVVL_v1, HLT_Mu17_TrkIsoVVL_v1, HLT_Mu24_TrkIsoVVL_v1, HLT_Mu34_TrkIsoVVL_v1, HLT_Ele12_CaloIdL_TrackIdL_IsoVL_PFJet30_v1, HLT_Ele18_CaloIdL_TrackIdL_IsoVL_PFJet30_v1, HLT_Ele23_CaloIdL_TrackIdL_IsoVL_PFJet30_v1, HLT_Ele33_CaloIdL_TrackIdL_IsoVL_PFJet30_v1, HLT_BTagMu_DiJet20_Mu5_v1, HLT_BTagMu_DiJet40_Mu5_v1, HLT_BTagMu_DiJet70_Mu5_v1, HLT_BTagMu_DiJet110_Mu5_v1, HLT_BTagMu_Jet300_Mu5_v1, HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v1, HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v1, HLT_Ele16_Ele12_Ele8_CaloIdL_TrackIdL_v1, HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v1, HLT_Mu8_TrkIsoVVL_Ele17_CaloIdL_TrackIdL_IsoVL_v1, HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_Mu17_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_Mu30_Ele30_CaloIdL_GsfTrkIdVL_v1, HLT_Mu8_DiEle12_CaloIdL_TrackIdL_v1, HLT_Mu12_Photon25_CaloIdL_v1, HLT_Mu12_Photon25_CaloIdL_L1ISO_v1, HLT_Mu12_Photon25_CaloIdL_L1OR_v1, HLT_Mu17_Photon30_CaloIdL_L1ISO_v1, HLT_Mu17_Photon35_CaloIdL_L1ISO_v1, HLT_DiMu9_Ele9_CaloIdL_TrackIdL_v1, HLT_TripleMu_12_10_5_v1, HLT_Mu3er_PFHT140_PFMET125_NoiseCleaned_v1, HLT_Mu6_PFHT200_PFMET100_NoiseCleaned_BTagCSV07_v1, HLT_Mu6_PFHT200_PFMET125_NoiseCleaned_v1, HLT_Mu14er_PFMET120_NoiseCleaned_v1, HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_Ele23_CaloIdL_TrackIdL_IsoVL_v1, HLT_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_AK8DiPFJet280_200_TrimMass30_BTagCSV0p3_v1, HLT_PFHT650_WideJetMJJ900DEtaJJ1p5_v1, HLT_PFHT650_WideJetMJJ950DEtaJJ1p5_v1, HLT_Photon22_v1, HLT_Photon30_v1, HLT_Photon36_v1, HLT_Photon50_v1, HLT_Photon75_v1, HLT_Photon90_v1, HLT_Photon120_v1, HLT_Photon175_v1, HLT_Photon165_HE10_v1, HLT_Photon22_R9Id90_HE10_IsoM_v1, HLT_Photon30_R9Id90_HE10_IsoM_v1, HLT_Photon36_R9Id90_HE10_IsoM_v1, HLT_Photon50_R9Id90_HE10_IsoM_v1, HLT_Photon75_R9Id90_HE10_IsoM_v1, HLT_Photon90_R9Id90_HE10_IsoM_v1, HLT_Photon120_R9Id90_HE10_IsoM_v1, HLT_Photon165_R9Id90_HE10_IsoM_v1, HLT_Diphoton34_18_R9Id85_OR_Iso50T80LCaloId24b40e_AND_HE10P1_R9Id50b80e_Mass95_v1, HLT_Diphoton44_28_R9Id85_OR_Iso50T80LCaloId24b40e_AND_HE10P1_R9Id50b80e_v1, HLT_Diphoton36_18_R9Id85_OR_Iso50T80LCaloId24b40e_AND_HE10P5_R9Id50b80e_Mass70_v1, HLT_Diphoton28_14_R9Id85_OR_Iso50T80LCaloId24b40e_AND_HE10P5_R9Id50b80e_Mass50_Eta_1p5_v1, HLT_Diphoton30_18_R9Id85_AND_Iso50T80LCaloId24b40e_AND_HE10P0_R9Id50b80e_Solid_Mass30_v1, HLT_Diphoton30_18_R9Id85_AND_Iso50T80LCaloId24b40e_AND_HE10P0_R9Id50b80e_PV_v1, HLT_Diphoton30_18_R9Id85_AND_Iso50T80LCaloId24b40e_AND_HE10P0_R9Id50b80e_DoublePV_v1, HLT_Dimuon0_Jpsi_Muon_v1, HLT_Dimuon0_Upsilon_Muon_v1, HLT_QuadMuon0_Dimuon0_Jpsi_v1, HLT_QuadMuon0_Dimuon0_Upsilon_v1, HLT_Mu17_Mu8_SameSign_v1, HLT_Mu17_Mu8_SameSign_DPhi_v1, HLT_RsqMR260_Rsq0p09_MR200_v1, HLT_RsqMR260_Rsq0p09_MR200_4jet_v1, HLT_RsqMR300_Rsq0p09_MR200_v1, HLT_RsqMR300_Rsq0p09_MR200_4jet_v1, HLT_Rsq0p36_v1, HLT_HT750_DisplacedDijet80_Inclusive_v1, HLT_HT650_DisplacedDijet80_Inclusive_v1, HLT_MonoCentralPFJet140_PFMETNoMu100_PFMHTNoMu140_NoiseCleaned_v1, HLT_MonoCentralPFJet140_PFMETNoMu140_PFMHTNoMu140_NoiseCleaned_v1, HLT_MonoCentralPFJet150_PFMETNoMu150_PFMHTNoMu150_NoiseCleaned_v1, HLT_Ele27_eta2p1_WP85_Gsf_HT200_v1, HLT_Photon90_CaloIdL_PFHT500_v1, HLT_DoubleMu8_Mass8_PFHT300_v1, HLT_Mu8_Ele8_CaloIdL_TrkIdVL_Mass8_PFHT300_v1, HLT_DoubleEle8_CaloIdL_TrkIdVL_Mass8_PFHT300_v1, HLT_Mu10_CentralPFJet30_BTagCSV0p5PF_v1, HLT_Ele10_CaloIdL_TrackIdVL_CentralPFJet30_BTagCSV0p5PF_v1, HLT_Ele15_IsoVVVL_BTagtop8CSV07_PFHT400_v1, HLT_Ele15_IsoVVVL_PFHT400_PFMET70_v1, HLT_Ele15_IsoVVVL_PFHT600_v1, HLT_Ele15_PFHT300_v1, HLT_Mu15_IsoVVVL_BTagCSV07_PFHT400_v1, HLT_Mu15_IsoVVVL_PFHT400_PFMET70_v1, HLT_Mu15_IsoVVVL_PFHT600_v1, HLT_Mu15_PFHT300_v1, HLT_Dimuon16_Jpsi_v1, HLT_Dimuon10_Jpsi_Barrel_v1, HLT_Dimuon8_PsiPrime_Barrel_v1, HLT_Dimuon8_Upsilon_Barrel_v1, HLT_Dimuon0_Phi_Barrel_v1, HLT_Mu16_TkMu0_dEta18_Onia_v1, HLT_Mu16_TkMu0_dEta18_Phi_v1, HLT_PixelTracks_Multiplicity60_v1, HLT_PixelTracks_Multiplicity85_v1, HLT_PixelTracks_Multiplicity110_v1, HLT_PixelTracks_Multiplicity135_v1, HLT_PixelTracks_Multiplicity160_v1, HLT_ECALHT800_v1, HLT_Physics_v1, HLT_ReducedIterativeTracking_v1, HLT_ZeroBias_v1, HLTriggerFinalPath )) +HLTSchedule = cms.Schedule( *(HLTriggerFirstPath, HLT_AK8PFJet360TrimMod_Mass30_v1, HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1, HLT_BTagCSV07_v1, HLT_CaloJet260_v1, HLT_CaloJet500_NoJetID_v1, HLT_Dimuon13_PsiPrime_v1, HLT_Dimuon13_Upsilon_v1, HLT_Dimuon20_Jpsi_v1, HLT_DoubleEle24_22_eta2p1_WP75_Gsf_v1, HLT_DoubleEle33_CaloIdL_GsfTrkIdVL_MW_v1, HLT_DoubleEle33_CaloIdL_GsfTrkIdVL_v1, HLT_DoubleMediumIsoPFTau40_Trk1_eta2p1_Reg_v1, HLT_DoubleMediumIsoPFTau40_Trk1_eta2p1_v1, HLT_DoubleMu4_3_Bs_v1, HLT_DoubleMu4_3_Jpsi_Displaced_v1, HLT_DoubleMu4_JpsiTrk_Displaced_v1, HLT_DoubleMu4_LowMassNonResonantTrk_Displaced_v1, HLT_DoubleMu4_PsiPrimeTrk_Displaced_v1, HLT_Mu7p5_L2Mu2_Jpsi_v1, HLT_Mu7p5_L2Mu2_Upsilon_v1, HLT_Mu7p5_Track2_Jpsi_v1, HLT_Mu7p5_Track3p5_Jpsi_v1, HLT_Mu7p5_Track7_Jpsi_v1, HLT_Mu7p5_Track2_Upsilon_v1, HLT_Mu7p5_Track3p5_Upsilon_v1, HLT_Mu7p5_Track7_Upsilon_v1, HLT_Dimuon0er16_Jpsi_NoOS_NoVertexing_v1, HLT_Dimuon0er16_Jpsi_NoVertexing_v1, HLT_Dimuon6_Jpsi_NoVertexing_v1, HLT_DoublePhoton85_v1, HLT_Ele17_Ele8_Gsf_v1, HLT_Ele20WP60_Ele8_Mass55_v1, HLT_Ele22_eta2p1_WP75_Gsf_v1, HLT_Ele22_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1, HLT_Ele25WP60_SC4_Mass55_v1, HLT_Ele25_eta2p1_WP85_Gsf_PFMET80_boostedW_v1, HLT_Ele35_eta2p1_WP85_Gsf_v1, HLT_Ele40_eta2p1_WP85_Gsf_v1, HLT_Ele27_WP85_Gsf_v1, HLT_Ele27_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1, HLT_Ele27_eta2p1_WP75_Gsf_DoubleMediumIsoPFTau40_Trk1_eta2p1_Reg_v1, HLT_Ele27_eta2p1_WP75_Gsf_CentralPFJet30_BTagCSV07_v1, HLT_Ele27_eta2p1_WP75_Gsf_TriCentralPFJet30_v1, HLT_Ele27_eta2p1_WP75_Gsf_TriCentralPFJet50_40_30_v1, HLT_Ele27_eta2p1_WP75_Gsf_v1, HLT_Ele32_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1, HLT_Ele32_eta2p1_WP75_Gsf_DoubleMediumIsoPFTau40_Trk1_eta2p1_Reg_v1, HLT_Ele32_eta2p1_WP75_Gsf_CentralPFJet30_BTagCSV07_v1, HLT_Ele32_eta2p1_WP75_Gsf_TriCentralPFJet30_v1, HLT_Ele32_eta2p1_WP75_Gsf_TriCentralPFJet50_40_30_v1, HLT_Ele32_eta2p1_WP75_Gsf_v1, HLT_Ele45_CaloIdVT_GsfTrkIdT_PFJet200_PFJet50_v1, HLT_Ele105_CaloIdVT_GsfTrkIdT_v1, HLT_HT650_v1, HLT_Mu16_eta2p1_CaloMET30_v1, HLT_IsoMu16_eta2p1_CaloMET30_v1, HLT_IsoMu16_eta2p1_CaloMET30_LooseIsoPFTau50_Trk30_eta2p1_v1, HLT_IsoMu17_eta2p1_v1, HLT_IsoMu17_eta2p1_LooseIsoPFTau20_v1, HLT_IsoMu17_eta2p1_LooseIsoPFTau20_SingleL1_v1, HLT_IsoMu17_eta2p1_MediumIsoPFTau40_Trk1_eta2p1_Reg_v1, HLT_DoubleIsoMu17_eta2p1_v1, HLT_IsoMu24_eta2p1_LooseIsoPFTau20_v1, HLT_IsoMu20_eta2p1_CentralPFJet30_BTagCSV07_v1, HLT_IsoMu20_eta2p1_TriCentralPFJet30_v1, HLT_IsoMu20_eta2p1_TriCentralPFJet50_40_30_v1, HLT_IsoMu20_v1, HLT_IsoMu20_eta2p1_v1, HLT_IsoMu24_eta2p1_CentralPFJet30_BTagCSV07_v1, HLT_IsoMu24_eta2p1_TriCentralPFJet30_v1, HLT_IsoMu24_eta2p1_TriCentralPFJet50_40_30_v1, HLT_IsoMu24_eta2p1_v1, HLT_IsoMu27_v1, HLT_IsoTkMu20_v1, HLT_IsoTkMu20_eta2p1_v1, HLT_IsoTkMu24_eta2p1_v1, HLT_IsoTkMu27_v1, HLT_IterativeTracking_v1, HLT_L2DoubleMu23_NoVertex_v1, HLT_L2DoubleMu28_NoVertex_2Cha_Angle2p5_Mass10_v1, HLT_L2DoubleMu38_NoVertex_2Cha_Angle2p5_Mass10_v1, HLT_LooseIsoPFTau50_Trk30_eta2p1_v1, HLT_LooseIsoPFTau50_Trk30_eta2p1_MET120_v1, HLT_LooseIsoPFTau50_Trk30_eta2p1_MET80_v1, HLT_Mu17_Mu8_DZ_v1, HLT_Mu17_NoFilters_v1, HLT_Mu17_TkMu8_DZ_v1, HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v1, HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v1, HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_v1, HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_DZ_v1, HLT_Mu25_TkMu0_dEta18_Onia_v1, HLT_Mu27_TkMu8_v1, HLT_Mu30_TkMu11_v1, HLT_Mu40_TkMu11_v1, HLT_Mu40_eta2p1_PFJet200_PFJet50_v1, HLT_Mu20_v1, HLT_TkMu20_v1, HLT_Mu24_eta2p1_v1, HLT_TkMu24_eta2p1_v1, HLT_Mu27_v1, HLT_TkMu27_v1, HLT_Mu50_v1, HLT_Mu45_eta2p1_v1, HLT_PFHT350_PFMET120_NoiseCleaned_v1, HLT_PFHT550_4Jet_v1, HLT_PFHT650_4Jet_v1, HLT_PFHT750_4Jet_v1, HLT_PFHT350_v1, HLT_PFHT600_v1, HLT_PFHT650_v1, HLT_PFHT900_v1, HLT_PFJet40_v1, HLT_PFJet60_v1, HLT_PFJet80_v1, HLT_PFJet140_v1, HLT_PFJet200_v1, HLT_PFJet260_v1, HLT_PFJet320_v1, HLT_PFJet400_v1, HLT_PFJet450_v1, HLT_PFJet500_v1, HLT_DiPFJetAve30_HFJEC_v1, HLT_DiPFJetAve60_HFJEC_v1, HLT_DiPFJetAve80_HFJEC_v1, HLT_DiPFJetAve100_HFJEC_v1, HLT_DiPFJetAve160_HFJEC_v1, HLT_DiPFJetAve220_HFJEC_v1, HLT_DiPFJetAve300_HFJEC_v1, HLT_DiPFJet40_DEta3p5_MJJ600_PFMETNoMu140_v1, HLT_DiPFJet40_DEta3p5_MJJ600_PFMETNoMu80_v1, HLT_DiCentralPFJet70_PFMET120_NoiseCleaned_v1, HLT_HT200_v1, HLT_HT250_v1, HLT_HT300_v1, HLT_HT350_v1, HLT_HT400_v1, HLT_PFHT200_DiPFJet90_PFAlphaT0p57_v1, HLT_PFHT250_DiPFJet90_PFAlphaT0p55_v1, HLT_PFHT300_DiPFJet90_PFAlphaT0p53_v1, HLT_PFHT350_DiPFJet90_PFAlphaT0p52_v1, HLT_PFHT400_DiPFJet90_PFAlphaT0p51_v1, HLT_MET75_IsoTrk50_v1, HLT_MET90_IsoTrk50_v1, HLT_PFMET120_NoiseCleaned_BTagCSV07_v1, HLT_PFMET120_NoiseCleaned_Mu5_v1, HLT_PFMET170_NoiseCleaned_v1, HLT_PFMET90_PFMHT90_IDLoose_v1, HLT_PFMET100_PFMHT100_IDLoose_v1, HLT_PFMET110_PFMHT110_IDLoose_v1, HLT_PFMET120_PFMHT120_IDLoose_v1, HLT_CaloMHTNoPU90_PFMET90_PFMHT90_IDLoose_BTagCSV0p7_v1, HLT_CaloMHTNoPU90_PFMET90_PFMHT90_IDLoose_v1, HLT_QuadPFJet_DoubleBTagCSV_VBF_Mqq200_v1, HLT_QuadPFJet_SingleBTagCSV_VBF_Mqq460_v1, HLT_QuadPFJet_DoubleBTagCSV_VBF_Mqq240_v1, HLT_QuadPFJet_SingleBTagCSV_VBF_Mqq500_v1, HLT_QuadPFJet_VBF_v1, HLT_L1_TripleJet_VBF_v1, HLT_QuadJet45_TripleCSV0p5_v1, HLT_QuadJet45_DoubleCSV0p5_v1, HLT_DoubleJet90_Double30_TripleCSV0p5_v1, HLT_DoubleJet90_Double30_DoubleCSV0p5_v1, HLT_PFchMET90_NoiseCleaned_v1, HLT_Photon135_PFMET100_NoiseCleaned_v1, HLT_Photon20_CaloIdVL_IsoL_v1, HLT_Photon22_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon22_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon250_NoHE_v1, HLT_Photon300_NoHE_v1, HLT_Photon26_R9Id85_OR_CaloId24b40e_Iso50T80L_Photon16_AND_HE10_R9Id65_Eta2_Mass60_v1, HLT_Photon36_R9Id85_OR_CaloId24b40e_Iso50T80L_Photon22_AND_HE10_R9Id65_Eta2_Mass15_v1, HLT_Photon36_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon36_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon50_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon50_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon75_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon75_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon90_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon90_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon120_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon120_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Mu8_TrkIsoVVL_v1, HLT_Mu17_TrkIsoVVL_v1, HLT_Mu24_TrkIsoVVL_v1, HLT_Mu34_TrkIsoVVL_v1, HLT_Ele12_CaloIdL_TrackIdL_IsoVL_PFJet30_v1, HLT_Ele18_CaloIdL_TrackIdL_IsoVL_PFJet30_v1, HLT_Ele23_CaloIdL_TrackIdL_IsoVL_PFJet30_v1, HLT_Ele33_CaloIdL_TrackIdL_IsoVL_PFJet30_v1, HLT_BTagMu_DiJet20_Mu5_v1, HLT_BTagMu_DiJet40_Mu5_v1, HLT_BTagMu_DiJet70_Mu5_v1, HLT_BTagMu_DiJet110_Mu5_v1, HLT_BTagMu_Jet300_Mu5_v1, HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v1, HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v1, HLT_Ele16_Ele12_Ele8_CaloIdL_TrackIdL_v1, HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v1, HLT_Mu8_TrkIsoVVL_Ele17_CaloIdL_TrackIdL_IsoVL_v1, HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_Mu17_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_Mu30_Ele30_CaloIdL_GsfTrkIdVL_v1, HLT_Mu8_DiEle12_CaloIdL_TrackIdL_v1, HLT_Mu12_Photon25_CaloIdL_v1, HLT_Mu12_Photon25_CaloIdL_L1ISO_v1, HLT_Mu12_Photon25_CaloIdL_L1OR_v1, HLT_Mu17_Photon30_CaloIdL_L1ISO_v1, HLT_Mu17_Photon35_CaloIdL_L1ISO_v1, HLT_DiMu9_Ele9_CaloIdL_TrackIdL_v1, HLT_TripleMu_12_10_5_v1, HLT_Mu3er_PFHT140_PFMET125_NoiseCleaned_v1, HLT_Mu6_PFHT200_PFMET100_NoiseCleaned_BTagCSV07_v1, HLT_Mu6_PFHT200_PFMET125_NoiseCleaned_v1, HLT_Mu14er_PFMET120_NoiseCleaned_v1, HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_Ele23_CaloIdL_TrackIdL_IsoVL_v1, HLT_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_AK8DiPFJet280_200_TrimMass30_BTagCSV0p3_v1, HLT_PFHT650_WideJetMJJ900DEtaJJ1p5_v1, HLT_PFHT650_WideJetMJJ950DEtaJJ1p5_v1, HLT_Photon22_v1, HLT_Photon30_v1, HLT_Photon36_v1, HLT_Photon50_v1, HLT_Photon75_v1, HLT_Photon90_v1, HLT_Photon120_v1, HLT_Photon175_v1, HLT_Photon165_HE10_v1, HLT_Photon22_R9Id90_HE10_IsoM_v1, HLT_Photon30_R9Id90_HE10_IsoM_v1, HLT_Photon36_R9Id90_HE10_IsoM_v1, HLT_Photon50_R9Id90_HE10_IsoM_v1, HLT_Photon75_R9Id90_HE10_IsoM_v1, HLT_Photon90_R9Id90_HE10_IsoM_v1, HLT_Photon120_R9Id90_HE10_IsoM_v1, HLT_Photon165_R9Id90_HE10_IsoM_v1, HLT_Diphoton34_18_R9Id85_OR_Iso50T80LCaloId24b40e_AND_HE10P1_R9Id50b80e_Mass95_v1, HLT_Diphoton44_28_R9Id85_OR_Iso50T80LCaloId24b40e_AND_HE10P1_R9Id50b80e_v1, HLT_Diphoton36_18_R9Id85_OR_Iso50T80LCaloId24b40e_AND_HE10P5_R9Id50b80e_Mass70_v1, HLT_Diphoton28_14_R9Id85_OR_Iso50T80LCaloId24b40e_AND_HE10P5_R9Id50b80e_Mass50_Eta_1p5_v1, HLT_Diphoton30_18_R9Id85_AND_Iso50T80LCaloId24b40e_AND_HE10P0_R9Id50b80e_Solid_Mass30_v1, HLT_Diphoton30_18_R9Id85_AND_Iso50T80LCaloId24b40e_AND_HE10P0_R9Id50b80e_PV_v1, HLT_Diphoton30_18_R9Id85_AND_Iso50T80LCaloId24b40e_AND_HE10P0_R9Id50b80e_DoublePV_v1, HLT_Dimuon0_Jpsi_Muon_v1, HLT_Dimuon0_Upsilon_Muon_v1, HLT_QuadMuon0_Dimuon0_Jpsi_v1, HLT_QuadMuon0_Dimuon0_Upsilon_v1, HLT_Mu17_Mu8_SameSign_v1, HLT_Mu17_Mu8_SameSign_DPhi_v1, HLT_RsqMR260_Rsq0p09_MR200_v1, HLT_RsqMR260_Rsq0p09_MR200_4jet_v1, HLT_RsqMR300_Rsq0p09_MR200_v1, HLT_RsqMR300_Rsq0p09_MR200_4jet_v1, HLT_Rsq0p36_v1, HLT_HT750_DisplacedDijet80_Inclusive_v1, HLT_HT650_DisplacedDijet80_Inclusive_v1, HLT_MonoCentralPFJet140_PFMETNoMu100_PFMHTNoMu140_NoiseCleaned_v1, HLT_MonoCentralPFJet140_PFMETNoMu140_PFMHTNoMu140_NoiseCleaned_v1, HLT_MonoCentralPFJet150_PFMETNoMu150_PFMHTNoMu150_NoiseCleaned_v1, HLT_Ele27_eta2p1_WP85_Gsf_HT200_v1, HLT_Photon90_CaloIdL_PFHT500_v1, HLT_DoubleMu8_Mass8_PFHT300_v1, HLT_Mu8_Ele8_CaloIdL_TrkIdVL_Mass8_PFHT300_v1, HLT_DoubleEle8_CaloIdL_TrkIdVL_Mass8_PFHT300_v1, HLT_Mu10_CentralPFJet30_BTagCSV0p5PF_v1, HLT_Ele10_CaloIdL_TrackIdVL_CentralPFJet30_BTagCSV0p5PF_v1, HLT_Ele15_IsoVVVL_BTagtop8CSV07_PFHT400_v1, HLT_Ele15_IsoVVVL_PFHT400_PFMET70_v1, HLT_Ele15_IsoVVVL_PFHT600_v1, HLT_Ele15_PFHT300_v1, HLT_Mu15_IsoVVVL_BTagCSV07_PFHT400_v1, HLT_Mu15_IsoVVVL_PFHT400_PFMET70_v1, HLT_Mu15_IsoVVVL_PFHT600_v1, HLT_Mu15_PFHT300_v1, HLT_Dimuon16_Jpsi_v1, HLT_Dimuon10_Jpsi_Barrel_v1, HLT_Dimuon8_PsiPrime_Barrel_v1, HLT_Dimuon8_Upsilon_Barrel_v1, HLT_Dimuon0_Phi_Barrel_v1, HLT_Mu16_TkMu0_dEta18_Onia_v1, HLT_Mu16_TkMu0_dEta18_Phi_v1, HLT_PixelTracks_Multiplicity60_v1, HLT_PixelTracks_Multiplicity85_v1, HLT_PixelTracks_Multiplicity110_v1, HLT_PixelTracks_Multiplicity135_v1, HLT_PixelTracks_Multiplicity160_v1, HLT_ECALHT800_v1, HLT_Physics_v1, HLT_ReducedIterativeTracking_v1, HLT_ZeroBias_v1, HLT_HIL1DoubleMu0_HighQ_v1, HLT_HIL2Mu3_v1, HLT_HIL2Mu7_v1, HLT_HIL2Mu15_v1, HLT_HIL2Mu3_NHitQ_v1, HLT_HIL2DoubleMu0_v1, HLT_HIL2DoubleMu0_NHitQ_v1, HLT_HIL2DoubleMu3_v1, HLT_HIL3Mu3_v1, HLT_HIL3DoubleMuOpen_v1, HLT_HIL3DoubleMuOpen_SS_v1, HLT_HIL3DoubleMuOpen_OS_v1, HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1, HLTriggerFinalPath )) diff --git a/HLTrigger/Configuration/python/HLT_FULL_cff.py b/HLTrigger/Configuration/python/HLT_FULL_cff.py index 1c1196bec9e72..5c24ae66687ea 100644 --- a/HLTrigger/Configuration/python/HLT_FULL_cff.py +++ b/HLTrigger/Configuration/python/HLT_FULL_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_4_0/HLT/V6 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/HLT/V10 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V6') + tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V10') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -382,6 +382,7 @@ ) streams = cms.PSet( A = cms.vstring( 'InitialPD', + 'InitialPDForHI', 'Templates' ), ALCAP0 = cms.vstring( 'AlCaP0' ), ALCAPHISYM = cms.vstring( 'AlCaPhiSym' ), @@ -703,6 +704,19 @@ 'HLT_VBF_DisplacedJet40_TightID_DisplacedTrack_v1', 'HLT_VBF_DisplacedJet40_TightID_Hadronic_v1', 'HLT_ZeroBias_v1') ), + InitialPDForHI = cms.vstring( 'HLT_HIL1DoubleMu0_HighQ_v1', + 'HLT_HIL2DoubleMu0_NHitQ_v1', + 'HLT_HIL2DoubleMu0_v1', + 'HLT_HIL2DoubleMu3_v1', + 'HLT_HIL2Mu15_v1', + 'HLT_HIL2Mu3_NHitQ_v1', + 'HLT_HIL2Mu3_v1', + 'HLT_HIL2Mu7_v1', + 'HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1', + 'HLT_HIL3DoubleMuOpen_OS_v1', + 'HLT_HIL3DoubleMuOpen_SS_v1', + 'HLT_HIL3DoubleMuOpen_v1', + 'HLT_HIL3Mu3_v1' ), OfflineMonitor = cms.vstring( ), OfflineMonitorHI = cms.vstring( ), OnlineHltMonitor = cms.vstring( ), @@ -17736,8 +17750,8 @@ reqOppCharge = cms.untracked.bool( False ), nZcandcut = cms.int32( 1 ) ) -hltL1sL1SingleIsoEG18 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG18" ), +hltL1sL1SingleIsoEG20er = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG20er" ), saveTags = cms.bool( True ), L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), L1UseL1TriggerObjectMaps = cms.bool( True ), @@ -17752,7 +17766,7 @@ L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) -hltEGL1SingleIsoEG18erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", +hltEGL1SingleIsoEG20erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", doIsolated = cms.bool( False ), endcap_end = cms.double( 2.17 ), saveTags = cms.bool( False ), @@ -17762,7 +17776,7 @@ candIsolatedTag = cms.InputTag( "hltEgammaCandidates" ), region_phi_size = cms.double( 1.044 ), region_eta_size = cms.double( 0.522 ), - L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG18" ), + L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG20er" ), candNonIsolatedTag = cms.InputTag( "" ), l1NonIsolatedTag = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), ncandcut = cms.int32( 1 ) @@ -17772,7 +17786,7 @@ L1NonIsoCand = cms.InputTag( "" ), relaxed = cms.untracked.bool( False ), L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - inputTag = cms.InputTag( "hltEGL1SingleIsoEG18erFilter" ), + inputTag = cms.InputTag( "hltEGL1SingleIsoEG20erFilter" ), etcutEB = cms.double( 22.0 ), etcutEE = cms.double( 22.0 ), ncandcut = cms.int32( 1 ) @@ -41411,7 +41425,7 @@ tanhSO10ForwardThres = cms.double( 1.0 ), L1IsoPixelSeedsTag = cms.InputTag( "hltEgammaElectronPixelSeedsUnseeded" ), L1NonIsoCand = cms.InputTag( "" ), - ncandcut = cms.int32( 1 ), + ncandcut = cms.int32( 2 ), tanhSO10BarrelThres = cms.double( 0.35 ), s_a_rF = cms.double( 0.04 ), L1NonIsoPixelSeedsTag = cms.InputTag( "" ), @@ -45501,6 +45515,1214 @@ L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) +hltL1sL1DoubleMuOpenBptxAND = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_DoubleMuOpen_BptxAND" ), + saveTags = cms.bool( True ), + L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), + L1UseL1TriggerObjectMaps = cms.bool( True ), + L1UseAliasesForSeeding = cms.bool( True ), + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + L1CollectionsTag = cms.InputTag( "hltL1extraParticles" ), + L1NrBxInEvent = cms.int32( 3 ), + L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), + L1TechTriggerSeeding = cms.bool( False ) +) +hltPreHIL1DoubleMu0HighQ = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltL1fL1DoubleMu0HQL1Filtered0 = cms.EDFilter( "HLTMuonL1Filter", + saveTags = cms.bool( True ), + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1DoubleMuOpenBptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "hltL1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) +) +hltL1sL1SingleMu3BptxAND = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleMu3_BptxAND" ), + saveTags = cms.bool( True ), + L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), + L1UseL1TriggerObjectMaps = cms.bool( True ), + L1UseAliasesForSeeding = cms.bool( True ), + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + L1CollectionsTag = cms.InputTag( "hltL1extraParticles" ), + L1NrBxInEvent = cms.int32( 3 ), + L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), + L1TechTriggerSeeding = cms.bool( False ) +) +hltPreHIL2Mu3 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIL1SingleMu3Filtered = cms.EDFilter( "HLTMuonL1Filter", + saveTags = cms.bool( False ), + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1SingleMu3BptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 1 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "hltL1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) +) +hltHIL2Mu3L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltPreHIL2Mu7 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIL2Mu7L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 7.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltPreHIL2Mu15 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIL2Mu15L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 15.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltPreHIL2Mu3NHitQ = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIL2Mu3N1HitQL2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 1 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltPreHIL2DoubleMu0 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIDoubleMuLevel1PathL1OpenFiltered = cms.EDFilter( "HLTMuonL1Filter", + saveTags = cms.bool( True ), + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1DoubleMuOpenBptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "hltL1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) +) +hltHIL2DoubleMu0L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltPreHIL2DoubleMu0NHitQ = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIL2DoubleMu0L2N1HitsFiltered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 1 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltPreHIL2DoubleMu3 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIL2DoubleMu3L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltPreHIL3Mu3 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHISiPixelClusters = cms.EDProducer( "SiPixelClusterProducer", + src = cms.InputTag( "hltSiPixelDigis" ), + ChannelThreshold = cms.int32( 1000 ), + maxNumberOfClusters = cms.int32( -1 ), + VCaltoElectronGain = cms.int32( 65 ), + MissCalibrate = cms.untracked.bool( True ), + SplitClusters = cms.bool( False ), + VCaltoElectronOffset = cms.int32( -414 ), + payloadType = cms.string( "HLT" ), + SeedThreshold = cms.int32( 1000 ), + ClusterThreshold = cms.double( 4000.0 ) +) +hltHISiPixelClustersCache = cms.EDProducer( "SiPixelClusterShapeCacheProducer", + src = cms.InputTag( "hltHISiPixelClusters" ), + onDemand = cms.bool( False ) +) +hltHISiPixelRecHits = cms.EDProducer( "SiPixelRecHitConverter", + VerboseLevel = cms.untracked.int32( 0 ), + src = cms.InputTag( "hltHISiPixelClusters" ), + CPE = cms.string( "hltESPPixelCPEGeneric" ) +) +hltHISiStripClusters = cms.EDProducer( "MeasurementTrackerEventProducer", + inactivePixelDetectorLabels = cms.VInputTag( ), + stripClusterProducer = cms.string( "hltSiStripRawToClustersFacility" ), + pixelClusterProducer = cms.string( "hltHISiPixelClusters" ), + switchOffPixelsIfEmpty = cms.bool( True ), + inactiveStripDetectorLabels = cms.VInputTag( 'hltSiStripExcludedFEDListProducer' ), + skipClusters = cms.InputTag( "" ), + measurementTracker = cms.string( "hltESPMeasurementTracker" ) +) +hltHIL3TrajSeedOIState = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + propagatorCompatibleName = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + option = cms.uint32( 3 ), + maxChi2 = cms.double( 40.0 ), + errorMatrixPset = cms.PSet( + atIP = cms.bool( True ), + action = cms.string( "use" ), + errorMatrixValuesPSet = cms.PSet( + pf3_V12 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V13 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V11 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V14 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V15 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), + pf3_V33 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + zAxis = cms.vdouble( -3.14159, 3.14159 ), + pf3_V44 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), + pf3_V22 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V23 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V45 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V55 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V34 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V35 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V25 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V24 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ) + ) + ), + propagatorName = cms.string( "hltESPSteppingHelixPropagatorAlong" ), + manySeeds = cms.bool( False ), + copyMuonRecHit = cms.bool( False ), + ComponentName = cms.string( "TSGForRoadSearch" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ) + ), + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSteppingHelixPropagatorOpposite', + 'hltESPSteppingHelixPropagatorAlong' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( ), + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( ), + PtCut = cms.double( 1.0 ) +) +hltHIL3TrackCandidateFromL2OIState = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedOIState" ), + reverseTrajectories = cms.bool( True ), + TransientInitialStateEstimatorParameters = cms.PSet( + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), + numberMeasurementsForFit = cms.int32( 4 ), + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) + ), + TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + cleanTrajectoryAfterInOut = cms.bool( False ), + useHitsSplitting = cms.bool( False ), + RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), + doSeedingRegionRebuilding = cms.bool( False ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilderSeedHit" ) ), + NavigationSchool = cms.string( "SimpleNavigationSchool" ), + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) +) +hltHIL3TkTracksFromL2OIState = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2OIState" ), + SimpleMagneticField = cms.string( "" ), + clusterRemovalInfo = cms.InputTag( "" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), + useHitsSplitting = cms.bool( False ), + MeasurementTracker = cms.string( "" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), + NavigationSchool = cms.string( "" ), + TrajectoryInEvent = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + GeometricInnerState = cms.bool( True ), + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +hltHIL3MuonsOIState = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) + ), + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + ), + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) + ), + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) + ), + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2OIState" ), + tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) + ), + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) + ), + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) +) +hltHIL3TrajSeedOIHit = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + PSetNames = cms.vstring( 'skipTSG', + 'iterativeTSG' ), + L3TkCollectionA = cms.InputTag( "hltHIL3MuonsOIState" ), + iterativeTSG = cms.PSet( + ErrorRescaling = cms.double( 3.0 ), + beamSpot = cms.InputTag( "unused" ), + MaxChi2 = cms.double( 40.0 ), + errorMatrixPset = cms.PSet( + atIP = cms.bool( True ), + action = cms.string( "use" ), + errorMatrixValuesPSet = cms.PSet( + pf3_V12 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V13 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V11 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V14 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V15 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), + pf3_V33 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + zAxis = cms.vdouble( -3.14159, 3.14159 ), + pf3_V44 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), + pf3_V22 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V23 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V45 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V55 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V34 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V35 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V25 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V24 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ) + ) + ), + UpdateState = cms.bool( True ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + SelectState = cms.bool( False ), + SigmaZ = cms.double( 25.0 ), + ResetMethod = cms.string( "matrix" ), + ComponentName = cms.string( "TSGFromPropagation" ), + UseVertexState = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAnyOpposite" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ) + ), + skipTSG = cms.PSet( ), + ComponentName = cms.string( "DualByL2TSG" ) + ), + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'PropagatorWithMaterial', + 'hltESPSmartPropagatorAnyOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( ), + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( + cleanerFromSharedHits = cms.bool( True ), + ptCleaner = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + directionCleaner = cms.bool( True ) + ), + PtCut = cms.double( 1.0 ) +) +hltHIL3TrackCandidateFromL2OIHit = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedOIHit" ), + reverseTrajectories = cms.bool( True ), + TransientInitialStateEstimatorParameters = cms.PSet( + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), + numberMeasurementsForFit = cms.int32( 4 ), + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) + ), + TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + cleanTrajectoryAfterInOut = cms.bool( False ), + useHitsSplitting = cms.bool( False ), + RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), + doSeedingRegionRebuilding = cms.bool( False ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), + NavigationSchool = cms.string( "SimpleNavigationSchool" ), + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) +) +hltHIL3TkTracksFromL2OIHit = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2OIHit" ), + SimpleMagneticField = cms.string( "" ), + clusterRemovalInfo = cms.InputTag( "" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), + useHitsSplitting = cms.bool( False ), + MeasurementTracker = cms.string( "" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), + NavigationSchool = cms.string( "" ), + TrajectoryInEvent = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + GeometricInnerState = cms.bool( True ), + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +hltHIL3MuonsOIHit = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) + ), + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + ), + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) + ), + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) + ), + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2OIHit" ), + tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) + ), + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) + ), + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) +) +hltHIL3TkFromL2OICombination = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit' ) +) +hltHIL3TrajSeedIOHit = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + PSetNames = cms.vstring( 'skipTSG', + 'skipTSG' ), + L3TkCollectionA = cms.InputTag( "hltHIL3TkFromL2OICombination" ), + iterativeTSG = cms.PSet( + firstTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + ComponentName = cms.string( "StandardHitTripletGenerator" ), + GeneratorPSet = cms.PSet( + useBending = cms.bool( True ), + useFixedPreFiltering = cms.bool( False ), + maxElement = cms.uint32( 0 ), + phiPreFiltering = cms.double( 0.3 ), + extraHitRPhitolerance = cms.double( 0.06 ), + useMultScattering = cms.bool( True ), + ComponentName = cms.string( "PixelTripletHLTGenerator" ), + extraHitRZtolerance = cms.double( 0.06 ), + SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) + ), + SeedingLayers = cms.InputTag( "hltPixelLayerTriplets" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ), + PSetNames = cms.vstring( 'firstTSG', + 'secondTSG' ), + ComponentName = cms.string( "CombinedTSG" ), + thirdTSG = cms.PSet( + PSetNames = cms.vstring( 'endcapTSG', + 'barrelTSG' ), + barrelTSG = cms.PSet( ), + endcapTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + maxElement = cms.uint32( 0 ), + ComponentName = cms.string( "StandardHitPairGenerator" ), + useOnDemandTracker = cms.untracked.int32( 0 ), + SeedingLayers = cms.InputTag( "hltMixedLayerPairs" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ), + etaSeparation = cms.double( 2.0 ), + ComponentName = cms.string( "DualByEtaTSG" ) + ), + secondTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + maxElement = cms.uint32( 0 ), + ComponentName = cms.string( "StandardHitPairGenerator" ), + useOnDemandTracker = cms.untracked.int32( 0 ), + SeedingLayers = cms.InputTag( "hltPixelLayerPairs" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ) + ), + skipTSG = cms.PSet( ), + ComponentName = cms.string( "DualByL2TSG" ) + ), + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'PropagatorWithMaterial' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.1 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.1 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + ), + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( + cleanerFromSharedHits = cms.bool( True ), + ptCleaner = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + directionCleaner = cms.bool( True ) + ), + PtCut = cms.double( 1.0 ) +) +hltHIL3TrackCandidateFromL2IOHit = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedIOHit" ), + reverseTrajectories = cms.bool( False ), + TransientInitialStateEstimatorParameters = cms.PSet( + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), + numberMeasurementsForFit = cms.int32( 4 ), + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) + ), + TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + cleanTrajectoryAfterInOut = cms.bool( False ), + useHitsSplitting = cms.bool( False ), + RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), + doSeedingRegionRebuilding = cms.bool( False ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), + NavigationSchool = cms.string( "SimpleNavigationSchool" ), + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) +) +hltHIL3TkTracksFromL2IOHit = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2IOHit" ), + SimpleMagneticField = cms.string( "" ), + clusterRemovalInfo = cms.InputTag( "" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), + useHitsSplitting = cms.bool( False ), + MeasurementTracker = cms.string( "" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), + NavigationSchool = cms.string( "" ), + TrajectoryInEvent = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + GeometricInnerState = cms.bool( True ), + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +hltHIAllL3MuonsIOHit = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) + ), + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + ), + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) + ), + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) + ), + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2IOHit" ), + tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) + ), + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) + ), + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) +) +hltHIL3TrajectorySeed = cms.EDProducer( "L3MuonTrajectorySeedCombiner", + labels = cms.VInputTag( 'hltHIL3TrajSeedIOHit','hltHIL3TrajSeedOIState','hltHIL3TrajSeedOIHit' ) +) +hltHIL3TrackCandidateFromL2 = cms.EDProducer( "L3TrackCandCombiner", + labels = cms.VInputTag( 'hltHIL3TrackCandidateFromL2IOHit','hltHIL3TrackCandidateFromL2OIHit','hltHIL3TrackCandidateFromL2OIState' ) +) +hltHIL3TkTracksFromL2 = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3TkTracksFromL2IOHit','hltHIL3TkTracksFromL2OIHit','hltHIL3TkTracksFromL2OIState' ) +) +hltHIL3MuonsLinksCombination = cms.EDProducer( "L3TrackLinksCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit','hltHIAllL3MuonsIOHit' ) +) +hltHIL3Muons = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit','hltHIAllL3MuonsIOHit' ) +) +hltHIL3MuonCandidates = cms.EDProducer( "L3MuonCandidateProducer", + InputLinksObjects = cms.InputTag( "hltHIL3MuonsLinksCombination" ), + InputObjects = cms.InputTag( "hltHIL3Muons" ), + MuonPtOption = cms.string( "Global" ) +) +hltHISingleMu3L3Filtered = cms.EDFilter( "HLTMuonL3PreFilter", + MaxNormalizedChi2 = cms.double( 20.0 ), + saveTags = cms.bool( True ), + PreviousCandTag = cms.InputTag( "hltHIL2Mu3L2Filtered" ), + MinNmuonHits = cms.int32( 0 ), + MinN = cms.int32( 1 ), + MinTrackPt = cms.double( 0.0 ), + MaxEta = cms.double( 2.5 ), + MaxDXYBeamSpot = cms.double( 0.1 ), + MinNhits = cms.int32( 0 ), + MinDxySig = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MaxDz = cms.double( 9999.0 ), + MaxPtDifference = cms.double( 9999.0 ), + MaxDr = cms.double( 2.0 ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + MinDXYBeamSpot = cms.double( -1.0 ), + MinDr = cms.double( -1.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinPt = cms.double( 3.0 ) +) +hltPreHIL3DoubleMuOpen = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIDimuonL2PreFiltered0 = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltHIDimuonL3FilterOpen = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( 0 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +hltPreHIL3DoubleMuOpenSS = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIDimuonL3FilterOpenSS = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( 1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +hltPreHIL3DoubleMuOpenOS = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIDimuonL3FilterOpenOS = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( -1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +hltPreHIL3DoubleMuOpenOSNoCowboy = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIDimuonL3FilterOpenOSNoCowboy = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( -1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( True ), + MinInvMass = cms.vdouble( 0.0 ) +) hltFEDSelector = cms.EDProducer( "EvFFEDSelector", inputTag = cms.InputTag( "rawDataCollector" ), fedList = cms.vuint32( 1023 ) @@ -45643,7 +46865,7 @@ HLTDoublePho85Sequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleEG40ORL1SingleEG35Filter + hltEG85EtFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEG85HEFilter + HLTPFClusteringForEgammaUnseeded + hltEgammaCandidatesUnseeded + hltEgammaCandidatesWrapperUnseeded + hltDiEG85EtUnseededFilter + hltEgammaHoverEUnseeded + hltDiEG85HEUnseededFilter ) HLTEle17Ele8GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1DoubleEG1510Filter + hltEle17Ele8EtLeg1Filter + hltEle17Ele8EtLeg2Filter + hltEgammaClusterShape + hltEle17Ele8ClusterShapeLeg1Filter + hltEle17Ele8ClusterShapeLeg2Filter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEle17Ele8HELeg1Filter + hltEle17Ele8HELeg2Filter + hltEgammaEcalPFClusterIso + hltEle17Ele8EcalIsoLeg1Filter + hltEle17Ele8EcalIsoLeg2Filter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltEle17Ele8HcalIsoLeg1Filter + hltEle17Ele8HcalIsoLeg2Filter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltEle17Ele8PixelMatchLeg1Filter + hltEle17Ele8PixelMatchLeg2Filter + HLTGsfElectronSequence + hltEle17Ele8GsfDetaLeg1Filter + hltEle17Ele8GsfDetaLeg2Filter + hltEle17Ele8GsfDphiLeg1Filter + hltEle17Ele8GsfDphiLeg2Filter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltEle17Ele8GsfTrackIsoLeg1Filter + hltEle17Ele8GsfTrackIsoLeg2Filter ) HLTEle20WP60Ele8Mass55Sequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleEG20Filter + hltEle20WP60Ele8EtFilter + hltEgammaClusterShape + hltEle20WP60Ele8ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEle20WP60Ele8HEFilter + hltEgammaEcalPFClusterIso + hltEle20WP60Ele8EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltEle20WP60Ele8HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltEle20WP60Ele8PixelMatchFilter + HLTGsfElectronSequence + hltEle20WP60Ele8OneOEMinusOneOPFilter + hltEle20WP60Ele8DetaFilter + hltEle20WP60Ele8DphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltEle20WP60Ele8TrackIsoFilter + HLTPFClusteringForEgammaUnseeded + hltEgammaCandidatesUnseeded + hltEgammaCandidatesWrapperUnseeded + hltEle20WP60Ele8EtUnseededFilter + HLTElePixelMatchUnseededSequence + hltEle20WP60Ele8PixelMatchUnseededFilter + hltEle20WP60Ele8Mass55Filter ) -HLTSingleEle22erWP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleIsoEG18erFilter + hltSingleEG22EtFilter + hltEgammaClusterShape + hltSingleEle22WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltSingleEle22WP75HcEFilter + hltEgammaEcalPFClusterIso + hltSingleEle22WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltSingleEle22WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltSingleEle22WP75PixelMatchFilter + HLTGsfElectronSequence + hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + hltSingleEle22WP75GsfChi2Filter + hltSingleEle22WP75GsfDetaFilter + hltSingleEle22WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltSingleEle22WP75GsfTrackIsoFilter ) +HLTSingleEle22erWP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleIsoEG20erFilter + hltSingleEG22EtFilter + hltEgammaClusterShape + hltSingleEle22WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltSingleEle22WP75HcEFilter + hltEgammaEcalPFClusterIso + hltSingleEle22WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltSingleEle22WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltSingleEle22WP75PixelMatchFilter + HLTGsfElectronSequence + hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + hltSingleEle22WP75GsfChi2Filter + hltSingleEle22WP75GsfDetaFilter + hltSingleEle22WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltSingleEle22WP75GsfTrackIsoFilter ) HLTEle22WP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGRegionalL1IsoEG20erTauJet20er + hltEG22L1sIsoEG20erTauJet20erEtFilter + hltEgammaClusterShape + hltEle22WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEle22WP75HcEFilter + hltEgammaEcalPFClusterIso + hltEle22WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltEle22WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltEle22WP75PixelMatchFilter + HLTGsfElectronSequence + hltEle22WP75GsfOneOESuperMinusOneOPFilter + hltEle22WP75GsfChi2Filter + hltEle22WP75GsfDetaFilter + hltEle22WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltEle22WP75GsfTrackIsoFilter ) HLTLooseIsoPFTauSequence = cms.Sequence( hltTauPFJets08Region + hltTauPFJetsRecoTauChargedHadrons + hltPFTauPiZeros + hltPFTausSansRef + hltPFTaus + hltPFTauTrackFindingDiscriminator + hltPFTauLooseAbsoluteIsolationDiscriminator + hltPFTauLooseRelativeIsolationDiscriminator + hltPFTauLooseAbsOrRelIsolationDiscriminator ) HLTIsoEle22WP75GsfLooseIsoPFTau20Sequence = cms.Sequence( HLTLooseIsoPFTauSequence + hltPFTau20 + hltSelectedPFTausTrackFinding + hltPFTau20Track + hltSelectedPFTausTrackFindingLooseIsolation + hltPFTau20TrackLooseIso + hltOverlapFilterIsoEle22WP75GsfLooseIsoPFTau20 ) @@ -45833,6 +47055,11 @@ HLTMu15IsolationSequence = cms.Sequence( HLTL3muonEcalPFisorecoSequenceNoBoolsUnseeded + hltL3fL1sMu5L1f0L2f3QL3Filtered15QL3pfecalIsoRhoFilteredEB0p13EE0p10 + HLTL3muonHcalPFisorecoSequenceNoBoolsUnseeded + hltL3fL1sMu5L1f0L2f3QL3Filtered15QL3pfhcalIsoRhoFiltered0p23 + HLTTrackReconstructionForIsoL3MuonIter02 + hltMuonTkRelIsolationCut0p09Map ) HLTRecopixelvertexingForHighMultSequence = cms.Sequence( hltPixelLayerTriplets + hltPixelTracksForHighMult + hltPixelVerticesForHighMult ) HLTBeginSequenceRandom = cms.Sequence( hltRandomEventsFilter + hltGtDigis ) +HLTDoHILocalPixelSequence = cms.Sequence( hltSiPixelDigis + hltHISiPixelClusters + hltHISiPixelClustersCache + hltHISiPixelRecHits ) +HLTDoHILocalStripSequence = cms.Sequence( hltSiStripExcludedFEDListProducer + hltSiStripRawToClustersFacility + hltHISiStripClusters ) +HLTHIL3muonTkCandidateSequence = cms.Sequence( HLTDoHILocalPixelSequence + HLTDoHILocalStripSequence + hltHIL3TrajSeedOIState + hltHIL3TrackCandidateFromL2OIState + hltHIL3TkTracksFromL2OIState + hltHIL3MuonsOIState + hltHIL3TrajSeedOIHit + hltHIL3TrackCandidateFromL2OIHit + hltHIL3TkTracksFromL2OIHit + hltHIL3MuonsOIHit + hltHIL3TkFromL2OICombination + hltHIL3TrajSeedIOHit + hltHIL3TrackCandidateFromL2IOHit + hltHIL3TkTracksFromL2IOHit + hltHIAllL3MuonsIOHit + hltHIL3TrajectorySeed + hltHIL3TrackCandidateFromL2 ) +HLTHIL3muonrecoNocandSequence = cms.Sequence( HLTHIL3muonTkCandidateSequence + hltHIL3TkTracksFromL2 + hltHIL3MuonsLinksCombination + hltHIL3Muons ) +HLTHIL3muonrecoSequence = cms.Sequence( HLTHIL3muonrecoNocandSequence + hltHIL3MuonCandidates ) HLTriggerFirstPath = cms.Path( hltGetConditions + hltGetRaw + hltBoolFalse ) HLT_AK8PFJet360TrimMod_Mass30_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleJet176ORSingleJet200 + hltPreAK8PFJet360TrimModMass30 + HLTAK8CaloJetsSequence + hltAK8SingleCaloJet260 + HLTAK8PFJetsSequence + hltAK8PFJetsCorrectedMatchedToCaloJets260 + hltAK8TrimModJets + hltAK8SinglePFJet360TrimModMass30 + HLTEndSequence ) @@ -45871,7 +47098,7 @@ HLT_DoublePhoton85_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG40ORL1SingleEG35 + hltPreDoublePhoton85 + HLTDoublePho85Sequence + HLTEndSequence ) HLT_Ele17_Ele8_Gsf_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleEG1510 + hltPreEle17Ele8Gsf + HLTEle17Ele8GsfSequence + HLTEndSequence ) HLT_Ele20WP60_Ele8_Mass55_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG20 + hltPreEle20WP60Ele8Mass55 + HLTEle20WP60Ele8Mass55Sequence + HLTEndSequence ) -HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleIsoEG18 + hltPreEle22eta2p1WP75Gsf + HLTSingleEle22erWP75GsfSequence + HLTEndSequence ) +HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleIsoEG20er + hltPreEle22eta2p1WP75Gsf + HLTSingleEle22erWP75GsfSequence + HLTEndSequence ) HLT_Ele22_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1 = cms.Path( HLTBeginSequence + hltL1sL1IsoEG20erTauJet20er + hltPreEle22eta2p1WP75GsfLooseIsoPFTau20 + HLTEle22WP75GsfSequence + HLTRecoJetSequenceAK4PrePF + hltTauJet5 + hltOverlapFilterIsoEle22WP75GsfCaloJet5 + HLTPFTriggerSequenceForTaus + HLTIsoEle22WP75GsfLooseIsoPFTau20Sequence + HLTEndSequence ) HLT_Ele25WP60_SC4_Mass55_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG20 + hltPreEle25WP60SC4Mass55 + HLTEle25WP60SC4Mass55Sequence + HLTEndSequence ) HLT_Ele25_eta2p1_WP85_Gsf_PFMET80_boostedW_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG40ORL1SingleIsoEG30erORL1ETM70 + hltPreEle25eta2p1WP85GsfPFMET80boostedW + HLTEle25WP85GsfSequence + HLTAK4PFJetsSequence + hltPFMETProducer + hltPFMET80Filter + HLTEndSequence ) @@ -46154,11 +47381,24 @@ HLT_ReducedIterativeTracking_v1 = cms.Path( HLTBeginSequence + hltPreReducedIterativeTracking + HLTRecoJetSequenceAK4PrePF + HLTDoLocalPixelSequence + HLTRecopixelvertexingSequence + HLTDoLocalStripSequence + HLTIterativeTrackingIter02 + HLTEndSequence ) HLT_Random_v1 = cms.Path( HLTBeginSequenceRandom + hltPreRandom + HLTEndSequence ) HLT_ZeroBias_v1 = cms.Path( HLTBeginSequence + hltL1sL1ZeroBias + hltPreZeroBias + HLTEndSequence ) +HLT_HIL1DoubleMu0_HighQ_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL1DoubleMu0HighQ + hltL1fL1DoubleMu0HQL1Filtered0 + HLTEndSequence ) +HLT_HIL2Mu3_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleMu3BptxAND + hltPreHIL2Mu3 + hltHIL1SingleMu3Filtered + HLTL2muonrecoSequence + hltHIL2Mu3L2Filtered + HLTEndSequence ) +HLT_HIL2Mu7_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleMu3BptxAND + hltPreHIL2Mu7 + hltHIL1SingleMu3Filtered + HLTL2muonrecoSequence + hltHIL2Mu7L2Filtered + HLTEndSequence ) +HLT_HIL2Mu15_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleMu3BptxAND + hltPreHIL2Mu15 + hltHIL1SingleMu3Filtered + HLTL2muonrecoSequence + hltHIL2Mu15L2Filtered + HLTEndSequence ) +HLT_HIL2Mu3_NHitQ_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleMu3BptxAND + hltPreHIL2Mu3NHitQ + hltHIL1SingleMu3Filtered + HLTL2muonrecoSequence + hltHIL2Mu3N1HitQL2Filtered + HLTEndSequence ) +HLT_HIL2DoubleMu0_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL2DoubleMu0 + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIL2DoubleMu0L2Filtered + HLTEndSequence ) +HLT_HIL2DoubleMu0_NHitQ_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL2DoubleMu0NHitQ + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIL2DoubleMu0L2N1HitsFiltered + HLTEndSequence ) +HLT_HIL2DoubleMu3_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL2DoubleMu3 + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIL2DoubleMu3L2Filtered + HLTEndSequence ) +HLT_HIL3Mu3_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleMu3BptxAND + hltPreHIL3Mu3 + hltHIL1SingleMu3Filtered + HLTL2muonrecoSequence + hltHIL2Mu3L2Filtered + HLTHIL3muonrecoSequence + hltHISingleMu3L3Filtered + HLTEndSequence ) +HLT_HIL3DoubleMuOpen_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL3DoubleMuOpen + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIDimuonL2PreFiltered0 + HLTHIL3muonrecoSequence + hltHIDimuonL3FilterOpen + HLTEndSequence ) +HLT_HIL3DoubleMuOpen_SS_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL3DoubleMuOpenSS + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIDimuonL2PreFiltered0 + HLTHIL3muonrecoSequence + hltHIDimuonL3FilterOpenSS + HLTEndSequence ) +HLT_HIL3DoubleMuOpen_OS_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL3DoubleMuOpenOS + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIDimuonL2PreFiltered0 + HLTHIL3muonrecoSequence + hltHIDimuonL3FilterOpenOS + HLTEndSequence ) +HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL3DoubleMuOpenOSNoCowboy + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIDimuonL2PreFiltered0 + HLTHIL3muonrecoSequence + hltHIDimuonL3FilterOpenOSNoCowboy + HLTEndSequence ) HLTriggerFinalPath = cms.Path( hltGtDigis + hltScalersRawToDigi + hltFEDSelector + hltTriggerSummaryAOD + hltTriggerSummaryRAW ) HLTAnalyzerEndpath = cms.EndPath( hltL1GtTrigReport + hltTrigReport ) -HLTSchedule = cms.Schedule( *(HLTriggerFirstPath, HLT_AK8PFJet360TrimMod_Mass30_v1, HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1, HLT_BTagCSV07_v1, HLT_CaloJet260_v1, HLT_CaloJet500_NoJetID_v1, HLT_Dimuon13_PsiPrime_v1, HLT_Dimuon13_Upsilon_v1, HLT_Dimuon20_Jpsi_v1, HLT_DoubleEle24_22_eta2p1_WP75_Gsf_v1, HLT_DoubleEle33_CaloIdL_GsfTrkIdVL_MW_v1, HLT_DoubleEle33_CaloIdL_GsfTrkIdVL_v1, HLT_DoubleMediumIsoPFTau40_Trk1_eta2p1_Reg_v1, HLT_DoubleMediumIsoPFTau40_Trk1_eta2p1_v1, HLT_DoubleMu33NoFiltersNoVtx_v1, HLT_DoubleMu38NoFiltersNoVtx_v1, HLT_DoubleMu23NoFiltersNoVtxDisplaced_v1, HLT_DoubleMu28NoFiltersNoVtxDisplaced_v1, HLT_DoubleMu4_3_Bs_v1, HLT_DoubleMu4_3_Jpsi_Displaced_v1, HLT_DoubleMu4_JpsiTrk_Displaced_v1, HLT_DoubleMu4_LowMassNonResonantTrk_Displaced_v1, HLT_DoubleMu4_PsiPrimeTrk_Displaced_v1, HLT_Mu7p5_L2Mu2_Jpsi_v1, HLT_Mu7p5_L2Mu2_Upsilon_v1, HLT_Mu7p5_Track2_Jpsi_v1, HLT_Mu7p5_Track3p5_Jpsi_v1, HLT_Mu7p5_Track7_Jpsi_v1, HLT_Mu7p5_Track2_Upsilon_v1, HLT_Mu7p5_Track3p5_Upsilon_v1, HLT_Mu7p5_Track7_Upsilon_v1, HLT_Dimuon0er16_Jpsi_NoOS_NoVertexing_v1, HLT_Dimuon0er16_Jpsi_NoVertexing_v1, HLT_Dimuon6_Jpsi_NoVertexing_v1, HLT_DoublePhoton85_v1, HLT_Ele17_Ele8_Gsf_v1, HLT_Ele20WP60_Ele8_Mass55_v1, HLT_Ele22_eta2p1_WP75_Gsf_v1, HLT_Ele22_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1, HLT_Ele25WP60_SC4_Mass55_v1, HLT_Ele25_eta2p1_WP85_Gsf_PFMET80_boostedW_v1, HLT_Ele35_eta2p1_WP85_Gsf_v1, HLT_Ele40_eta2p1_WP85_Gsf_v1, HLT_Ele27_WP85_Gsf_v1, HLT_Ele27_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1, HLT_Ele27_eta2p1_WP75_Gsf_DoubleMediumIsoPFTau40_Trk1_eta2p1_Reg_v1, HLT_Ele27_eta2p1_WP75_Gsf_CentralPFJet30_BTagCSV07_v1, HLT_Ele27_eta2p1_WP75_Gsf_TriCentralPFJet30_v1, HLT_Ele27_eta2p1_WP75_Gsf_TriCentralPFJet50_40_30_v1, HLT_Ele27_eta2p1_WP75_Gsf_v1, HLT_Ele32_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1, HLT_Ele32_eta2p1_WP75_Gsf_DoubleMediumIsoPFTau40_Trk1_eta2p1_Reg_v1, HLT_Ele32_eta2p1_WP75_Gsf_CentralPFJet30_BTagCSV07_v1, HLT_Ele32_eta2p1_WP75_Gsf_TriCentralPFJet30_v1, HLT_Ele32_eta2p1_WP75_Gsf_TriCentralPFJet50_40_30_v1, HLT_Ele32_eta2p1_WP75_Gsf_v1, HLT_Ele45_CaloIdVT_GsfTrkIdT_PFJet200_PFJet50_v1, HLT_Ele105_CaloIdVT_GsfTrkIdT_v1, HLT_HT650_v1, HLT_Mu16_eta2p1_CaloMET30_v1, HLT_IsoMu16_eta2p1_CaloMET30_v1, HLT_IsoMu16_eta2p1_CaloMET30_LooseIsoPFTau50_Trk30_eta2p1_v1, HLT_IsoMu17_eta2p1_v1, HLT_IsoMu17_eta2p1_LooseIsoPFTau20_v1, HLT_IsoMu17_eta2p1_LooseIsoPFTau20_SingleL1_v1, HLT_IsoMu17_eta2p1_MediumIsoPFTau40_Trk1_eta2p1_Reg_v1, HLT_DoubleIsoMu17_eta2p1_v1, HLT_IsoMu24_eta2p1_LooseIsoPFTau20_v1, HLT_IsoMu20_eta2p1_CentralPFJet30_BTagCSV07_v1, HLT_IsoMu20_eta2p1_TriCentralPFJet30_v1, HLT_IsoMu20_eta2p1_TriCentralPFJet50_40_30_v1, HLT_IsoMu20_v1, HLT_IsoMu20_eta2p1_v1, HLT_IsoMu24_eta2p1_CentralPFJet30_BTagCSV07_v1, HLT_IsoMu24_eta2p1_TriCentralPFJet30_v1, HLT_IsoMu24_eta2p1_TriCentralPFJet50_40_30_v1, HLT_IsoMu24_eta2p1_v1, HLT_IsoMu27_v1, HLT_IsoTkMu20_v1, HLT_IsoTkMu20_eta2p1_v1, HLT_IsoTkMu24_eta2p1_v1, HLT_IsoTkMu27_v1, HLT_IterativeTracking_v1, HLT_JetE30_NoBPTX3BX_NoHalo_v1, HLT_JetE30_NoBPTX_v1, HLT_JetE50_NoBPTX3BX_NoHalo_v1, HLT_JetE70_NoBPTX3BX_NoHalo_v1, HLT_L2DoubleMu23_NoVertex_v1, HLT_L2DoubleMu28_NoVertex_2Cha_Angle2p5_Mass10_v1, HLT_L2DoubleMu38_NoVertex_2Cha_Angle2p5_Mass10_v1, HLT_L2Mu10_NoVertex_NoBPTX3BX_NoHalo_v1, HLT_L2Mu10_NoVertex_NoBPTX_v1, HLT_L2Mu35_NoVertex_3Sta_NoBPTX3BX_NoHalo_v1, HLT_L2Mu40_NoVertex_3Sta_NoBPTX3BX_NoHalo_v1, HLT_LooseIsoPFTau50_Trk30_eta2p1_v1, HLT_LooseIsoPFTau50_Trk30_eta2p1_MET120_v1, HLT_LooseIsoPFTau50_Trk30_eta2p1_MET80_v1, HLT_Mu17_Mu8_DZ_v1, HLT_Mu17_NoFilters_v1, HLT_Mu17_TkMu8_DZ_v1, HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v1, HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v1, HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_v1, HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_DZ_v1, HLT_Mu25_TkMu0_dEta18_Onia_v1, HLT_Mu27_TkMu8_v1, HLT_Mu30_TkMu11_v1, HLT_Mu40_TkMu11_v1, HLT_Mu40_eta2p1_PFJet200_PFJet50_v1, HLT_Mu20_v1, HLT_TkMu20_v1, HLT_Mu24_eta2p1_v1, HLT_TkMu24_eta2p1_v1, HLT_Mu27_v1, HLT_TkMu27_v1, HLT_Mu50_v1, HLT_Mu45_eta2p1_v1, HLT_Mu38NoFiltersNoVtx_Photon38_CaloIdL_v1, HLT_Mu42NoFiltersNoVtx_Photon42_CaloIdL_v1, HLT_Mu28NoFiltersNoVtxDisplaced_Photon28_CaloIdL_v1, HLT_Mu33NoFiltersNoVtxDisplaced_Photon33_CaloIdL_v1, HLT_PFHT350_PFMET120_NoiseCleaned_v1, HLT_PFHT550_4Jet_v1, HLT_PFHT650_4Jet_v1, HLT_PFHT750_4Jet_v1, HLT_PFHT350_v1, HLT_PFHT600_v1, HLT_PFHT650_v1, HLT_PFHT900_v1, HLT_PFJet40_v1, HLT_PFJet60_v1, HLT_PFJet80_v1, HLT_PFJet140_v1, HLT_PFJet200_v1, HLT_PFJet260_v1, HLT_PFJet320_v1, HLT_PFJet400_v1, HLT_PFJet450_v1, HLT_PFJet500_v1, HLT_DiPFJetAve30_HFJEC_v1, HLT_DiPFJetAve60_HFJEC_v1, HLT_DiPFJetAve80_HFJEC_v1, HLT_DiPFJetAve100_HFJEC_v1, HLT_DiPFJetAve160_HFJEC_v1, HLT_DiPFJetAve220_HFJEC_v1, HLT_DiPFJetAve300_HFJEC_v1, HLT_DiPFJet40_DEta3p5_MJJ600_PFMETNoMu140_v1, HLT_DiPFJet40_DEta3p5_MJJ600_PFMETNoMu80_v1, HLT_DiCentralPFJet70_PFMET120_NoiseCleaned_v1, HLT_HT200_v1, HLT_HT250_v1, HLT_HT300_v1, HLT_HT350_v1, HLT_HT400_v1, HLT_PFHT200_DiPFJet90_PFAlphaT0p57_v1, HLT_PFHT250_DiPFJet90_PFAlphaT0p55_v1, HLT_PFHT300_DiPFJet90_PFAlphaT0p53_v1, HLT_PFHT350_DiPFJet90_PFAlphaT0p52_v1, HLT_PFHT400_DiPFJet90_PFAlphaT0p51_v1, HLT_MET75_IsoTrk50_v1, HLT_MET90_IsoTrk50_v1, HLT_PFMET120_NoiseCleaned_BTagCSV07_v1, HLT_PFMET120_NoiseCleaned_Mu5_v1, HLT_PFMET170_NoiseCleaned_v1, HLT_PFMET90_PFMHT90_IDLoose_v1, HLT_PFMET100_PFMHT100_IDLoose_v1, HLT_PFMET110_PFMHT110_IDLoose_v1, HLT_PFMET120_PFMHT120_IDLoose_v1, HLT_CaloMHTNoPU90_PFMET90_PFMHT90_IDLoose_BTagCSV0p7_v1, HLT_CaloMHTNoPU90_PFMET90_PFMHT90_IDLoose_v1, HLT_QuadPFJet_DoubleBTagCSV_VBF_Mqq200_v1, HLT_QuadPFJet_SingleBTagCSV_VBF_Mqq460_v1, HLT_QuadPFJet_DoubleBTagCSV_VBF_Mqq240_v1, HLT_QuadPFJet_SingleBTagCSV_VBF_Mqq500_v1, HLT_QuadPFJet_VBF_v1, HLT_L1_TripleJet_VBF_v1, HLT_QuadJet45_TripleCSV0p5_v1, HLT_QuadJet45_DoubleCSV0p5_v1, HLT_DoubleJet90_Double30_TripleCSV0p5_v1, HLT_DoubleJet90_Double30_DoubleCSV0p5_v1, HLT_PFchMET90_NoiseCleaned_v1, HLT_Photon135_PFMET100_NoiseCleaned_v1, HLT_Photon20_CaloIdVL_IsoL_v1, HLT_Photon22_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon22_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon250_NoHE_v1, HLT_Photon300_NoHE_v1, HLT_Photon26_R9Id85_OR_CaloId24b40e_Iso50T80L_Photon16_AND_HE10_R9Id65_Eta2_Mass60_v1, HLT_Photon36_R9Id85_OR_CaloId24b40e_Iso50T80L_Photon22_AND_HE10_R9Id65_Eta2_Mass15_v1, HLT_Photon36_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon36_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon50_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon50_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon75_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon75_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon90_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon90_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon120_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon120_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Mu8_TrkIsoVVL_v1, HLT_Mu17_TrkIsoVVL_v1, HLT_Mu24_TrkIsoVVL_v1, HLT_Mu34_TrkIsoVVL_v1, HLT_Ele12_CaloIdL_TrackIdL_IsoVL_PFJet30_v1, HLT_Ele18_CaloIdL_TrackIdL_IsoVL_PFJet30_v1, HLT_Ele23_CaloIdL_TrackIdL_IsoVL_PFJet30_v1, HLT_Ele33_CaloIdL_TrackIdL_IsoVL_PFJet30_v1, HLT_BTagMu_DiJet20_Mu5_v1, HLT_BTagMu_DiJet40_Mu5_v1, HLT_BTagMu_DiJet70_Mu5_v1, HLT_BTagMu_DiJet110_Mu5_v1, HLT_BTagMu_Jet300_Mu5_v1, HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v1, HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v1, HLT_Ele16_Ele12_Ele8_CaloIdL_TrackIdL_v1, HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v1, HLT_Mu8_TrkIsoVVL_Ele17_CaloIdL_TrackIdL_IsoVL_v1, HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_Mu17_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_Mu30_Ele30_CaloIdL_GsfTrkIdVL_v1, HLT_Mu8_DiEle12_CaloIdL_TrackIdL_v1, HLT_Mu12_Photon25_CaloIdL_v1, HLT_Mu12_Photon25_CaloIdL_L1ISO_v1, HLT_Mu12_Photon25_CaloIdL_L1OR_v1, HLT_Mu17_Photon30_CaloIdL_L1ISO_v1, HLT_Mu17_Photon35_CaloIdL_L1ISO_v1, HLT_DiMu9_Ele9_CaloIdL_TrackIdL_v1, HLT_TripleMu_12_10_5_v1, HLT_Mu3er_PFHT140_PFMET125_NoiseCleaned_v1, HLT_Mu6_PFHT200_PFMET100_NoiseCleaned_BTagCSV07_v1, HLT_Mu6_PFHT200_PFMET125_NoiseCleaned_v1, HLT_Mu14er_PFMET120_NoiseCleaned_v1, HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_Ele23_CaloIdL_TrackIdL_IsoVL_v1, HLT_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_AK8DiPFJet280_200_TrimMass30_BTagCSV0p3_v1, HLT_PFHT650_WideJetMJJ900DEtaJJ1p5_v1, HLT_PFHT650_WideJetMJJ950DEtaJJ1p5_v1, HLT_Photon22_v1, HLT_Photon30_v1, HLT_Photon36_v1, HLT_Photon50_v1, HLT_Photon75_v1, HLT_Photon90_v1, HLT_Photon120_v1, HLT_Photon175_v1, HLT_Photon165_HE10_v1, HLT_Photon22_R9Id90_HE10_IsoM_v1, HLT_Photon30_R9Id90_HE10_IsoM_v1, HLT_Photon36_R9Id90_HE10_IsoM_v1, HLT_Photon50_R9Id90_HE10_IsoM_v1, HLT_Photon75_R9Id90_HE10_IsoM_v1, HLT_Photon90_R9Id90_HE10_IsoM_v1, HLT_Photon120_R9Id90_HE10_IsoM_v1, HLT_Photon165_R9Id90_HE10_IsoM_v1, HLT_Diphoton34_18_R9Id85_OR_Iso50T80LCaloId24b40e_AND_HE10P1_R9Id50b80e_Mass95_v1, HLT_Diphoton44_28_R9Id85_OR_Iso50T80LCaloId24b40e_AND_HE10P1_R9Id50b80e_v1, HLT_Diphoton36_18_R9Id85_OR_Iso50T80LCaloId24b40e_AND_HE10P5_R9Id50b80e_Mass70_v1, HLT_Diphoton28_14_R9Id85_OR_Iso50T80LCaloId24b40e_AND_HE10P5_R9Id50b80e_Mass50_Eta_1p5_v1, HLT_Diphoton30_18_R9Id85_AND_Iso50T80LCaloId24b40e_AND_HE10P0_R9Id50b80e_Solid_Mass30_v1, HLT_Diphoton30_18_R9Id85_AND_Iso50T80LCaloId24b40e_AND_HE10P0_R9Id50b80e_PV_v1, HLT_Diphoton30_18_R9Id85_AND_Iso50T80LCaloId24b40e_AND_HE10P0_R9Id50b80e_DoublePV_v1, HLT_Dimuon0_Jpsi_Muon_v1, HLT_Dimuon0_Upsilon_Muon_v1, HLT_QuadMuon0_Dimuon0_Jpsi_v1, HLT_QuadMuon0_Dimuon0_Upsilon_v1, HLT_Mu17_Mu8_SameSign_v1, HLT_Mu17_Mu8_SameSign_DPhi_v1, HLT_RsqMR260_Rsq0p09_MR200_v1, HLT_RsqMR260_Rsq0p09_MR200_4jet_v1, HLT_RsqMR300_Rsq0p09_MR200_v1, HLT_RsqMR300_Rsq0p09_MR200_4jet_v1, HLT_Rsq0p36_v1, HLT_HT750_DisplacedDijet80_Inclusive_v1, HLT_HT650_DisplacedDijet80_Inclusive_v1, HLT_HT350_DisplacedDijet80_Tight_DisplacedTrack_v1, HLT_HT350_DisplacedDijet40_DisplacedTrack_v1, HLT_HT350_DisplacedDijet80_DisplacedTrack_v1, HLT_HT500_DisplacedDijet40_Inclusive_v1, HLT_HT550_DisplacedDijet40_Inclusive_v1, HLT_VBF_DisplacedJet40_DisplacedTrack_v1, HLT_VBF_DisplacedJet40_TightID_DisplacedTrack_v1, HLT_VBF_DisplacedJet40_Hadronic_v1, HLT_VBF_DisplacedJet40_TightID_Hadronic_v1, HLT_MonoCentralPFJet140_PFMETNoMu100_PFMHTNoMu140_NoiseCleaned_v1, HLT_MonoCentralPFJet140_PFMETNoMu140_PFMHTNoMu140_NoiseCleaned_v1, HLT_MonoCentralPFJet150_PFMETNoMu150_PFMHTNoMu150_NoiseCleaned_v1, HLT_Ele27_eta2p1_WP85_Gsf_HT200_v1, HLT_Photon90_CaloIdL_PFHT500_v1, HLT_DoubleMu8_Mass8_PFHT300_v1, HLT_Mu8_Ele8_CaloIdL_TrkIdVL_Mass8_PFHT300_v1, HLT_DoubleEle8_CaloIdL_TrkIdVL_Mass8_PFHT300_v1, HLT_Mu10_CentralPFJet30_BTagCSV0p5PF_v1, HLT_Ele10_CaloIdL_TrackIdVL_CentralPFJet30_BTagCSV0p5PF_v1, HLT_Ele15_IsoVVVL_BTagtop8CSV07_PFHT400_v1, HLT_Ele15_IsoVVVL_PFHT400_PFMET70_v1, HLT_Ele15_IsoVVVL_PFHT600_v1, HLT_Ele15_PFHT300_v1, HLT_Mu15_IsoVVVL_BTagCSV07_PFHT400_v1, HLT_Mu15_IsoVVVL_PFHT400_PFMET70_v1, HLT_Mu15_IsoVVVL_PFHT600_v1, HLT_Mu15_PFHT300_v1, HLT_Dimuon16_Jpsi_v1, HLT_Dimuon10_Jpsi_Barrel_v1, HLT_Dimuon8_PsiPrime_Barrel_v1, HLT_Dimuon8_Upsilon_Barrel_v1, HLT_Dimuon0_Phi_Barrel_v1, HLT_Mu16_TkMu0_dEta18_Onia_v1, HLT_Mu16_TkMu0_dEta18_Phi_v1, HLT_PixelTracks_Multiplicity60_v1, HLT_PixelTracks_Multiplicity85_v1, HLT_PixelTracks_Multiplicity110_v1, HLT_PixelTracks_Multiplicity135_v1, HLT_PixelTracks_Multiplicity160_v1, HLT_ECALHT800_v1, HLT_Physics_v1, HLT_ReducedIterativeTracking_v1, HLT_Random_v1, HLT_ZeroBias_v1, HLTriggerFinalPath, HLTAnalyzerEndpath )) +HLTSchedule = cms.Schedule( *(HLTriggerFirstPath, HLT_AK8PFJet360TrimMod_Mass30_v1, HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1, HLT_BTagCSV07_v1, HLT_CaloJet260_v1, HLT_CaloJet500_NoJetID_v1, HLT_Dimuon13_PsiPrime_v1, HLT_Dimuon13_Upsilon_v1, HLT_Dimuon20_Jpsi_v1, HLT_DoubleEle24_22_eta2p1_WP75_Gsf_v1, HLT_DoubleEle33_CaloIdL_GsfTrkIdVL_MW_v1, HLT_DoubleEle33_CaloIdL_GsfTrkIdVL_v1, HLT_DoubleMediumIsoPFTau40_Trk1_eta2p1_Reg_v1, HLT_DoubleMediumIsoPFTau40_Trk1_eta2p1_v1, HLT_DoubleMu33NoFiltersNoVtx_v1, HLT_DoubleMu38NoFiltersNoVtx_v1, HLT_DoubleMu23NoFiltersNoVtxDisplaced_v1, HLT_DoubleMu28NoFiltersNoVtxDisplaced_v1, HLT_DoubleMu4_3_Bs_v1, HLT_DoubleMu4_3_Jpsi_Displaced_v1, HLT_DoubleMu4_JpsiTrk_Displaced_v1, HLT_DoubleMu4_LowMassNonResonantTrk_Displaced_v1, HLT_DoubleMu4_PsiPrimeTrk_Displaced_v1, HLT_Mu7p5_L2Mu2_Jpsi_v1, HLT_Mu7p5_L2Mu2_Upsilon_v1, HLT_Mu7p5_Track2_Jpsi_v1, HLT_Mu7p5_Track3p5_Jpsi_v1, HLT_Mu7p5_Track7_Jpsi_v1, HLT_Mu7p5_Track2_Upsilon_v1, HLT_Mu7p5_Track3p5_Upsilon_v1, HLT_Mu7p5_Track7_Upsilon_v1, HLT_Dimuon0er16_Jpsi_NoOS_NoVertexing_v1, HLT_Dimuon0er16_Jpsi_NoVertexing_v1, HLT_Dimuon6_Jpsi_NoVertexing_v1, HLT_DoublePhoton85_v1, HLT_Ele17_Ele8_Gsf_v1, HLT_Ele20WP60_Ele8_Mass55_v1, HLT_Ele22_eta2p1_WP75_Gsf_v1, HLT_Ele22_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1, HLT_Ele25WP60_SC4_Mass55_v1, HLT_Ele25_eta2p1_WP85_Gsf_PFMET80_boostedW_v1, HLT_Ele35_eta2p1_WP85_Gsf_v1, HLT_Ele40_eta2p1_WP85_Gsf_v1, HLT_Ele27_WP85_Gsf_v1, HLT_Ele27_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1, HLT_Ele27_eta2p1_WP75_Gsf_DoubleMediumIsoPFTau40_Trk1_eta2p1_Reg_v1, HLT_Ele27_eta2p1_WP75_Gsf_CentralPFJet30_BTagCSV07_v1, HLT_Ele27_eta2p1_WP75_Gsf_TriCentralPFJet30_v1, HLT_Ele27_eta2p1_WP75_Gsf_TriCentralPFJet50_40_30_v1, HLT_Ele27_eta2p1_WP75_Gsf_v1, HLT_Ele32_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1, HLT_Ele32_eta2p1_WP75_Gsf_DoubleMediumIsoPFTau40_Trk1_eta2p1_Reg_v1, HLT_Ele32_eta2p1_WP75_Gsf_CentralPFJet30_BTagCSV07_v1, HLT_Ele32_eta2p1_WP75_Gsf_TriCentralPFJet30_v1, HLT_Ele32_eta2p1_WP75_Gsf_TriCentralPFJet50_40_30_v1, HLT_Ele32_eta2p1_WP75_Gsf_v1, HLT_Ele45_CaloIdVT_GsfTrkIdT_PFJet200_PFJet50_v1, HLT_Ele105_CaloIdVT_GsfTrkIdT_v1, HLT_HT650_v1, HLT_Mu16_eta2p1_CaloMET30_v1, HLT_IsoMu16_eta2p1_CaloMET30_v1, HLT_IsoMu16_eta2p1_CaloMET30_LooseIsoPFTau50_Trk30_eta2p1_v1, HLT_IsoMu17_eta2p1_v1, HLT_IsoMu17_eta2p1_LooseIsoPFTau20_v1, HLT_IsoMu17_eta2p1_LooseIsoPFTau20_SingleL1_v1, HLT_IsoMu17_eta2p1_MediumIsoPFTau40_Trk1_eta2p1_Reg_v1, HLT_DoubleIsoMu17_eta2p1_v1, HLT_IsoMu24_eta2p1_LooseIsoPFTau20_v1, HLT_IsoMu20_eta2p1_CentralPFJet30_BTagCSV07_v1, HLT_IsoMu20_eta2p1_TriCentralPFJet30_v1, HLT_IsoMu20_eta2p1_TriCentralPFJet50_40_30_v1, HLT_IsoMu20_v1, HLT_IsoMu20_eta2p1_v1, HLT_IsoMu24_eta2p1_CentralPFJet30_BTagCSV07_v1, HLT_IsoMu24_eta2p1_TriCentralPFJet30_v1, HLT_IsoMu24_eta2p1_TriCentralPFJet50_40_30_v1, HLT_IsoMu24_eta2p1_v1, HLT_IsoMu27_v1, HLT_IsoTkMu20_v1, HLT_IsoTkMu20_eta2p1_v1, HLT_IsoTkMu24_eta2p1_v1, HLT_IsoTkMu27_v1, HLT_IterativeTracking_v1, HLT_JetE30_NoBPTX3BX_NoHalo_v1, HLT_JetE30_NoBPTX_v1, HLT_JetE50_NoBPTX3BX_NoHalo_v1, HLT_JetE70_NoBPTX3BX_NoHalo_v1, HLT_L2DoubleMu23_NoVertex_v1, HLT_L2DoubleMu28_NoVertex_2Cha_Angle2p5_Mass10_v1, HLT_L2DoubleMu38_NoVertex_2Cha_Angle2p5_Mass10_v1, HLT_L2Mu10_NoVertex_NoBPTX3BX_NoHalo_v1, HLT_L2Mu10_NoVertex_NoBPTX_v1, HLT_L2Mu35_NoVertex_3Sta_NoBPTX3BX_NoHalo_v1, HLT_L2Mu40_NoVertex_3Sta_NoBPTX3BX_NoHalo_v1, HLT_LooseIsoPFTau50_Trk30_eta2p1_v1, HLT_LooseIsoPFTau50_Trk30_eta2p1_MET120_v1, HLT_LooseIsoPFTau50_Trk30_eta2p1_MET80_v1, HLT_Mu17_Mu8_DZ_v1, HLT_Mu17_NoFilters_v1, HLT_Mu17_TkMu8_DZ_v1, HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v1, HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v1, HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_v1, HLT_Mu17_TrkIsoVVL_TkMu8_TrkIsoVVL_DZ_v1, HLT_Mu25_TkMu0_dEta18_Onia_v1, HLT_Mu27_TkMu8_v1, HLT_Mu30_TkMu11_v1, HLT_Mu40_TkMu11_v1, HLT_Mu40_eta2p1_PFJet200_PFJet50_v1, HLT_Mu20_v1, HLT_TkMu20_v1, HLT_Mu24_eta2p1_v1, HLT_TkMu24_eta2p1_v1, HLT_Mu27_v1, HLT_TkMu27_v1, HLT_Mu50_v1, HLT_Mu45_eta2p1_v1, HLT_Mu38NoFiltersNoVtx_Photon38_CaloIdL_v1, HLT_Mu42NoFiltersNoVtx_Photon42_CaloIdL_v1, HLT_Mu28NoFiltersNoVtxDisplaced_Photon28_CaloIdL_v1, HLT_Mu33NoFiltersNoVtxDisplaced_Photon33_CaloIdL_v1, HLT_PFHT350_PFMET120_NoiseCleaned_v1, HLT_PFHT550_4Jet_v1, HLT_PFHT650_4Jet_v1, HLT_PFHT750_4Jet_v1, HLT_PFHT350_v1, HLT_PFHT600_v1, HLT_PFHT650_v1, HLT_PFHT900_v1, HLT_PFJet40_v1, HLT_PFJet60_v1, HLT_PFJet80_v1, HLT_PFJet140_v1, HLT_PFJet200_v1, HLT_PFJet260_v1, HLT_PFJet320_v1, HLT_PFJet400_v1, HLT_PFJet450_v1, HLT_PFJet500_v1, HLT_DiPFJetAve30_HFJEC_v1, HLT_DiPFJetAve60_HFJEC_v1, HLT_DiPFJetAve80_HFJEC_v1, HLT_DiPFJetAve100_HFJEC_v1, HLT_DiPFJetAve160_HFJEC_v1, HLT_DiPFJetAve220_HFJEC_v1, HLT_DiPFJetAve300_HFJEC_v1, HLT_DiPFJet40_DEta3p5_MJJ600_PFMETNoMu140_v1, HLT_DiPFJet40_DEta3p5_MJJ600_PFMETNoMu80_v1, HLT_DiCentralPFJet70_PFMET120_NoiseCleaned_v1, HLT_HT200_v1, HLT_HT250_v1, HLT_HT300_v1, HLT_HT350_v1, HLT_HT400_v1, HLT_PFHT200_DiPFJet90_PFAlphaT0p57_v1, HLT_PFHT250_DiPFJet90_PFAlphaT0p55_v1, HLT_PFHT300_DiPFJet90_PFAlphaT0p53_v1, HLT_PFHT350_DiPFJet90_PFAlphaT0p52_v1, HLT_PFHT400_DiPFJet90_PFAlphaT0p51_v1, HLT_MET75_IsoTrk50_v1, HLT_MET90_IsoTrk50_v1, HLT_PFMET120_NoiseCleaned_BTagCSV07_v1, HLT_PFMET120_NoiseCleaned_Mu5_v1, HLT_PFMET170_NoiseCleaned_v1, HLT_PFMET90_PFMHT90_IDLoose_v1, HLT_PFMET100_PFMHT100_IDLoose_v1, HLT_PFMET110_PFMHT110_IDLoose_v1, HLT_PFMET120_PFMHT120_IDLoose_v1, HLT_CaloMHTNoPU90_PFMET90_PFMHT90_IDLoose_BTagCSV0p7_v1, HLT_CaloMHTNoPU90_PFMET90_PFMHT90_IDLoose_v1, HLT_QuadPFJet_DoubleBTagCSV_VBF_Mqq200_v1, HLT_QuadPFJet_SingleBTagCSV_VBF_Mqq460_v1, HLT_QuadPFJet_DoubleBTagCSV_VBF_Mqq240_v1, HLT_QuadPFJet_SingleBTagCSV_VBF_Mqq500_v1, HLT_QuadPFJet_VBF_v1, HLT_L1_TripleJet_VBF_v1, HLT_QuadJet45_TripleCSV0p5_v1, HLT_QuadJet45_DoubleCSV0p5_v1, HLT_DoubleJet90_Double30_TripleCSV0p5_v1, HLT_DoubleJet90_Double30_DoubleCSV0p5_v1, HLT_PFchMET90_NoiseCleaned_v1, HLT_Photon135_PFMET100_NoiseCleaned_v1, HLT_Photon20_CaloIdVL_IsoL_v1, HLT_Photon22_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon22_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon250_NoHE_v1, HLT_Photon300_NoHE_v1, HLT_Photon26_R9Id85_OR_CaloId24b40e_Iso50T80L_Photon16_AND_HE10_R9Id65_Eta2_Mass60_v1, HLT_Photon36_R9Id85_OR_CaloId24b40e_Iso50T80L_Photon22_AND_HE10_R9Id65_Eta2_Mass15_v1, HLT_Photon36_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon36_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon50_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon50_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon75_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon75_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon90_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon90_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Photon120_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1, HLT_Photon120_R9Id90_HE10_Iso40_EBOnly_VBF_v1, HLT_Mu8_TrkIsoVVL_v1, HLT_Mu17_TrkIsoVVL_v1, HLT_Mu24_TrkIsoVVL_v1, HLT_Mu34_TrkIsoVVL_v1, HLT_Ele12_CaloIdL_TrackIdL_IsoVL_PFJet30_v1, HLT_Ele18_CaloIdL_TrackIdL_IsoVL_PFJet30_v1, HLT_Ele23_CaloIdL_TrackIdL_IsoVL_PFJet30_v1, HLT_Ele33_CaloIdL_TrackIdL_IsoVL_PFJet30_v1, HLT_BTagMu_DiJet20_Mu5_v1, HLT_BTagMu_DiJet40_Mu5_v1, HLT_BTagMu_DiJet70_Mu5_v1, HLT_BTagMu_DiJet110_Mu5_v1, HLT_BTagMu_Jet300_Mu5_v1, HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v1, HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v1, HLT_Ele16_Ele12_Ele8_CaloIdL_TrackIdL_v1, HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v1, HLT_Mu8_TrkIsoVVL_Ele17_CaloIdL_TrackIdL_IsoVL_v1, HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_Mu17_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_Mu30_Ele30_CaloIdL_GsfTrkIdVL_v1, HLT_Mu8_DiEle12_CaloIdL_TrackIdL_v1, HLT_Mu12_Photon25_CaloIdL_v1, HLT_Mu12_Photon25_CaloIdL_L1ISO_v1, HLT_Mu12_Photon25_CaloIdL_L1OR_v1, HLT_Mu17_Photon30_CaloIdL_L1ISO_v1, HLT_Mu17_Photon35_CaloIdL_L1ISO_v1, HLT_DiMu9_Ele9_CaloIdL_TrackIdL_v1, HLT_TripleMu_12_10_5_v1, HLT_Mu3er_PFHT140_PFMET125_NoiseCleaned_v1, HLT_Mu6_PFHT200_PFMET100_NoiseCleaned_BTagCSV07_v1, HLT_Mu6_PFHT200_PFMET125_NoiseCleaned_v1, HLT_Mu14er_PFMET120_NoiseCleaned_v1, HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_Ele23_CaloIdL_TrackIdL_IsoVL_v1, HLT_Ele12_CaloIdL_TrackIdL_IsoVL_v1, HLT_AK8DiPFJet280_200_TrimMass30_BTagCSV0p3_v1, HLT_PFHT650_WideJetMJJ900DEtaJJ1p5_v1, HLT_PFHT650_WideJetMJJ950DEtaJJ1p5_v1, HLT_Photon22_v1, HLT_Photon30_v1, HLT_Photon36_v1, HLT_Photon50_v1, HLT_Photon75_v1, HLT_Photon90_v1, HLT_Photon120_v1, HLT_Photon175_v1, HLT_Photon165_HE10_v1, HLT_Photon22_R9Id90_HE10_IsoM_v1, HLT_Photon30_R9Id90_HE10_IsoM_v1, HLT_Photon36_R9Id90_HE10_IsoM_v1, HLT_Photon50_R9Id90_HE10_IsoM_v1, HLT_Photon75_R9Id90_HE10_IsoM_v1, HLT_Photon90_R9Id90_HE10_IsoM_v1, HLT_Photon120_R9Id90_HE10_IsoM_v1, HLT_Photon165_R9Id90_HE10_IsoM_v1, HLT_Diphoton34_18_R9Id85_OR_Iso50T80LCaloId24b40e_AND_HE10P1_R9Id50b80e_Mass95_v1, HLT_Diphoton44_28_R9Id85_OR_Iso50T80LCaloId24b40e_AND_HE10P1_R9Id50b80e_v1, HLT_Diphoton36_18_R9Id85_OR_Iso50T80LCaloId24b40e_AND_HE10P5_R9Id50b80e_Mass70_v1, HLT_Diphoton28_14_R9Id85_OR_Iso50T80LCaloId24b40e_AND_HE10P5_R9Id50b80e_Mass50_Eta_1p5_v1, HLT_Diphoton30_18_R9Id85_AND_Iso50T80LCaloId24b40e_AND_HE10P0_R9Id50b80e_Solid_Mass30_v1, HLT_Diphoton30_18_R9Id85_AND_Iso50T80LCaloId24b40e_AND_HE10P0_R9Id50b80e_PV_v1, HLT_Diphoton30_18_R9Id85_AND_Iso50T80LCaloId24b40e_AND_HE10P0_R9Id50b80e_DoublePV_v1, HLT_Dimuon0_Jpsi_Muon_v1, HLT_Dimuon0_Upsilon_Muon_v1, HLT_QuadMuon0_Dimuon0_Jpsi_v1, HLT_QuadMuon0_Dimuon0_Upsilon_v1, HLT_Mu17_Mu8_SameSign_v1, HLT_Mu17_Mu8_SameSign_DPhi_v1, HLT_RsqMR260_Rsq0p09_MR200_v1, HLT_RsqMR260_Rsq0p09_MR200_4jet_v1, HLT_RsqMR300_Rsq0p09_MR200_v1, HLT_RsqMR300_Rsq0p09_MR200_4jet_v1, HLT_Rsq0p36_v1, HLT_HT750_DisplacedDijet80_Inclusive_v1, HLT_HT650_DisplacedDijet80_Inclusive_v1, HLT_HT350_DisplacedDijet80_Tight_DisplacedTrack_v1, HLT_HT350_DisplacedDijet40_DisplacedTrack_v1, HLT_HT350_DisplacedDijet80_DisplacedTrack_v1, HLT_HT500_DisplacedDijet40_Inclusive_v1, HLT_HT550_DisplacedDijet40_Inclusive_v1, HLT_VBF_DisplacedJet40_DisplacedTrack_v1, HLT_VBF_DisplacedJet40_TightID_DisplacedTrack_v1, HLT_VBF_DisplacedJet40_Hadronic_v1, HLT_VBF_DisplacedJet40_TightID_Hadronic_v1, HLT_MonoCentralPFJet140_PFMETNoMu100_PFMHTNoMu140_NoiseCleaned_v1, HLT_MonoCentralPFJet140_PFMETNoMu140_PFMHTNoMu140_NoiseCleaned_v1, HLT_MonoCentralPFJet150_PFMETNoMu150_PFMHTNoMu150_NoiseCleaned_v1, HLT_Ele27_eta2p1_WP85_Gsf_HT200_v1, HLT_Photon90_CaloIdL_PFHT500_v1, HLT_DoubleMu8_Mass8_PFHT300_v1, HLT_Mu8_Ele8_CaloIdL_TrkIdVL_Mass8_PFHT300_v1, HLT_DoubleEle8_CaloIdL_TrkIdVL_Mass8_PFHT300_v1, HLT_Mu10_CentralPFJet30_BTagCSV0p5PF_v1, HLT_Ele10_CaloIdL_TrackIdVL_CentralPFJet30_BTagCSV0p5PF_v1, HLT_Ele15_IsoVVVL_BTagtop8CSV07_PFHT400_v1, HLT_Ele15_IsoVVVL_PFHT400_PFMET70_v1, HLT_Ele15_IsoVVVL_PFHT600_v1, HLT_Ele15_PFHT300_v1, HLT_Mu15_IsoVVVL_BTagCSV07_PFHT400_v1, HLT_Mu15_IsoVVVL_PFHT400_PFMET70_v1, HLT_Mu15_IsoVVVL_PFHT600_v1, HLT_Mu15_PFHT300_v1, HLT_Dimuon16_Jpsi_v1, HLT_Dimuon10_Jpsi_Barrel_v1, HLT_Dimuon8_PsiPrime_Barrel_v1, HLT_Dimuon8_Upsilon_Barrel_v1, HLT_Dimuon0_Phi_Barrel_v1, HLT_Mu16_TkMu0_dEta18_Onia_v1, HLT_Mu16_TkMu0_dEta18_Phi_v1, HLT_PixelTracks_Multiplicity60_v1, HLT_PixelTracks_Multiplicity85_v1, HLT_PixelTracks_Multiplicity110_v1, HLT_PixelTracks_Multiplicity135_v1, HLT_PixelTracks_Multiplicity160_v1, HLT_ECALHT800_v1, HLT_Physics_v1, HLT_ReducedIterativeTracking_v1, HLT_Random_v1, HLT_ZeroBias_v1, HLT_HIL1DoubleMu0_HighQ_v1, HLT_HIL2Mu3_v1, HLT_HIL2Mu7_v1, HLT_HIL2Mu15_v1, HLT_HIL2Mu3_NHitQ_v1, HLT_HIL2DoubleMu0_v1, HLT_HIL2DoubleMu0_NHitQ_v1, HLT_HIL2DoubleMu3_v1, HLT_HIL3Mu3_v1, HLT_HIL3DoubleMuOpen_v1, HLT_HIL3DoubleMuOpen_SS_v1, HLT_HIL3DoubleMuOpen_OS_v1, HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1, HLTriggerFinalPath, HLTAnalyzerEndpath )) diff --git a/HLTrigger/Configuration/python/HLT_GRun_Famos_cff.py b/HLTrigger/Configuration/python/HLT_GRun_Famos_cff.py index c0778df53d829..98ae64d521865 100644 --- a/HLTrigger/Configuration/python/HLT_GRun_Famos_cff.py +++ b/HLTrigger/Configuration/python/HLT_GRun_Famos_cff.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/GRun/V4 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/GRun/V5 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms from FastSimulation.HighLevelTrigger.HLTSetup_cff import * HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V4') + tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V5') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -8615,8 +8615,8 @@ reqOppCharge = cms.untracked.bool( False ), nZcandcut = cms.int32( 1 ) ) -hltL1sL1SingleIsoEG18 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG18" ), +hltL1sL1SingleIsoEG20er = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG20er" ), saveTags = cms.bool( True ), L1MuonCollectionTag = cms.InputTag( "l1extraParticles" ), L1UseL1TriggerObjectMaps = cms.bool( True ), @@ -8631,7 +8631,7 @@ L1GtReadoutRecordTag = cms.InputTag( "simGtDigis" ), offset = cms.uint32( 0 ) ) -hltEGL1SingleIsoEG18erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", +hltEGL1SingleIsoEG20erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", doIsolated = cms.bool( False ), endcap_end = cms.double( 2.17 ), saveTags = cms.bool( False ), @@ -8641,7 +8641,7 @@ candIsolatedTag = cms.InputTag( "hltEgammaCandidates" ), region_phi_size = cms.double( 1.044 ), region_eta_size = cms.double( 0.522 ), - L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG18" ), + L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG20er" ), candNonIsolatedTag = cms.InputTag( "" ), l1NonIsolatedTag = cms.InputTag( 'l1extraParticles','NonIsolated' ), ncandcut = cms.int32( 1 ) @@ -8651,7 +8651,7 @@ L1NonIsoCand = cms.InputTag( "" ), relaxed = cms.untracked.bool( False ), L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - inputTag = cms.InputTag( "hltEGL1SingleIsoEG18erFilter" ), + inputTag = cms.InputTag( "hltEGL1SingleIsoEG20erFilter" ), etcutEB = cms.double( 22.0 ), etcutEE = cms.double( 22.0 ), ncandcut = cms.int32( 1 ) @@ -28254,7 +28254,7 @@ tanhSO10ForwardThres = cms.double( 1.0 ), L1IsoPixelSeedsTag = cms.InputTag( "hltEgammaElectronPixelSeedsUnseeded" ), L1NonIsoCand = cms.InputTag( "" ), - ncandcut = cms.int32( 1 ), + ncandcut = cms.int32( 2 ), tanhSO10BarrelThres = cms.double( 0.35 ), s_a_rF = cms.double( 0.04 ), L1NonIsoPixelSeedsTag = cms.InputTag( "" ), @@ -31325,7 +31325,7 @@ HLTTrackReconstructionIter02 = cms.Sequence( HLTPixelTrackingL3Muon + HLTDoLocalStripSequence + HLTIterativeTrackingL3MuonIter02 ) HLTDoublePho85Sequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleEG40ORL1SingleEG35Filter + hltEG85EtFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEG85HEFilter + HLTPFClusteringForEgammaUnseeded + hltEgammaCandidatesUnseeded + hltEgammaCandidatesWrapperUnseeded + hltDiEG85EtUnseededFilter + hltEgammaHoverEUnseeded + hltDiEG85HEUnseededFilter ) HLTEle20WP60Ele8Mass55Sequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleEG20Filter + hltEle20WP60Ele8EtFilter + hltEgammaClusterShape + hltEle20WP60Ele8ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEle20WP60Ele8HEFilter + hltEgammaEcalPFClusterIso + hltEle20WP60Ele8EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltEle20WP60Ele8HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltEle20WP60Ele8PixelMatchFilter + HLTGsfElectronSequence + hltEle20WP60Ele8OneOEMinusOneOPFilter + hltEle20WP60Ele8DetaFilter + hltEle20WP60Ele8DphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltEle20WP60Ele8TrackIsoFilter + HLTPFClusteringForEgammaUnseeded + hltEgammaCandidatesUnseeded + hltEgammaCandidatesWrapperUnseeded + hltEle20WP60Ele8EtUnseededFilter + HLTElePixelMatchUnseededSequence + hltEle20WP60Ele8PixelMatchUnseededFilter + hltEle20WP60Ele8Mass55Filter ) -HLTSingleEle22erWP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleIsoEG18erFilter + hltSingleEG22EtFilter + hltEgammaClusterShape + hltSingleEle22WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltSingleEle22WP75HcEFilter + hltEgammaEcalPFClusterIso + hltSingleEle22WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltSingleEle22WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltSingleEle22WP75PixelMatchFilter + HLTGsfElectronSequence + hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + hltSingleEle22WP75GsfChi2Filter + hltSingleEle22WP75GsfDetaFilter + hltSingleEle22WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltSingleEle22WP75GsfTrackIsoFilter ) +HLTSingleEle22erWP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleIsoEG20erFilter + hltSingleEG22EtFilter + hltEgammaClusterShape + hltSingleEle22WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltSingleEle22WP75HcEFilter + hltEgammaEcalPFClusterIso + hltSingleEle22WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltSingleEle22WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltSingleEle22WP75PixelMatchFilter + HLTGsfElectronSequence + hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + hltSingleEle22WP75GsfChi2Filter + hltSingleEle22WP75GsfDetaFilter + hltSingleEle22WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltSingleEle22WP75GsfTrackIsoFilter ) HLTEle22WP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGRegionalL1IsoEG20erTauJet20er + hltEG22L1sIsoEG20erTauJet20erEtFilter + hltEgammaClusterShape + hltEle22WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEle22WP75HcEFilter + hltEgammaEcalPFClusterIso + hltEle22WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltEle22WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltEle22WP75PixelMatchFilter + HLTGsfElectronSequence + hltEle22WP75GsfOneOESuperMinusOneOPFilter + hltEle22WP75GsfChi2Filter + hltEle22WP75GsfDetaFilter + hltEle22WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltEle22WP75GsfTrackIsoFilter ) HLTParticleFlowSequenceForTaus = cms.Sequence( HLTPreshowerSequence + hltParticleFlowRecHitECALUnseeded + hltParticleFlowRecHitHCAL + hltParticleFlowRecHitPSUnseeded + hltParticleFlowClusterECALUncorrectedUnseeded + hltParticleFlowClusterPSUnseeded + hltParticleFlowClusterECALUnseeded + hltParticleFlowClusterHCAL + hltParticleFlowClusterHFEM + hltParticleFlowClusterHFHAD + hltLightPFTracks + hltParticleFlowBlockForTaus + hltParticleFlowForTaus ) HLTPFTriggerSequenceForTaus = cms.Sequence( HLTL2muonrecoSequence + HLTL3muonrecoSequence + HLTTrackReconstructionForPF + HLTParticleFlowSequenceForTaus + hltAK4PFJetsForTaus ) @@ -31505,7 +31505,7 @@ HLT_Dimuon6_Jpsi_NoVertexing_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMu0 + hltPreDimuon6JpsiNoVertexing + hltL1fL1DoubleMu0L1Filtered0 + HLTL2muonrecoSequence + hltL2fDoubleMu2L2PreFiltered2 + HLTL3muonrecoSequence + hltDimuon6JpsiL3Filtered + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_DoublePhoton85_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG40ORL1SingleEG35 + hltPreDoublePhoton85 + HLTDoublePho85Sequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_Ele20WP60_Ele8_Mass55_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG20 + hltPreEle20WP60Ele8Mass55 + HLTEle20WP60Ele8Mass55Sequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) -HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleIsoEG18 + hltPreEle22eta2p1WP75Gsf + HLTSingleEle22erWP75GsfSequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) +HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleIsoEG20er + hltPreEle22eta2p1WP75Gsf + HLTSingleEle22erWP75GsfSequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_Ele22_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1 = cms.Path( HLTBeginSequence + hltL1sL1IsoEG20erTauJet20er + hltPreEle22eta2p1WP75GsfLooseIsoPFTau20 + HLTEle22WP75GsfSequence + HLTRecoJetSequenceAK4PrePF + hltTauJet5 + hltOverlapFilterIsoEle22WP75GsfCaloJet5 + HLTPFTriggerSequenceForTaus + HLTIsoEle22WP75GsfLooseIsoPFTau20Sequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_Ele25WP60_SC4_Mass55_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG20 + hltPreEle25WP60SC4Mass55 + HLTEle25WP60SC4Mass55Sequence + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_Ele25_eta2p1_WP85_Gsf_PFMET80_boostedW_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG40ORL1SingleIsoEG30erORL1ETM70 + hltPreEle25eta2p1WP85GsfPFMET80boostedW + HLTEle25WP85GsfSequence + HLTAK4PFJetsSequence + hltPFMETProducer + hltPFMET80Filter + cms.SequencePlaceholder( "HLTEndSequence" ) ) diff --git a/HLTrigger/Configuration/python/HLT_GRun_cff.py b/HLTrigger/Configuration/python/HLT_GRun_cff.py index 6b7d21c3c22eb..c7e26b8a291bc 100644 --- a/HLTrigger/Configuration/python/HLT_GRun_cff.py +++ b/HLTrigger/Configuration/python/HLT_GRun_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_4_0/GRun/V4 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/GRun/V5 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V4') + tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V5') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -15546,8 +15546,8 @@ reqOppCharge = cms.untracked.bool( False ), nZcandcut = cms.int32( 1 ) ) -hltL1sL1SingleIsoEG18 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG18" ), +hltL1sL1SingleIsoEG20er = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG20er" ), saveTags = cms.bool( True ), L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), L1UseL1TriggerObjectMaps = cms.bool( True ), @@ -15562,7 +15562,7 @@ L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) -hltEGL1SingleIsoEG18erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", +hltEGL1SingleIsoEG20erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", doIsolated = cms.bool( False ), endcap_end = cms.double( 2.17 ), saveTags = cms.bool( False ), @@ -15572,7 +15572,7 @@ candIsolatedTag = cms.InputTag( "hltEgammaCandidates" ), region_phi_size = cms.double( 1.044 ), region_eta_size = cms.double( 0.522 ), - L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG18" ), + L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG20er" ), candNonIsolatedTag = cms.InputTag( "" ), l1NonIsolatedTag = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), ncandcut = cms.int32( 1 ) @@ -15582,7 +15582,7 @@ L1NonIsoCand = cms.InputTag( "" ), relaxed = cms.untracked.bool( False ), L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - inputTag = cms.InputTag( "hltEGL1SingleIsoEG18erFilter" ), + inputTag = cms.InputTag( "hltEGL1SingleIsoEG20erFilter" ), etcutEB = cms.double( 22.0 ), etcutEE = cms.double( 22.0 ), ncandcut = cms.int32( 1 ) @@ -39205,7 +39205,7 @@ tanhSO10ForwardThres = cms.double( 1.0 ), L1IsoPixelSeedsTag = cms.InputTag( "hltEgammaElectronPixelSeedsUnseeded" ), L1NonIsoCand = cms.InputTag( "" ), - ncandcut = cms.int32( 1 ), + ncandcut = cms.int32( 2 ), tanhSO10BarrelThres = cms.double( 0.35 ), s_a_rF = cms.double( 0.04 ), L1NonIsoPixelSeedsTag = cms.InputTag( "" ), @@ -43193,7 +43193,7 @@ HLTTrackReconstructionIter02 = cms.Sequence( HLTPixelTrackingL3Muon + HLTDoLocalStripSequence + HLTIterativeTrackingL3MuonIter02 ) HLTDoublePho85Sequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleEG40ORL1SingleEG35Filter + hltEG85EtFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEG85HEFilter + HLTPFClusteringForEgammaUnseeded + hltEgammaCandidatesUnseeded + hltEgammaCandidatesWrapperUnseeded + hltDiEG85EtUnseededFilter + hltEgammaHoverEUnseeded + hltDiEG85HEUnseededFilter ) HLTEle20WP60Ele8Mass55Sequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleEG20Filter + hltEle20WP60Ele8EtFilter + hltEgammaClusterShape + hltEle20WP60Ele8ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEle20WP60Ele8HEFilter + hltEgammaEcalPFClusterIso + hltEle20WP60Ele8EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltEle20WP60Ele8HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltEle20WP60Ele8PixelMatchFilter + HLTGsfElectronSequence + hltEle20WP60Ele8OneOEMinusOneOPFilter + hltEle20WP60Ele8DetaFilter + hltEle20WP60Ele8DphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltEle20WP60Ele8TrackIsoFilter + HLTPFClusteringForEgammaUnseeded + hltEgammaCandidatesUnseeded + hltEgammaCandidatesWrapperUnseeded + hltEle20WP60Ele8EtUnseededFilter + HLTElePixelMatchUnseededSequence + hltEle20WP60Ele8PixelMatchUnseededFilter + hltEle20WP60Ele8Mass55Filter ) -HLTSingleEle22erWP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleIsoEG18erFilter + hltSingleEG22EtFilter + hltEgammaClusterShape + hltSingleEle22WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltSingleEle22WP75HcEFilter + hltEgammaEcalPFClusterIso + hltSingleEle22WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltSingleEle22WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltSingleEle22WP75PixelMatchFilter + HLTGsfElectronSequence + hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + hltSingleEle22WP75GsfChi2Filter + hltSingleEle22WP75GsfDetaFilter + hltSingleEle22WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltSingleEle22WP75GsfTrackIsoFilter ) +HLTSingleEle22erWP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleIsoEG20erFilter + hltSingleEG22EtFilter + hltEgammaClusterShape + hltSingleEle22WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltSingleEle22WP75HcEFilter + hltEgammaEcalPFClusterIso + hltSingleEle22WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltSingleEle22WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltSingleEle22WP75PixelMatchFilter + HLTGsfElectronSequence + hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + hltSingleEle22WP75GsfChi2Filter + hltSingleEle22WP75GsfDetaFilter + hltSingleEle22WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltSingleEle22WP75GsfTrackIsoFilter ) HLTEle22WP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGRegionalL1IsoEG20erTauJet20er + hltEG22L1sIsoEG20erTauJet20erEtFilter + hltEgammaClusterShape + hltEle22WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEle22WP75HcEFilter + hltEgammaEcalPFClusterIso + hltEle22WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltEle22WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltEle22WP75PixelMatchFilter + HLTGsfElectronSequence + hltEle22WP75GsfOneOESuperMinusOneOPFilter + hltEle22WP75GsfChi2Filter + hltEle22WP75GsfDetaFilter + hltEle22WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltEle22WP75GsfTrackIsoFilter ) HLTParticleFlowSequenceForTaus = cms.Sequence( HLTPreshowerSequence + hltParticleFlowRecHitECALUnseeded + hltParticleFlowRecHitHCAL + hltParticleFlowRecHitPSUnseeded + hltParticleFlowClusterECALUncorrectedUnseeded + hltParticleFlowClusterPSUnseeded + hltParticleFlowClusterECALUnseeded + hltParticleFlowClusterHCAL + hltParticleFlowClusterHFEM + hltParticleFlowClusterHFHAD + hltLightPFTracks + hltParticleFlowBlockForTaus + hltParticleFlowForTaus ) HLTPFTriggerSequenceForTaus = cms.Sequence( HLTL2muonrecoSequence + HLTL3muonrecoSequence + HLTTrackReconstructionForPF + HLTParticleFlowSequenceForTaus + hltAK4PFJetsForTaus ) @@ -43421,7 +43421,7 @@ HLT_Dimuon6_Jpsi_NoVertexing_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMu0 + hltPreDimuon6JpsiNoVertexing + hltL1fL1DoubleMu0L1Filtered0 + HLTL2muonrecoSequence + hltL2fDoubleMu2L2PreFiltered2 + HLTL3muonrecoSequence + hltDimuon6JpsiL3Filtered + HLTEndSequence ) HLT_DoublePhoton85_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG40ORL1SingleEG35 + hltPreDoublePhoton85 + HLTDoublePho85Sequence + HLTEndSequence ) HLT_Ele20WP60_Ele8_Mass55_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG20 + hltPreEle20WP60Ele8Mass55 + HLTEle20WP60Ele8Mass55Sequence + HLTEndSequence ) -HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleIsoEG18 + hltPreEle22eta2p1WP75Gsf + HLTSingleEle22erWP75GsfSequence + HLTEndSequence ) +HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleIsoEG20er + hltPreEle22eta2p1WP75Gsf + HLTSingleEle22erWP75GsfSequence + HLTEndSequence ) HLT_Ele22_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1 = cms.Path( HLTBeginSequence + hltL1sL1IsoEG20erTauJet20er + hltPreEle22eta2p1WP75GsfLooseIsoPFTau20 + HLTEle22WP75GsfSequence + HLTRecoJetSequenceAK4PrePF + hltTauJet5 + hltOverlapFilterIsoEle22WP75GsfCaloJet5 + HLTPFTriggerSequenceForTaus + HLTIsoEle22WP75GsfLooseIsoPFTau20Sequence + HLTEndSequence ) HLT_Ele25WP60_SC4_Mass55_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG20 + hltPreEle25WP60SC4Mass55 + HLTEle25WP60SC4Mass55Sequence + HLTEndSequence ) HLT_Ele25_eta2p1_WP85_Gsf_PFMET80_boostedW_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG40ORL1SingleIsoEG30erORL1ETM70 + hltPreEle25eta2p1WP85GsfPFMET80boostedW + HLTEle25WP85GsfSequence + HLTAK4PFJetsSequence + hltPFMETProducer + hltPFMET80Filter + HLTEndSequence ) diff --git a/HLTrigger/Configuration/python/HLT_HIon_cff.py b/HLTrigger/Configuration/python/HLT_HIon_cff.py index c1396a600fc65..c48626ff96cc0 100644 --- a/HLTrigger/Configuration/python/HLT_HIon_cff.py +++ b/HLTrigger/Configuration/python/HLT_HIon_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_4_0/HIon/V4 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/HIon/V5 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HIon/V4') + tableName = cms.string('/dev/CMSSW_7_4_0/HIon/V5') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -381,14 +381,22 @@ track_prob_min = cms.double( -1.0 ) ) streams = cms.PSet( A = cms.vstring( 'InitialPD', - 'Templates' ) ) + 'InitialPDForHI' ) ) datasets = cms.PSet( - InitialPD = cms.vstring( 'HLT_Ele27_eta2p1_WP75_Gsf_v1', - 'HLT_Mu50_v1', - 'HLT_PFJet260_v1', - 'HLT_Physics_v1' ), - Templates = cms.vstring( 'HLT_CaloJet260_v1', - 'HLT_Photon20_CaloIdVL_IsoL_v1' ) + InitialPD = cms.vstring( 'HLT_Physics_v1' ), + InitialPDForHI = cms.vstring( 'HLT_HIL1DoubleMu0_HighQ_v1', + 'HLT_HIL2DoubleMu0_NHitQ_v1', + 'HLT_HIL2DoubleMu0_v1', + 'HLT_HIL2DoubleMu3_v1', + 'HLT_HIL2Mu15_v1', + 'HLT_HIL2Mu3_NHitQ_v1', + 'HLT_HIL2Mu3_v1', + 'HLT_HIL2Mu7_v1', + 'HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1', + 'HLT_HIL3DoubleMuOpen_OS_v1', + 'HLT_HIL3DoubleMuOpen_SS_v1', + 'HLT_HIL3DoubleMuOpen_v1', + 'HLT_HIL3Mu3_v1' ) ) hltESSHcalSeverityLevel = cms.ESSource( "EmptyESSource", @@ -1591,8 +1599,15 @@ setSigmaZ = cms.double( 0.0 ), maxRadius = cms.double( 2.0 ) ) -hltL1sL1SingleJet200 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleJet200" ), +hltPrePhysics = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltBoolEnd = cms.EDFilter( "HLTBool", + result = cms.bool( True ) +) +hltL1sL1DoubleMuOpenBptxAND = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_DoubleMuOpen_BptxAND" ), saveTags = cms.bool( True ), L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), L1UseL1TriggerObjectMaps = cms.bool( True ), @@ -1603,635 +1618,23 @@ L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), L1TechTriggerSeeding = cms.bool( False ) ) -hltPreCaloJet260 = cms.EDFilter( "HLTPrescaler", +hltPreHIL1DoubleMu0HighQ = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) -hltEcalDigis = cms.EDProducer( "EcalRawToDigi", - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), - FedLabel = cms.InputTag( "listfeds" ), - eventPut = cms.bool( True ), - srpUnpacking = cms.bool( True ), - syncCheck = cms.bool( True ), - headerUnpacking = cms.bool( True ), - feUnpacking = cms.bool( True ), - orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), - tccUnpacking = cms.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), - InputLabel = cms.InputTag( "rawDataCollector" ), - numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), - FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), - silentMode = cms.untracked.bool( True ), - DoRegional = cms.bool( False ), - forceToKeepFRData = cms.bool( False ), - memUnpacking = cms.bool( True ) -) -hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", - EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), - EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - algo = cms.string( "EcalUncalibRecHitWorkerMultiFit" ), - algoPSet = cms.PSet( - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( False ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( False ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 100.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( True ), - doPrefitEB = cms.bool( True ) - ) -) -hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", - ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), - ebDetIdToBeRecovered = cms.string( "ebDetId" ), - integrityTTIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityTTIdErrors' ), - eeIntegrityGainErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityGainErrors' ), - ebFEToBeRecovered = cms.string( "ebFE" ), - ebIntegrityGainErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityGainErrors' ), - eeDetIdToBeRecovered = cms.string( "eeDetId" ), - eeIntegrityGainSwitchErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityGainSwitchErrors' ), - eeIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), - ebIntegrityGainSwitchErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityGainSwitchErrors' ), - ebSrFlagCollection = cms.InputTag( "hltEcalDigis" ), - eeSrFlagCollection = cms.InputTag( "hltEcalDigis" ), - integrityBlockSizeErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityBlockSizeErrors' ), - eeFEToBeRecovered = cms.string( "eeFE" ) -) -hltEcalRecHit = cms.EDProducer( "EcalRecHitProducer", - recoverEEVFE = cms.bool( False ), - EErechitCollection = cms.string( "EcalRecHitsEE" ), - recoverEBIsolatedChannels = cms.bool( False ), - recoverEBVFE = cms.bool( False ), - laserCorrection = cms.bool( True ), - EBLaserMIN = cms.double( 0.5 ), - killDeadChannels = cms.bool( True ), - dbStatusToBeExcludedEB = cms.vint32( 14, 78, 142 ), - EEuncalibRecHitCollection = cms.InputTag( 'hltEcalUncalibRecHit','EcalUncalibRecHitsEE' ), - EBLaserMAX = cms.double( 3.0 ), - EELaserMIN = cms.double( 0.5 ), - ebFEToBeRecovered = cms.InputTag( 'hltEcalDetIdToBeRecovered','ebFE' ), - EELaserMAX = cms.double( 8.0 ), - recoverEEIsolatedChannels = cms.bool( False ), - eeDetIdToBeRecovered = cms.InputTag( 'hltEcalDetIdToBeRecovered','eeDetId' ), - recoverEBFE = cms.bool( True ), - algo = cms.string( "EcalRecHitWorkerSimple" ), - ebDetIdToBeRecovered = cms.InputTag( 'hltEcalDetIdToBeRecovered','ebDetId' ), - singleChannelRecoveryThreshold = cms.double( 8.0 ), - ChannelStatusToBeExcluded = cms.vstring( ), - EBrechitCollection = cms.string( "EcalRecHitsEB" ), - singleChannelRecoveryMethod = cms.string( "NeuralNetworks" ), - recoverEEFE = cms.bool( True ), - triggerPrimitiveDigiCollection = cms.InputTag( 'hltEcalDigis','EcalTriggerPrimitives' ), - dbStatusToBeExcludedEE = cms.vint32( 14, 78, 142 ), - flagsMapDBReco = cms.PSet( - kGood = cms.vstring( 'kOk', - 'kDAC', - 'kNoLaser', - 'kNoisy' ), - kNeighboursRecovered = cms.vstring( 'kFixedG0', - 'kNonRespondingIsolated', - 'kDeadVFE' ), - kDead = cms.vstring( 'kNoDataNoTP' ), - kNoisy = cms.vstring( 'kNNoisy', - 'kFixedG6', - 'kFixedG1' ), - kTowerRecovered = cms.vstring( 'kDeadFE' ) - ), - EBuncalibRecHitCollection = cms.InputTag( 'hltEcalUncalibRecHit','EcalUncalibRecHitsEB' ), - algoRecover = cms.string( "EcalRecHitWorkerRecover" ), - eeFEToBeRecovered = cms.InputTag( 'hltEcalDetIdToBeRecovered','eeFE' ), - cleaningConfig = cms.PSet( - e6e2thresh = cms.double( 0.04 ), - tightenCrack_e6e2_double = cms.double( 3.0 ), - e4e1Threshold_endcap = cms.double( 0.3 ), - tightenCrack_e4e1_single = cms.double( 3.0 ), - tightenCrack_e1_double = cms.double( 2.0 ), - cThreshold_barrel = cms.double( 4.0 ), - e4e1Threshold_barrel = cms.double( 0.08 ), - tightenCrack_e1_single = cms.double( 2.0 ), - e4e1_b_barrel = cms.double( -0.024 ), - e4e1_a_barrel = cms.double( 0.04 ), - ignoreOutOfTimeThresh = cms.double( 1.0E9 ), - cThreshold_endcap = cms.double( 15.0 ), - e4e1_b_endcap = cms.double( -0.0125 ), - e4e1_a_endcap = cms.double( 0.02 ), - cThreshold_double = cms.double( 10.0 ) - ), - logWarningEtThreshold_EB_FE = cms.double( 50.0 ), - logWarningEtThreshold_EE_FE = cms.double( 50.0 ) -) -hltHcalDigis = cms.EDProducer( "HcalRawToDigi", - ExpectedOrbitMessageTime = cms.untracked.int32( -1 ), - FilterDataQuality = cms.bool( True ), - silent = cms.untracked.bool( True ), - HcalFirstFED = cms.untracked.int32( 700 ), - InputLabel = cms.InputTag( "rawDataCollector" ), - ComplainEmptyData = cms.untracked.bool( False ), - UnpackCalib = cms.untracked.bool( True ), - FEDs = cms.untracked.vint32( ), - UnpackerMode = cms.untracked.int32( 0 ), - UnpackTTP = cms.untracked.bool( False ), - lastSample = cms.int32( 9 ), - UnpackZDC = cms.untracked.bool( True ), - firstSample = cms.int32( 0 ) -) -hltHbhereco = cms.EDProducer( "HcalHitReconstructor", - digiTimeFromDB = cms.bool( True ), - mcOOTCorrectionName = cms.string( "" ), - S9S1stat = cms.PSet( ), - saturationParameters = cms.PSet( maxADCvalue = cms.int32( 127 ) ), - tsFromDB = cms.bool( True ), - samplesToAdd = cms.int32( 4 ), - mcOOTCorrectionCategory = cms.string( "MC" ), - dataOOTCorrectionName = cms.string( "" ), - puCorrMethod = cms.int32( 0 ), - correctionPhaseNS = cms.double( 13.0 ), - HFInWindowStat = cms.PSet( ), - digiLabel = cms.InputTag( "hltHcalDigis" ), - setHSCPFlags = cms.bool( False ), - firstAuxTS = cms.int32( 4 ), - digistat = cms.PSet( ), - hfTimingTrustParameters = cms.PSet( ), - PETstat = cms.PSet( ), - setSaturationFlags = cms.bool( False ), - setNegativeFlags = cms.bool( False ), - useLeakCorrection = cms.bool( False ), - setTimingTrustFlags = cms.bool( False ), - S8S1stat = cms.PSet( ), - correctForPhaseContainment = cms.bool( True ), - correctForTimeslew = cms.bool( True ), - setNoiseFlags = cms.bool( False ), - correctTiming = cms.bool( False ), - setPulseShapeFlags = cms.bool( False ), - Subdetector = cms.string( "HBHE" ), - dataOOTCorrectionCategory = cms.string( "Data" ), - dropZSmarkedPassed = cms.bool( True ), - recoParamsFromDB = cms.bool( True ), - firstSample = cms.int32( 4 ), - setTimingShapedCutsFlags = cms.bool( False ), - pulseJitter = cms.double( 1.0 ), - chargeMax = cms.double( 6.0 ), - negativeParameters = cms.PSet( - TS4TS5ChargeThreshold = cms.double( 70.0 ), - Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), - Last = cms.int32( 6 ), - MinimumChargeThreshold = cms.double( 20.0 ), - Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), - First = cms.int32( 4 ) - ), - timeMin = cms.double( -15.0 ), - ts4chi2 = cms.double( 15.0 ), - ts345chi2 = cms.double( 100.0 ), - applyTimeSlew = cms.bool( True ), - applyTimeConstraint = cms.bool( True ), - applyPulseJitter = cms.bool( False ), - timingshapedcutsParameters = cms.PSet( - ignorelowest = cms.bool( True ), - win_offset = cms.double( 0.0 ), - ignorehighest = cms.bool( False ), - win_gain = cms.double( 1.0 ), - tfilterEnvelope = cms.vdouble( 4.0, 12.04, 13.0, 10.56, 23.5, 8.82, 37.0, 7.38, 56.0, 6.3, 81.0, 5.64, 114.5, 5.44, 175.5, 5.38, 350.5, 5.14 ) - ), - ts3chi2 = cms.double( 5.0 ), - ts4Min = cms.double( 5.0 ), - pulseShapeParameters = cms.PSet( ), - noise = cms.double( 1.0 ), - applyPedConstraint = cms.bool( True ), - applyUnconstrainedFit = cms.bool( False ), - ts4Max = cms.double( 500.0 ), - meanTime = cms.double( -2.5 ), - flagParameters = cms.PSet( - nominalPedestal = cms.double( 3.0 ), - hitMultiplicityThreshold = cms.int32( 17 ), - hitEnergyMinimum = cms.double( 1.0 ), - pulseShapeParameterSets = cms.VPSet( - cms.PSet( pulseShapeParameters = cms.vdouble( 0.0, 100.0, -50.0, 0.0, -15.0, 0.15 ) ), - cms.PSet( pulseShapeParameters = cms.vdouble( 100.0, 2000.0, -50.0, 0.0, -5.0, 0.05 ) ), - cms.PSet( pulseShapeParameters = cms.vdouble( 2000.0, 1000000.0, -50.0, 0.0, 95.0, 0.0 ) ), - cms.PSet( pulseShapeParameters = cms.vdouble( -1000000.0, 1000000.0, 45.0, 0.1, 1000000.0, 0.0 ) ) - ) - ), - fitTimes = cms.int32( 1 ), - timeMax = cms.double( 10.0 ), - timeSigma = cms.double( 5.0 ), - pedSigma = cms.double( 0.5 ), - meanPed = cms.double( 0.0 ), - hscpParameters = cms.PSet( - slopeMax = cms.double( -0.6 ), - r1Max = cms.double( 1.0 ), - r1Min = cms.double( 0.15 ), - TimingEnergyThreshold = cms.double( 30.0 ), - slopeMin = cms.double( -1.5 ), - outerMin = cms.double( 0.0 ), - outerMax = cms.double( 0.1 ), - fracLeaderMin = cms.double( 0.4 ), - r2Min = cms.double( 0.1 ), - r2Max = cms.double( 0.5 ), - fracLeaderMax = cms.double( 0.7 ) - ) -) -hltHfreco = cms.EDProducer( "HcalHitReconstructor", - digiTimeFromDB = cms.bool( True ), - mcOOTCorrectionName = cms.string( "" ), - S9S1stat = cms.PSet( - longETParams = cms.vdouble( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ), - shortEnergyParams = cms.vdouble( 35.1773, 35.37, 35.7933, 36.4472, 37.3317, 38.4468, 39.7925, 41.3688, 43.1757, 45.2132, 47.4813, 49.98, 52.7093 ), - flagsToSkip = cms.int32( 24 ), - shortETParams = cms.vdouble( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ), - short_optimumSlope = cms.vdouble( -99999.0, 0.0164905, 0.0238698, 0.0321383, 0.041296, 0.0513428, 0.0622789, 0.0741041, 0.0868186, 0.100422, 0.135313, 0.136289, 0.0589927 ), - longEnergyParams = cms.vdouble( 43.5, 45.7, 48.32, 51.36, 54.82, 58.7, 63.0, 67.72, 72.86, 78.42, 84.4, 90.8, 97.62 ), - long_optimumSlope = cms.vdouble( -99999.0, 0.0164905, 0.0238698, 0.0321383, 0.041296, 0.0513428, 0.0622789, 0.0741041, 0.0868186, 0.100422, 0.135313, 0.136289, 0.0589927 ), - isS8S1 = cms.bool( False ), - HcalAcceptSeverityLevel = cms.int32( 9 ) - ), - saturationParameters = cms.PSet( maxADCvalue = cms.int32( 127 ) ), - tsFromDB = cms.bool( True ), - samplesToAdd = cms.int32( 2 ), - mcOOTCorrectionCategory = cms.string( "MC" ), - dataOOTCorrectionName = cms.string( "" ), - puCorrMethod = cms.int32( 0 ), - correctionPhaseNS = cms.double( 13.0 ), - HFInWindowStat = cms.PSet( - hflongEthresh = cms.double( 40.0 ), - hflongMinWindowTime = cms.vdouble( -10.0 ), - hfshortEthresh = cms.double( 40.0 ), - hflongMaxWindowTime = cms.vdouble( 10.0 ), - hfshortMaxWindowTime = cms.vdouble( 10.0 ), - hfshortMinWindowTime = cms.vdouble( -12.0 ) - ), - digiLabel = cms.InputTag( "hltHcalDigis" ), - setHSCPFlags = cms.bool( False ), - firstAuxTS = cms.int32( 1 ), - digistat = cms.PSet( - HFdigiflagFirstSample = cms.int32( 1 ), - HFdigiflagMinEthreshold = cms.double( 40.0 ), - HFdigiflagSamplesToAdd = cms.int32( 3 ), - HFdigiflagExpectedPeak = cms.int32( 2 ), - HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) - ), - hfTimingTrustParameters = cms.PSet( - hfTimingTrustLevel2 = cms.int32( 4 ), - hfTimingTrustLevel1 = cms.int32( 1 ) - ), - PETstat = cms.PSet( - longETParams = cms.vdouble( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ), - short_R_29 = cms.vdouble( 0.8 ), - shortEnergyParams = cms.vdouble( 35.1773, 35.37, 35.7933, 36.4472, 37.3317, 38.4468, 39.7925, 41.3688, 43.1757, 45.2132, 47.4813, 49.98, 52.7093 ), - flagsToSkip = cms.int32( 0 ), - short_R = cms.vdouble( 0.8 ), - shortETParams = cms.vdouble( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ), - long_R_29 = cms.vdouble( 0.8 ), - longEnergyParams = cms.vdouble( 43.5, 45.7, 48.32, 51.36, 54.82, 58.7, 63.0, 67.72, 72.86, 78.42, 84.4, 90.8, 97.62 ), - long_R = cms.vdouble( 0.98 ), - HcalAcceptSeverityLevel = cms.int32( 9 ) - ), - setSaturationFlags = cms.bool( False ), - setNegativeFlags = cms.bool( False ), - useLeakCorrection = cms.bool( False ), - setTimingTrustFlags = cms.bool( False ), - S8S1stat = cms.PSet( - longETParams = cms.vdouble( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ), - shortEnergyParams = cms.vdouble( 40.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0 ), - flagsToSkip = cms.int32( 16 ), - shortETParams = cms.vdouble( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ), - short_optimumSlope = cms.vdouble( 0.3, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1 ), - longEnergyParams = cms.vdouble( 40.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0 ), - long_optimumSlope = cms.vdouble( 0.3, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1 ), - isS8S1 = cms.bool( True ), - HcalAcceptSeverityLevel = cms.int32( 9 ) - ), - correctForPhaseContainment = cms.bool( False ), - correctForTimeslew = cms.bool( False ), - setNoiseFlags = cms.bool( True ), - correctTiming = cms.bool( False ), - setPulseShapeFlags = cms.bool( False ), - Subdetector = cms.string( "HF" ), - dataOOTCorrectionCategory = cms.string( "Data" ), - dropZSmarkedPassed = cms.bool( True ), - recoParamsFromDB = cms.bool( True ), - firstSample = cms.int32( 2 ), - setTimingShapedCutsFlags = cms.bool( False ), - pulseJitter = cms.double( 1.0 ), - chargeMax = cms.double( 6.0 ), - negativeParameters = cms.PSet( - TS4TS5ChargeThreshold = cms.double( 70.0 ), - Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), - Last = cms.int32( 6 ), - MinimumChargeThreshold = cms.double( 20.0 ), - Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), - First = cms.int32( 4 ) - ), - timeMin = cms.double( -15.0 ), - ts4chi2 = cms.double( 15.0 ), - ts345chi2 = cms.double( 100.0 ), - applyTimeSlew = cms.bool( True ), - applyTimeConstraint = cms.bool( True ), - applyPulseJitter = cms.bool( False ), - timingshapedcutsParameters = cms.PSet( ), - ts3chi2 = cms.double( 5.0 ), - ts4Min = cms.double( 5.0 ), - pulseShapeParameters = cms.PSet( ), - noise = cms.double( 1.0 ), - applyPedConstraint = cms.bool( True ), - applyUnconstrainedFit = cms.bool( False ), - ts4Max = cms.double( 500.0 ), - meanTime = cms.double( -2.5 ), - flagParameters = cms.PSet( ), - fitTimes = cms.int32( 1 ), - timeMax = cms.double( 10.0 ), - timeSigma = cms.double( 5.0 ), - pedSigma = cms.double( 0.5 ), - meanPed = cms.double( 0.0 ), - hscpParameters = cms.PSet( ) -) -hltHoreco = cms.EDProducer( "HcalHitReconstructor", - digiTimeFromDB = cms.bool( True ), - mcOOTCorrectionName = cms.string( "" ), - S9S1stat = cms.PSet( ), - saturationParameters = cms.PSet( maxADCvalue = cms.int32( 127 ) ), - tsFromDB = cms.bool( True ), - samplesToAdd = cms.int32( 4 ), - mcOOTCorrectionCategory = cms.string( "MC" ), - dataOOTCorrectionName = cms.string( "" ), - puCorrMethod = cms.int32( 0 ), - correctionPhaseNS = cms.double( 13.0 ), - HFInWindowStat = cms.PSet( ), - digiLabel = cms.InputTag( "hltHcalDigis" ), - setHSCPFlags = cms.bool( False ), - firstAuxTS = cms.int32( 4 ), - digistat = cms.PSet( ), - hfTimingTrustParameters = cms.PSet( ), - PETstat = cms.PSet( ), - setSaturationFlags = cms.bool( False ), - setNegativeFlags = cms.bool( False ), - useLeakCorrection = cms.bool( False ), - setTimingTrustFlags = cms.bool( False ), - S8S1stat = cms.PSet( ), - correctForPhaseContainment = cms.bool( True ), - correctForTimeslew = cms.bool( True ), - setNoiseFlags = cms.bool( False ), - correctTiming = cms.bool( False ), - setPulseShapeFlags = cms.bool( False ), - Subdetector = cms.string( "HO" ), - dataOOTCorrectionCategory = cms.string( "Data" ), - dropZSmarkedPassed = cms.bool( True ), - recoParamsFromDB = cms.bool( True ), - firstSample = cms.int32( 4 ), - setTimingShapedCutsFlags = cms.bool( False ), - pulseJitter = cms.double( 1.0 ), - chargeMax = cms.double( 6.0 ), - negativeParameters = cms.PSet( - TS4TS5ChargeThreshold = cms.double( 70.0 ), - Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), - Last = cms.int32( 6 ), - MinimumChargeThreshold = cms.double( 20.0 ), - Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), - First = cms.int32( 4 ) - ), - timeMin = cms.double( -15.0 ), - ts4chi2 = cms.double( 15.0 ), - ts345chi2 = cms.double( 100.0 ), - applyTimeSlew = cms.bool( True ), - applyTimeConstraint = cms.bool( True ), - applyPulseJitter = cms.bool( False ), - timingshapedcutsParameters = cms.PSet( ), - ts3chi2 = cms.double( 5.0 ), - ts4Min = cms.double( 5.0 ), - pulseShapeParameters = cms.PSet( ), - noise = cms.double( 1.0 ), - applyPedConstraint = cms.bool( True ), - applyUnconstrainedFit = cms.bool( False ), - ts4Max = cms.double( 500.0 ), - meanTime = cms.double( -2.5 ), - flagParameters = cms.PSet( ), - fitTimes = cms.int32( 1 ), - timeMax = cms.double( 10.0 ), - timeSigma = cms.double( 5.0 ), - pedSigma = cms.double( 0.5 ), - meanPed = cms.double( 0.0 ), - hscpParameters = cms.PSet( ) -) -hltTowerMakerForAll = cms.EDProducer( "CaloTowersCreator", - EBSumThreshold = cms.double( 0.2 ), - MomHBDepth = cms.double( 0.2 ), - UseEtEBTreshold = cms.bool( False ), - hfInput = cms.InputTag( "hltHfreco" ), - AllowMissingInputs = cms.bool( False ), - MomEEDepth = cms.double( 0.0 ), - EESumThreshold = cms.double( 0.45 ), - HBGrid = cms.vdouble( ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - HBThreshold = cms.double( 0.7 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), - UseEcalRecoveredHits = cms.bool( False ), - MomConstrMethod = cms.int32( 1 ), - MomHEDepth = cms.double( 0.4 ), - HcalThreshold = cms.double( -1000.0 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), - UseSymEBTreshold = cms.bool( False ), - EEWeights = cms.vdouble( ), - EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), - HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HEDGrid = cms.vdouble( ), - EBWeight = cms.double( 1.0 ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), - HOWeight = cms.double( 1.0E-99 ), - HESWeight = cms.double( 1.0 ), - HESThreshold = cms.double( 0.8 ), - hbheInput = cms.InputTag( "hltHbhereco" ), - HF2Weight = cms.double( 1.0 ), - HF2Threshold = cms.double( 0.85 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EEThreshold = cms.double( 0.3 ), - HOThresholdPlus1 = cms.double( 3.5 ), - HOThresholdPlus2 = cms.double( 3.5 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HF1Threshold = cms.double( 0.5 ), - HOThresholdMinus1 = cms.double( 3.5 ), - HESGrid = cms.vdouble( ), - EcutTower = cms.double( -1000.0 ), - UseRejectedRecoveredEcalHits = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - HESWeights = cms.vdouble( ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), - HEDWeight = cms.double( 1.0 ), - UseSymEETreshold = cms.bool( False ), - HEDThreshold = cms.double( 0.8 ), - EBThreshold = cms.double( 0.07 ), - UseRejectedHitsOnly = cms.bool( False ), - UseHcalRecoveredHits = cms.bool( False ), - HOThresholdMinus2 = cms.double( 3.5 ), - HOThreshold0 = cms.double( 3.5 ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), - UseRejectedRecoveredHcalHits = cms.bool( False ), - MomEBDepth = cms.double( 0.3 ), - HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ) -) -hltAK4CaloJets = cms.EDProducer( "FastjetJetProducer", - Active_Area_Repeats = cms.int32( 5 ), - doAreaFastjet = cms.bool( False ), - voronoiRfact = cms.double( 0.9 ), - maxBadHcalCells = cms.uint32( 9999999 ), - doAreaDiskApprox = cms.bool( True ), - maxRecoveredEcalCells = cms.uint32( 9999999 ), - jetType = cms.string( "CaloJet" ), - minSeed = cms.uint32( 14327 ), - Ghost_EtaMax = cms.double( 6.0 ), - doRhoFastjet = cms.bool( False ), - jetAlgorithm = cms.string( "AntiKt" ), - nSigmaPU = cms.double( 1.0 ), - GhostArea = cms.double( 0.01 ), - Rho_EtaMax = cms.double( 4.4 ), - maxBadEcalCells = cms.uint32( 9999999 ), - useDeterministicSeed = cms.bool( True ), - doPVCorrection = cms.bool( False ), - maxRecoveredHcalCells = cms.uint32( 9999999 ), - rParam = cms.double( 0.4 ), - maxProblematicHcalCells = cms.uint32( 9999999 ), - doOutputJets = cms.bool( True ), - src = cms.InputTag( "hltTowerMakerForAll" ), - inputEtMin = cms.double( 0.3 ), - puPtMin = cms.double( 10.0 ), - srcPVs = cms.InputTag( "NotUsed" ), - jetPtMin = cms.double( 1.0 ), - radiusPU = cms.double( 0.4 ), - maxProblematicEcalCells = cms.uint32( 9999999 ), - doPUOffsetCorr = cms.bool( False ), - inputEMin = cms.double( 0.0 ), - useMassDropTagger = cms.bool( False ), - muMin = cms.double( -1.0 ), - subtractorName = cms.string( "" ), - muCut = cms.double( -1.0 ), - subjetPtMin = cms.double( -1.0 ), - useTrimming = cms.bool( False ), - muMax = cms.double( -1.0 ), - yMin = cms.double( -1.0 ), - useFiltering = cms.bool( False ), - rFilt = cms.double( -1.0 ), - yMax = cms.double( -1.0 ), - zcut = cms.double( -1.0 ), - MinVtxNdof = cms.int32( 5 ), - MaxVtxZ = cms.double( 15.0 ), - UseOnlyVertexTracks = cms.bool( False ), - dRMin = cms.double( -1.0 ), - nFilt = cms.int32( -1 ), - usePruning = cms.bool( False ), - maxDepth = cms.int32( -1 ), - yCut = cms.double( -1.0 ), - DzTrVtxMax = cms.double( 0.0 ), - UseOnlyOnePV = cms.bool( False ), - rcut_factor = cms.double( -1.0 ), - sumRecHits = cms.bool( False ), - trimPtFracMin = cms.double( -1.0 ), - dRMax = cms.double( -1.0 ), - DxyTrVtxMax = cms.double( 0.0 ), - useCMSBoostedTauSeedingAlgorithm = cms.bool( False ) -) -hltAK4CaloJetsIDPassed = cms.EDProducer( "HLTCaloJetIDProducer", - min_N90 = cms.int32( -2 ), - min_N90hits = cms.int32( 2 ), - min_EMF = cms.double( 1.0E-6 ), - jetsInput = cms.InputTag( "hltAK4CaloJets" ), - JetIDParams = cms.PSet( - useRecHits = cms.bool( True ), - hbheRecHitsColl = cms.InputTag( "hltHbhereco" ), - hoRecHitsColl = cms.InputTag( "hltHoreco" ), - hfRecHitsColl = cms.InputTag( "hltHfreco" ), - ebRecHitsColl = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEB' ), - eeRecHitsColl = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEE' ) - ), - max_EMF = cms.double( 999.0 ) -) -hltFixedGridRhoFastjetAllCalo = cms.EDProducer( "FixedGridRhoProducerFastjet", - gridSpacing = cms.double( 0.55 ), - maxRapidity = cms.double( 5.0 ), - pfCandidatesTag = cms.InputTag( "hltTowerMakerForAll" ) -) -hltAK4CaloJetsCorrected = cms.EDProducer( "CaloJetCorrectionProducer", - src = cms.InputTag( "hltAK4CaloJets" ), - correctors = cms.vstring( 'hltESPAK4CaloCorrection' ) -) -hltAK4CaloJetsCorrectedIDPassed = cms.EDProducer( "CaloJetCorrectionProducer", - src = cms.InputTag( "hltAK4CaloJetsIDPassed" ), - correctors = cms.vstring( 'hltESPAK4CaloCorrection' ) -) -hltSingleCaloJet260 = cms.EDFilter( "HLT1CaloJet", +hltL1fL1DoubleMu0HQL1Filtered0 = cms.EDFilter( "HLTMuonL1Filter", saveTags = cms.bool( True ), - MinPt = cms.double( 260.0 ), - MinN = cms.int32( 1 ), - MaxEta = cms.double( 5.0 ), - MinMass = cms.double( -1.0 ), - inputTag = cms.InputTag( "hltAK4CaloJetsCorrectedIDPassed" ), - MinE = cms.double( -1.0 ), - triggerType = cms.int32( 85 ) -) -hltBoolEnd = cms.EDFilter( "HLTBool", - result = cms.bool( True ) + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1DoubleMuOpenBptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "hltL1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) ) -hltL1sL1SingleIsoEG22er = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG22er" ), +hltL1sL1SingleMu3BptxAND = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleMu3_BptxAND" ), saveTags = cms.bool( True ), L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), L1UseL1TriggerObjectMaps = cms.bool( True ), @@ -2242,5670 +1645,1703 @@ L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), L1TechTriggerSeeding = cms.bool( False ) ) -hltPreEle27eta2p1WP75Gsf = cms.EDFilter( "HLTPrescaler", +hltPreHIL2Mu3 = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) -hltEcalPreshowerDigis = cms.EDProducer( "ESRawToDigi", - sourceTag = cms.InputTag( "rawDataCollector" ), - debugMode = cms.untracked.bool( False ), - InstanceES = cms.string( "" ), - ESdigiCollection = cms.string( "" ), - LookupTable = cms.FileInPath( "EventFilter/ESDigiToRaw/data/ES_lookup_table.dat" ) -) -hltEcalPreshowerRecHit = cms.EDProducer( "ESRecHitProducer", - ESRecoAlgo = cms.int32( 0 ), - ESrechitCollection = cms.string( "EcalRecHitsES" ), - algo = cms.string( "ESRecHitWorker" ), - ESdigiCollection = cms.InputTag( "hltEcalPreshowerDigis" ) -) -hltRechitInRegionsECAL = cms.EDProducer( "EgammaHLTRechitInRegionsProducer", - l1LowerThr = cms.double( 5.0 ), - doIsolated = cms.bool( True ), - useUncalib = cms.bool( False ), - regionEtaMargin = cms.double( 0.14 ), - ecalhitLabels = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), - regionPhiMargin = cms.double( 0.4 ), - l1TagNonIsolated = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), - l1UpperThr = cms.double( 999.0 ), - l1LowerThrIgnoreIsolation = cms.double( 0.0 ), - productLabels = cms.vstring( 'EcalRecHitsEB', - 'EcalRecHitsEE' ), - l1TagIsolated = cms.InputTag( 'hltL1extraParticles','Isolated' ) -) -hltRechitInRegionsES = cms.EDProducer( "EgammaHLTRechitInRegionsProducer", - l1LowerThr = cms.double( 5.0 ), - doIsolated = cms.bool( True ), - useUncalib = cms.bool( False ), - regionEtaMargin = cms.double( 0.14 ), - ecalhitLabels = cms.VInputTag( 'hltEcalPreshowerRecHit:EcalRecHitsES' ), - regionPhiMargin = cms.double( 0.4 ), - l1TagNonIsolated = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), - l1UpperThr = cms.double( 999.0 ), - l1LowerThrIgnoreIsolation = cms.double( 0.0 ), - productLabels = cms.vstring( 'EcalRecHitsES' ), - l1TagIsolated = cms.InputTag( 'hltL1extraParticles','Isolated' ) -) -hltParticleFlowRecHitECALL1Seeded = cms.EDProducer( "PFRecHitProducer", - producers = cms.VPSet( - cms.PSet( src = cms.InputTag( 'hltRechitInRegionsECAL','EcalRecHitsEB' ), - qualityTests = cms.VPSet( - cms.PSet( threshold = cms.double( 0.08 ), - name = cms.string( "PFRecHitQTestThreshold" ) - ), - cms.PSet( timingCleaning = cms.bool( True ), - topologicalCleaning = cms.bool( True ), - cleaningThreshold = cms.double( 2.0 ), - skipTTRecoveredHits = cms.bool( True ), - name = cms.string( "PFRecHitQTestECAL" ) - ) - ), - name = cms.string( "PFEBRecHitCreator" ) - ), - cms.PSet( src = cms.InputTag( 'hltRechitInRegionsECAL','EcalRecHitsEE' ), - qualityTests = cms.VPSet( - cms.PSet( threshold = cms.double( 0.3 ), - name = cms.string( "PFRecHitQTestThreshold" ) - ), - cms.PSet( timingCleaning = cms.bool( True ), - topologicalCleaning = cms.bool( True ), - cleaningThreshold = cms.double( 2.0 ), - skipTTRecoveredHits = cms.bool( True ), - name = cms.string( "PFRecHitQTestECAL" ) - ) - ), - name = cms.string( "PFEERecHitCreator" ) - ) - ), - navigator = cms.PSet( - barrel = cms.PSet( ), - endcap = cms.PSet( ), - name = cms.string( "PFRecHitECALNavigator" ) - ) +hltHIL1SingleMu3Filtered = cms.EDFilter( "HLTMuonL1Filter", + saveTags = cms.bool( False ), + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1SingleMu3BptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 1 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "hltL1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) ) -hltParticleFlowRecHitPSL1Seeded = cms.EDProducer( "PFRecHitProducer", - producers = cms.VPSet( - cms.PSet( src = cms.InputTag( 'hltRechitInRegionsES','EcalRecHitsES' ), - qualityTests = cms.VPSet( - cms.PSet( threshold = cms.double( 7.0E-6 ), - name = cms.string( "PFRecHitQTestThreshold" ) - ) - ), - name = cms.string( "PFPSRecHitCreator" ) - ) - ), - navigator = cms.PSet( name = cms.string( "PFRecHitPreshowerNavigator" ) ) -) -hltParticleFlowClusterPSL1Seeded = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - minFracTot = cms.double( 1.0E-20 ), - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 6.0E-5 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 0.3 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "PS1" ), - recHitEnergyNorm = cms.double( 6.0E-5 ) - ), - cms.PSet( detector = cms.string( "PS2" ), - recHitEnergyNorm = cms.double( 6.0E-5 ) - ) - ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ) - ), - positionReCalc = cms.PSet( ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 6.0E-5 ), - detector = cms.string( "PS1" ), - gatheringThresholdPt = cms.double( 0.0 ) - ), - cms.PSet( gatheringThreshold = cms.double( 6.0E-5 ), - detector = cms.string( "PS2" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) - ), - useCornerCells = cms.bool( False ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 4 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 1.2E-4 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "PS1" ) - ), - cms.PSet( seedingThreshold = cms.double( 1.2E-4 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "PS2" ) - ) - ), - algoName = cms.string( "LocalMaximumSeedFinder" ) - ), - recHitsSource = cms.InputTag( "hltParticleFlowRecHitPSL1Seeded" ) -) -hltParticleFlowClusterECALUncorrectedL1Seeded = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.08 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( 9 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - minFracTot = cms.double( 1.0E-20 ), - positionCalcForConvergence = cms.PSet( - minFractionInCalc = cms.double( 0.0 ), - W0 = cms.double( 4.2 ), - minAllowedNormalization = cms.double( 0.0 ), - T0_EB = cms.double( 7.4 ), - X0 = cms.double( 0.89 ), - T0_ES = cms.double( 1.2 ), - T0_EE = cms.double( 3.1 ), - algoName = cms.string( "ECAL2DPositionCalcWithDepthCorr" ) - ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 1.5 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "ECAL_BARREL" ), - recHitEnergyNorm = cms.double( 0.08 ) - ), - cms.PSet( detector = cms.string( "ECAL_ENDCAP" ), - recHitEnergyNorm = cms.double( 0.3 ) - ) - ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ), - allCellsPositionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.08 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ) - ), - positionReCalc = cms.PSet( - minFractionInCalc = cms.double( 0.0 ), - W0 = cms.double( 4.2 ), - minAllowedNormalization = cms.double( 0.0 ), - T0_EB = cms.double( 7.4 ), - X0 = cms.double( 0.89 ), - T0_ES = cms.double( 1.2 ), - T0_EE = cms.double( 3.1 ), - algoName = cms.string( "ECAL2DPositionCalcWithDepthCorr" ) - ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 0.08 ), - detector = cms.string( "ECAL_BARREL" ), - gatheringThresholdPt = cms.double( 0.0 ) - ), - cms.PSet( gatheringThreshold = cms.double( 0.3 ), - detector = cms.string( "ECAL_ENDCAP" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) - ), - useCornerCells = cms.bool( True ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - cms.PSet( cleaningByDetector = cms.VPSet( - cms.PSet( doubleSpikeS6S2 = cms.double( 0.04 ), - fractionThresholdModifier = cms.double( 3.0 ), - doubleSpikeThresh = cms.double( 10.0 ), - minS4S1_b = cms.double( -0.024 ), - singleSpikeThresh = cms.double( 4.0 ), - detector = cms.string( "ECAL_BARREL" ), - minS4S1_a = cms.double( 0.04 ), - energyThresholdModifier = cms.double( 2.0 ) - ), - cms.PSet( doubleSpikeS6S2 = cms.double( -1.0 ), - fractionThresholdModifier = cms.double( 3.0 ), - doubleSpikeThresh = cms.double( 1.0E9 ), - minS4S1_b = cms.double( -0.0125 ), - singleSpikeThresh = cms.double( 15.0 ), - detector = cms.string( "ECAL_ENDCAP" ), - minS4S1_a = cms.double( 0.02 ), - energyThresholdModifier = cms.double( 2.0 ) - ) -), - algoName = cms.string( "SpikeAndDoubleSpikeCleaner" ) - ) - ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 8 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 0.6 ), - seedingThresholdPt = cms.double( 0.15 ), - detector = cms.string( "ECAL_ENDCAP" ) - ), - cms.PSet( seedingThreshold = cms.double( 0.23 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "ECAL_BARREL" ) - ) +hltMuonDTDigis = cms.EDProducer( "DTUnpackingModule", + useStandardFEDid = cms.bool( True ), + maxFEDid = cms.untracked.int32( 779 ), + inputLabel = cms.InputTag( "rawDataCollector" ), + minFEDid = cms.untracked.int32( 770 ), + dataType = cms.string( "DDU" ), + readOutParameters = cms.PSet( + debug = cms.untracked.bool( False ), + rosParameters = cms.PSet( + writeSC = cms.untracked.bool( True ), + readingDDU = cms.untracked.bool( True ), + performDataIntegrityMonitor = cms.untracked.bool( False ), + readDDUIDfromDDU = cms.untracked.bool( True ), + debug = cms.untracked.bool( False ), + localDAQ = cms.untracked.bool( False ) ), - algoName = cms.string( "LocalMaximumSeedFinder" ) - ), - recHitsSource = cms.InputTag( "hltParticleFlowRecHitECALL1Seeded" ) -) -hltParticleFlowClusterECALL1Seeded = cms.EDProducer( "CorrectedECALPFClusterProducer", - inputPS = cms.InputTag( "hltParticleFlowClusterPSL1Seeded" ), - minimumPSEnergy = cms.double( 0.0 ), - energyCorrector = cms.PSet( - applyCrackCorrections = cms.bool( False ), - algoName = cms.string( "PFClusterEMEnergyCorrector" ) - ), - inputECAL = cms.InputTag( "hltParticleFlowClusterECALUncorrectedL1Seeded" ) -) -hltParticleFlowSuperClusterECALL1Seeded = cms.EDProducer( "PFECALSuperClusterProducer", - PFSuperClusterCollectionEndcap = cms.string( "hltParticleFlowSuperClusterECALEndcap" ), - doSatelliteClusterMerge = cms.bool( False ), - BeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - PFBasicClusterCollectionBarrel = cms.string( "hltParticleFlowBasicClusterECALBarrel" ), - useRegression = cms.bool( False ), - satelliteMajorityFraction = cms.double( 0.5 ), - thresh_PFClusterEndcap = cms.double( 4.0 ), - ESAssociation = cms.InputTag( "hltParticleFlowClusterECALL1Seeded" ), - PFBasicClusterCollectionPreshower = cms.string( "hltParticleFlowBasicClusterECALPreshower" ), - use_preshower = cms.bool( True ), - thresh_PFClusterBarrel = cms.double( 4.0 ), - thresh_SCEt = cms.double( 4.0 ), - etawidth_SuperClusterEndcap = cms.double( 0.04 ), - phiwidth_SuperClusterEndcap = cms.double( 0.6 ), - verbose = cms.untracked.bool( False ), - useDynamicDPhiWindow = cms.bool( True ), - PFSuperClusterCollectionBarrel = cms.string( "hltParticleFlowSuperClusterECALBarrel" ), - regressionConfig = cms.PSet( - regressionKeyEE = cms.string( "pfscecal_EECorrection_offline" ), - ecalRecHitsEE = cms.InputTag( 'hltRechitInRegionsECAL','EcalRecHitsEE' ), - ecalRecHitsEB = cms.InputTag( 'hltRechitInRegionsECAL','EcalRecHitsEB' ), - regressionKeyEB = cms.string( "pfscecal_EBCorrection_offline" ), - vertexCollection = cms.InputTag( "offlinePrimaryVertices" ) + localDAQ = cms.untracked.bool( False ), + performDataIntegrityMonitor = cms.untracked.bool( False ) ), - applyCrackCorrections = cms.bool( False ), - satelliteClusterSeedThreshold = cms.double( 50.0 ), - etawidth_SuperClusterBarrel = cms.double( 0.04 ), - PFBasicClusterCollectionEndcap = cms.string( "hltParticleFlowBasicClusterECALEndcap" ), - PFClusters = cms.InputTag( "hltParticleFlowClusterECALL1Seeded" ), - thresh_PFClusterSeedBarrel = cms.double( 4.0 ), - ClusteringType = cms.string( "Mustache" ), - EnergyWeight = cms.string( "Raw" ), - thresh_PFClusterSeedEndcap = cms.double( 4.0 ), - phiwidth_SuperClusterBarrel = cms.double( 0.6 ), - thresh_PFClusterES = cms.double( 5.0 ), - seedThresholdIsET = cms.bool( True ), - PFSuperClusterCollectionEndcapWithPreshower = cms.string( "hltParticleFlowSuperClusterECALEndcapWithPreshower" ) -) -hltEgammaCandidates = cms.EDProducer( "EgammaHLTRecoEcalCandidateProducers", - scIslandEndcapProducer = cms.InputTag( 'hltParticleFlowSuperClusterECALL1Seeded','hltParticleFlowSuperClusterECALEndcapWithPreshower' ), - scHybridBarrelProducer = cms.InputTag( 'hltParticleFlowSuperClusterECALL1Seeded','hltParticleFlowSuperClusterECALBarrel' ), - recoEcalCandidateCollection = cms.string( "" ) -) -hltEGL1SingleIsoEG22erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", - doIsolated = cms.bool( False ), - endcap_end = cms.double( 2.65 ), - saveTags = cms.bool( False ), - region_eta_size_ecap = cms.double( 1.0 ), - barrel_end = cms.double( 1.4791 ), - l1IsolatedTag = cms.InputTag( 'hltL1extraParticles','Isolated' ), - candIsolatedTag = cms.InputTag( "hltEgammaCandidates" ), - region_phi_size = cms.double( 1.044 ), - region_eta_size = cms.double( 0.522 ), - L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG22er" ), - candNonIsolatedTag = cms.InputTag( "" ), - l1NonIsolatedTag = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), - ncandcut = cms.int32( 1 ) -) -hltEG27EtL1IsoEG22erFilter = cms.EDFilter( "HLTEgammaEtFilter", - saveTags = cms.bool( False ), - L1NonIsoCand = cms.InputTag( "" ), - relaxed = cms.untracked.bool( False ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - inputTag = cms.InputTag( "hltEGL1SingleIsoEG22erFilter" ), - etcutEB = cms.double( 27.0 ), - etcutEE = cms.double( 27.0 ), - ncandcut = cms.int32( 1 ) -) -hltEgammaClusterShape = cms.EDProducer( "EgammaHLTClusterShapeProducer", - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - ecalRechitEB = cms.InputTag( 'hltRechitInRegionsECAL','EcalRecHitsEB' ), - ecalRechitEE = cms.InputTag( 'hltRechitInRegionsECAL','EcalRecHitsEE' ), - isIeta = cms.bool( True ) -) -hltEle27WP75ClusterShapeFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( 0.031 ), - thrOverEEE = cms.double( -1.0 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( -1.0 ), - thrRegularEB = cms.double( 0.011 ), - lessThan = cms.bool( True ), - useEt = cms.bool( False ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( 'hltEgammaClusterShape','sigmaIEtaIEta5x5' ), - candTag = cms.InputTag( "hltEG27EtL1IsoEG22erFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -hltFixedGridRhoFastjetAllCaloForMuons = cms.EDProducer( "FixedGridRhoProducerFastjet", - gridSpacing = cms.double( 0.55 ), - maxRapidity = cms.double( 2.5 ), - pfCandidatesTag = cms.InputTag( "hltTowerMakerForAll" ) -) -hltEgammaHoverE = cms.EDProducer( "EgammaHLTBcHcalIsolationProducersRegional", - caloTowerProducer = cms.InputTag( "hltTowerMakerForAll" ), - effectiveAreaBarrel = cms.double( 0.105 ), - outerCone = cms.double( 0.14 ), - innerCone = cms.double( 0.0 ), - useSingleTower = cms.bool( False ), - rhoProducer = cms.InputTag( "hltFixedGridRhoFastjetAllCaloForMuons" ), - depth = cms.int32( -1 ), - doRhoCorrection = cms.bool( False ), - effectiveAreaEndcap = cms.double( 0.17 ), - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - rhoMax = cms.double( 9.9999999E7 ), - etMin = cms.double( 0.0 ), - rhoScale = cms.double( 1.0 ), - doEtSum = cms.bool( False ) -) -hltEle27WP75HcEFilter = cms.EDFilter( "HLTEgammaGenericQuadraticFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( 0.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( 0.0 ), - thrRegularEE = cms.double( 13.0 ), - thrOverEEE = cms.double( 0.01 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.01 ), - thrRegularEB = cms.double( 4.0 ), - lessThan = cms.bool( True ), - useEt = cms.bool( False ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaHoverE" ), - candTag = cms.InputTag( "hltEle27WP75ClusterShapeFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -hltEgammaEcalPFClusterIso = cms.EDProducer( "EgammaHLTEcalPFClusterIsolationProducer", - energyEndcap = cms.double( 0.0 ), - effectiveAreaBarrel = cms.double( 0.149 ), - etaStripBarrel = cms.double( 0.0 ), - rhoProducer = cms.InputTag( "hltFixedGridRhoFastjetAllCaloForMuons" ), - pfClusterProducer = cms.InputTag( "hltParticleFlowClusterECALL1Seeded" ), - etaStripEndcap = cms.double( 0.0 ), - drVetoBarrel = cms.double( 0.0 ), - drMax = cms.double( 0.3 ), - doRhoCorrection = cms.bool( True ), - energyBarrel = cms.double( 0.0 ), - effectiveAreaEndcap = cms.double( 0.097 ), - drVetoEndcap = cms.double( 0.0 ), - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - rhoMax = cms.double( 9.9999999E7 ), - rhoScale = cms.double( 1.0 ) -) -hltEle27WP75EcalIsoFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( -1.0 ), - thrOverEEE = cms.double( 0.14 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.21 ), - thrRegularEB = cms.double( -1.0 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaEcalPFClusterIso" ), - candTag = cms.InputTag( "hltEle27WP75HcEFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -hltRegionalTowerForEgamma = cms.EDProducer( "EgammaHLTCaloTowerProducer", - L1NonIsoCand = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), - EMin = cms.double( 0.8 ), - EtMin = cms.double( 0.5 ), - L1IsoCand = cms.InputTag( 'hltL1extraParticles','Isolated' ), - useTowersInCone = cms.double( 0.8 ), - towerCollection = cms.InputTag( "hltTowerMakerForAll" ) -) -hltParticleFlowRecHitHCALForEgamma = cms.EDProducer( "PFCTRecHitProducer", - ECAL_Compensate = cms.bool( False ), - ECAL_Dead_Code = cms.uint32( 10 ), - MinLongTiming_Cut = cms.double( -5.0 ), - ECAL_Compensation = cms.double( 0.5 ), - MaxLongTiming_Cut = cms.double( 5.0 ), - weight_HFhad = cms.double( 1.0 ), - ApplyPulseDPG = cms.bool( False ), - navigator = cms.PSet( name = cms.string( "PFRecHitCaloTowerNavigator" ) ), - ECAL_Threshold = cms.double( 10.0 ), - ApplyTimeDPG = cms.bool( False ), - caloTowers = cms.InputTag( "hltRegionalTowerForEgamma" ), - hcalRecHitsHBHE = cms.InputTag( "hltHbhereco" ), - LongFibre_Fraction = cms.double( 0.1 ), - MaxShortTiming_Cut = cms.double( 5.0 ), - HcalMaxAllowedHFLongShortSev = cms.int32( 9 ), - thresh_Barrel = cms.double( 0.4 ), - navigation_HF = cms.bool( True ), - HcalMaxAllowedHFInTimeWindowSev = cms.int32( 9 ), - HF_Calib_29 = cms.double( 1.07 ), - LongFibre_Cut = cms.double( 120.0 ), - EM_Depth = cms.double( 22.0 ), - weight_HFem = cms.double( 1.0 ), - LongShortFibre_Cut = cms.double( 1.0E9 ), - MinShortTiming_Cut = cms.double( -5.0 ), - HCAL_Calib = cms.bool( True ), - thresh_HF = cms.double( 0.4 ), - HcalMaxAllowedHFDigiTimeSev = cms.int32( 9 ), - thresh_Endcap = cms.double( 0.4 ), - HcalMaxAllowedChannelStatusSev = cms.int32( 9 ), - hcalRecHitsHF = cms.InputTag( "hltHfreco" ), - ShortFibre_Cut = cms.double( 60.0 ), - ApplyLongShortDPG = cms.bool( True ), - HF_Calib = cms.bool( True ), - HAD_Depth = cms.double( 47.0 ), - ShortFibre_Fraction = cms.double( 0.01 ), - HCAL_Calib_29 = cms.double( 1.35 ) -) -hltParticleFlowClusterHCALForEgamma = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( 5 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - minFracTot = cms.double( 1.0E-20 ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 10.0 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "HCAL_BARREL1" ), - recHitEnergyNorm = cms.double( 0.8 ) - ), - cms.PSet( detector = cms.string( "HCAL_ENDCAP" ), - recHitEnergyNorm = cms.double( 0.8 ) - ) + dqmOnly = cms.bool( False ) +) +hltDt1DRecHits = cms.EDProducer( "DTRecHitProducer", + debug = cms.untracked.bool( False ), + recAlgoConfig = cms.PSet( + tTrigMode = cms.string( "DTTTrigSyncFromDB" ), + minTime = cms.double( -3.0 ), + stepTwoFromDigi = cms.bool( False ), + doVdriftCorr = cms.bool( True ), + debug = cms.untracked.bool( False ), + maxTime = cms.double( 420.0 ), + tTrigModeConfig = cms.PSet( + vPropWire = cms.double( 24.4 ), + doTOFCorrection = cms.bool( True ), + tofCorrType = cms.int32( 0 ), + wirePropCorrType = cms.int32( 0 ), + tTrigLabel = cms.string( "" ), + doWirePropCorrection = cms.bool( True ), + doT0Correction = cms.bool( True ), + debug = cms.untracked.bool( False ) ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ), - allCellsPositionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ) + useUncertDB = cms.bool( True ) ), - positionReCalc = cms.PSet( ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 0.8 ), - detector = cms.string( "HCAL_BARREL1" ), - gatheringThresholdPt = cms.double( 0.0 ) + dtDigiLabel = cms.InputTag( "hltMuonDTDigis" ), + recAlgo = cms.string( "DTLinearDriftFromDBAlgo" ) +) +hltDt4DSegments = cms.EDProducer( "DTRecSegment4DProducer", + debug = cms.untracked.bool( False ), + Reco4DAlgoName = cms.string( "DTCombinatorialPatternReco4D" ), + recHits2DLabel = cms.InputTag( "dt2DSegments" ), + recHits1DLabel = cms.InputTag( "hltDt1DRecHits" ), + Reco4DAlgoConfig = cms.PSet( + segmCleanerMode = cms.int32( 2 ), + Reco2DAlgoName = cms.string( "DTCombinatorialPatternReco" ), + recAlgoConfig = cms.PSet( + tTrigMode = cms.string( "DTTTrigSyncFromDB" ), + minTime = cms.double( -3.0 ), + stepTwoFromDigi = cms.bool( False ), + doVdriftCorr = cms.bool( True ), + debug = cms.untracked.bool( False ), + maxTime = cms.double( 420.0 ), + tTrigModeConfig = cms.PSet( + vPropWire = cms.double( 24.4 ), + doTOFCorrection = cms.bool( True ), + tofCorrType = cms.int32( 0 ), + wirePropCorrType = cms.int32( 0 ), + tTrigLabel = cms.string( "" ), + doWirePropCorrection = cms.bool( True ), + doT0Correction = cms.bool( True ), + debug = cms.untracked.bool( False ) ), - cms.PSet( gatheringThreshold = cms.double( 0.8 ), - detector = cms.string( "HCAL_ENDCAP" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) + useUncertDB = cms.bool( True ) ), - useCornerCells = cms.bool( True ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - cms.PSet( algoName = cms.string( "RBXAndHPDCleaner" ) ) - ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 4 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 0.8 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "HCAL_BARREL1" ) + nSharedHitsMax = cms.int32( 2 ), + hit_afterT0_resolution = cms.double( 0.03 ), + Reco2DAlgoConfig = cms.PSet( + segmCleanerMode = cms.int32( 2 ), + recAlgoConfig = cms.PSet( + tTrigMode = cms.string( "DTTTrigSyncFromDB" ), + minTime = cms.double( -3.0 ), + stepTwoFromDigi = cms.bool( False ), + doVdriftCorr = cms.bool( True ), + debug = cms.untracked.bool( False ), + maxTime = cms.double( 420.0 ), + tTrigModeConfig = cms.PSet( + vPropWire = cms.double( 24.4 ), + doTOFCorrection = cms.bool( True ), + tofCorrType = cms.int32( 0 ), + wirePropCorrType = cms.int32( 0 ), + tTrigLabel = cms.string( "" ), + doWirePropCorrection = cms.bool( True ), + doT0Correction = cms.bool( True ), + debug = cms.untracked.bool( False ) + ), + useUncertDB = cms.bool( True ) ), - cms.PSet( seedingThreshold = cms.double( 1.1 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "HCAL_ENDCAP" ) - ) + nSharedHitsMax = cms.int32( 2 ), + AlphaMaxPhi = cms.double( 1.0 ), + hit_afterT0_resolution = cms.double( 0.03 ), + MaxAllowedHits = cms.uint32( 50 ), + performT0_vdriftSegCorrection = cms.bool( False ), + AlphaMaxTheta = cms.double( 0.9 ), + debug = cms.untracked.bool( False ), + recAlgo = cms.string( "DTLinearDriftFromDBAlgo" ), + nUnSharedHitsMin = cms.int32( 2 ), + performT0SegCorrection = cms.bool( False ), + perform_delta_rejecting = cms.bool( False ) ), - algoName = cms.string( "LocalMaximumSeedFinder" ) - ), - recHitsSource = cms.InputTag( "hltParticleFlowRecHitHCALForEgamma" ) -) -hltEgammaHcalPFClusterIso = cms.EDProducer( "EgammaHLTHcalPFClusterIsolationProducer", - energyEndcap = cms.double( 0.0 ), - useHF = cms.bool( False ), - effectiveAreaBarrel = cms.double( 0.06 ), - etaStripBarrel = cms.double( 0.0 ), - pfClusterProducerHFHAD = cms.InputTag( "hltParticleFlowClusterHFHADForEgamma" ), - rhoProducer = cms.InputTag( "hltFixedGridRhoFastjetAllCaloForMuons" ), - etaStripEndcap = cms.double( 0.0 ), - drVetoBarrel = cms.double( 0.0 ), - pfClusterProducerHCAL = cms.InputTag( "hltParticleFlowClusterHCALForEgamma" ), - drMax = cms.double( 0.3 ), - doRhoCorrection = cms.bool( True ), - energyBarrel = cms.double( 0.0 ), - effectiveAreaEndcap = cms.double( 0.089 ), - drVetoEndcap = cms.double( 0.0 ), - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - rhoMax = cms.double( 9.9999999E7 ), - pfClusterProducerHFEM = cms.InputTag( "hltParticleFlowClusterHFEMForEgamma" ), - rhoScale = cms.double( 1.0 ) -) -hltEle27WP75HcalIsoFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( -1.0 ), - thrOverEEE = cms.double( 0.21 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.11 ), - thrRegularEB = cms.double( -1.0 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaHcalPFClusterIso" ), - candTag = cms.InputTag( "hltEle27WP75EcalIsoFilter" ), - nonIsoTag = cms.InputTag( "" ) + performT0_vdriftSegCorrection = cms.bool( False ), + debug = cms.untracked.bool( False ), + recAlgo = cms.string( "DTLinearDriftFromDBAlgo" ), + nUnSharedHitsMin = cms.int32( 2 ), + AllDTRecHits = cms.bool( True ), + performT0SegCorrection = cms.bool( False ), + perform_delta_rejecting = cms.bool( False ) + ) ) -hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", - UseQualityInfo = cms.bool( False ), - UsePilotBlade = cms.bool( False ), - UsePhase1 = cms.bool( False ), - InputLabel = cms.InputTag( "rawDataCollector" ), - IncludeErrors = cms.bool( False ), - ErrorList = cms.vint32( ), - Regions = cms.PSet( ), - Timing = cms.untracked.bool( False ), - UserErrorList = cms.vint32( ) +hltMuonCSCDigis = cms.EDProducer( "CSCDCCUnpacker", + PrintEventNumber = cms.untracked.bool( False ), + SuppressZeroLCT = cms.untracked.bool( True ), + UseExaminer = cms.bool( True ), + Debug = cms.untracked.bool( False ), + ErrorMask = cms.uint32( 0x0 ), + InputObjects = cms.InputTag( "rawDataCollector" ), + ExaminerMask = cms.uint32( 0x1febf3f6 ), + runDQM = cms.untracked.bool( False ), + UnpackStatusDigis = cms.bool( False ), + VisualFEDInspect = cms.untracked.bool( False ), + FormatedEventDump = cms.untracked.bool( False ), + UseFormatStatus = cms.bool( True ), + UseSelectiveUnpacking = cms.bool( True ), + VisualFEDShort = cms.untracked.bool( False ) ) -hltSiPixelClusters = cms.EDProducer( "SiPixelClusterProducer", - src = cms.InputTag( "hltSiPixelDigis" ), - ChannelThreshold = cms.int32( 1000 ), - maxNumberOfClusters = cms.int32( 20000 ), - VCaltoElectronGain = cms.int32( 65 ), - MissCalibrate = cms.untracked.bool( True ), - SplitClusters = cms.bool( False ), - VCaltoElectronOffset = cms.int32( -414 ), - payloadType = cms.string( "HLT" ), - SeedThreshold = cms.int32( 1000 ), - ClusterThreshold = cms.double( 4000.0 ) -) -hltSiPixelClustersCache = cms.EDProducer( "SiPixelClusterShapeCacheProducer", - src = cms.InputTag( "hltSiPixelClusters" ), - onDemand = cms.bool( False ) -) -hltSiPixelRecHits = cms.EDProducer( "SiPixelRecHitConverter", - VerboseLevel = cms.untracked.int32( 0 ), - src = cms.InputTag( "hltSiPixelClusters" ), - CPE = cms.string( "hltESPPixelCPEGeneric" ) -) -hltSiStripExcludedFEDListProducer = cms.EDProducer( "SiStripExcludedFEDListProducer", - ProductLabel = cms.InputTag( "rawDataCollector" ) -) -hltSiStripRawToClustersFacility = cms.EDProducer( "SiStripClusterizerFromRaw", - ProductLabel = cms.InputTag( "rawDataCollector" ), - DoAPVEmulatorCheck = cms.bool( False ), - Algorithms = cms.PSet( - SiStripFedZeroSuppressionMode = cms.uint32( 4 ), - CommonModeNoiseSubtractionMode = cms.string( "Median" ), - PedestalSubtractionFedMode = cms.bool( True ), - TruncateInSuppressor = cms.bool( True ), - doAPVRestore = cms.bool( False ), - useCMMeanMap = cms.bool( False ) - ), - Clusterizer = cms.PSet( - ChannelThreshold = cms.double( 2.0 ), - MaxSequentialBad = cms.uint32( 1 ), - MaxSequentialHoles = cms.uint32( 0 ), - Algorithm = cms.string( "ThreeThresholdAlgorithm" ), - MaxAdjacentBad = cms.uint32( 0 ), - QualityLabel = cms.string( "" ), - SeedThreshold = cms.double( 3.0 ), - ClusterThreshold = cms.double( 5.0 ), - setDetId = cms.bool( True ), - RemoveApvShots = cms.bool( True ) - ), - onDemand = cms.bool( True ) -) -hltSiStripClusters = cms.EDProducer( "MeasurementTrackerEventProducer", - inactivePixelDetectorLabels = cms.VInputTag( ), - stripClusterProducer = cms.string( "hltSiStripRawToClustersFacility" ), - pixelClusterProducer = cms.string( "hltSiPixelClusters" ), - switchOffPixelsIfEmpty = cms.bool( True ), - inactiveStripDetectorLabels = cms.VInputTag( 'hltSiStripExcludedFEDListProducer' ), - skipClusters = cms.InputTag( "" ), - measurementTracker = cms.string( "hltESPMeasurementTracker" ) -) -hltMixedLayerPairs = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2', - 'BPix1+BPix3', - 'BPix2+BPix3', - 'BPix1+FPix1_pos', - 'BPix1+FPix1_neg', - 'BPix1+FPix2_pos', - 'BPix1+FPix2_neg', - 'BPix2+FPix1_pos', - 'BPix2+FPix1_neg', - 'BPix2+FPix2_pos', - 'BPix2+FPix2_neg', - 'FPix1_pos+FPix2_pos', - 'FPix1_neg+FPix2_neg', - 'FPix2_pos+TEC1_pos', - 'FPix2_pos+TEC2_pos', - 'TEC1_pos+TEC2_pos', - 'TEC2_pos+TEC3_pos', - 'FPix2_neg+TEC1_neg', - 'FPix2_neg+TEC2_neg', - 'TEC1_neg+TEC2_neg', - 'TEC2_neg+TEC3_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( - useRingSlector = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - minRing = cms.int32( 1 ), - maxRing = cms.int32( 1 ) - ), - MTID = cms.PSet( ), - FPix = cms.PSet( - useErrorsFromParam = cms.bool( True ), - hitErrorRPhi = cms.double( 0.0051 ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - useErrorsFromParam = cms.bool( True ), - hitErrorRPhi = cms.double( 0.0027 ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ) - ), - TIB = cms.PSet( ) -) -hltEgammaElectronPixelSeeds = cms.EDProducer( "ElectronSeedProducer", - endcapSuperClusters = cms.InputTag( 'hltParticleFlowSuperClusterECALL1Seeded','hltParticleFlowSuperClusterECALEndcapWithPreshower' ), - SeedConfiguration = cms.PSet( - searchInTIDTEC = cms.bool( True ), - HighPtThreshold = cms.double( 35.0 ), - r2MinF = cms.double( -0.15 ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitPairGenerator" ), - useOnDemandTracker = cms.untracked.int32( 0 ), - SeedingLayers = cms.InputTag( "hltMixedLayerPairs" ) - ), - DeltaPhi1Low = cms.double( 0.23 ), - DeltaPhi1High = cms.double( 0.08 ), - ePhiMin1 = cms.double( -0.08 ), - LowPtThreshold = cms.double( 3.0 ), - RegionPSet = cms.PSet( - deltaPhiRegion = cms.double( 0.4 ), - originHalfLength = cms.double( 15.0 ), - useZInVertex = cms.bool( True ), - deltaEtaRegion = cms.double( 0.1 ), - ptMin = cms.double( 1.5 ), - originRadius = cms.double( 0.2 ), - VertexProducer = cms.InputTag( "dummyVertices" ) - ), - dynamicPhiRoad = cms.bool( False ), - ePhiMax1 = cms.double( 0.04 ), - measurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - SizeWindowENeg = cms.double( 0.675 ), - nSigmasDeltaZ1 = cms.double( 5.0 ), - rMaxI = cms.double( 0.2 ), - preFilteredSeeds = cms.bool( True ), - r2MaxF = cms.double( 0.15 ), - pPhiMin1 = cms.double( -0.04 ), - initialSeeds = cms.InputTag( "noSeedsHere" ), - pPhiMax1 = cms.double( 0.08 ), - SCEtCut = cms.double( 3.0 ), - z2MaxB = cms.double( 0.09 ), - fromTrackerSeeds = cms.bool( True ), - hcalRecHits = cms.InputTag( "hltHbhereco" ), - z2MinB = cms.double( -0.09 ), - rMinI = cms.double( -0.2 ), - hOverEConeSize = cms.double( 0.0 ), - hOverEHBMinE = cms.double( 999999.0 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - applyHOverECut = cms.bool( False ), - hOverEHFMinE = cms.double( 999999.0 ), - measurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - PhiMin2B = cms.double( -0.004 ), - PhiMin2F = cms.double( -0.004 ), - PhiMax2B = cms.double( 0.004 ), - PhiMax2F = cms.double( 0.004 ), - DeltaPhi2B = cms.double( 0.004 ), - DeltaPhi2F = cms.double( 0.004 ) - ), - barrelSuperClusters = cms.InputTag( 'hltParticleFlowSuperClusterECALL1Seeded','hltParticleFlowSuperClusterECALBarrel' ) -) -hltEle27WP75PixelMatchFilter = cms.EDFilter( "HLTElectronPixelMatchFilter", - saveTags = cms.bool( False ), - s2_threshold = cms.double( 0.4 ), - npixelmatchcut = cms.double( 1.0 ), - tanhSO10InterThres = cms.double( 1.0 ), - pixelVeto = cms.bool( False ), - doIsolated = cms.bool( True ), - s_a_phi1B = cms.double( 0.0069 ), - s_a_phi1F = cms.double( 0.0076 ), - s_a_phi1I = cms.double( 0.0088 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - candTag = cms.InputTag( "hltEle27WP75HcalIsoFilter" ), - tanhSO10ForwardThres = cms.double( 1.0 ), - L1IsoPixelSeedsTag = cms.InputTag( "hltEgammaElectronPixelSeeds" ), - L1NonIsoCand = cms.InputTag( "" ), - ncandcut = cms.int32( 1 ), - tanhSO10BarrelThres = cms.double( 0.35 ), - s_a_rF = cms.double( 0.04 ), - L1NonIsoPixelSeedsTag = cms.InputTag( "" ), - s_a_rI = cms.double( 0.027 ), - s_a_phi2I = cms.double( 7.0E-4 ), - useS = cms.bool( False ), - s_a_phi2B = cms.double( 3.7E-4 ), - s_a_zB = cms.double( 0.012 ), - s_a_phi2F = cms.double( 0.00906 ) -) -hltEgammaCkfTrackCandidatesForGSF = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltEgammaElectronPixelSeeds" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - cleanTrajectoryAfterInOut = cms.bool( True ), - useHitsSplitting = cms.bool( True ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( True ), - maxNSeeds = cms.uint32( 1000000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetTrajectoryBuilderForElectrons" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) -) -hltEgammaGsfTracks = cms.EDProducer( "GsfTrackProducer", - src = cms.InputTag( "hltEgammaCkfTrackCandidatesForGSF" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - producer = cms.string( "" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPGsfElectronFittingSmoother" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "hltESPMeasurementTracker" ), - GeometricInnerState = cms.bool( True ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - AlgorithmName = cms.string( "gsf" ), - Propagator = cms.string( "hltESPFwdElectronPropagator" ) -) -hltEgammaGsfElectrons = cms.EDProducer( "EgammaHLTPixelMatchElectronProducers", - BSProducer = cms.InputTag( "hltOnlineBeamSpot" ), - UseGsfTracks = cms.bool( True ), - TrackProducer = cms.InputTag( "" ), - GsfTrackProducer = cms.InputTag( "hltEgammaGsfTracks" ) -) -hltEgammaGsfTrackVars = cms.EDProducer( "EgammaHLTGsfTrackVarProducer", - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - beamSpotProducer = cms.InputTag( "hltOnlineBeamSpot" ), - upperTrackNrToRemoveCut = cms.int32( 9999 ), - lowerTrackNrToRemoveCut = cms.int32( -1 ), - inputCollection = cms.InputTag( "hltEgammaGsfTracks" ) -) -hltEle27WP75GsfOneOEMinusOneOPFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( 0.032 ), - thrOverEEE = cms.double( -1.0 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( -1.0 ), - thrRegularEB = cms.double( 0.032 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( 'hltEgammaGsfTrackVars','OneOESuperMinusOneOP' ), - candTag = cms.InputTag( "hltEle27WP75PixelMatchFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -hltEle27WP75GsfChi2Filter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( 2.8 ), - thrOverEEE = cms.double( -1.0 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( -1.0 ), - thrRegularEB = cms.double( 3.0 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( 'hltEgammaGsfTrackVars','Chi2' ), - candTag = cms.InputTag( "hltEle27WP75GsfOneOEMinusOneOPFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -hltEle27WP75GsfDetaFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( 0.0065 ), - thrOverEEE = cms.double( -1.0 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( -1.0 ), - thrRegularEB = cms.double( 0.0035 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( 'hltEgammaGsfTrackVars','Deta' ), - candTag = cms.InputTag( "hltEle27WP75GsfChi2Filter" ), - nonIsoTag = cms.InputTag( "" ) -) -hltEle27WP75GsfDphiFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( 0.035 ), - thrOverEEE = cms.double( -1.0 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( -1.0 ), - thrRegularEB = cms.double( 0.021 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( 'hltEgammaGsfTrackVars','Dphi' ), - candTag = cms.InputTag( "hltEle27WP75GsfDetaFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -hltElectronsVertex = cms.EDProducer( "VertexFromTrackProducer", - verbose = cms.untracked.bool( False ), - useTriggerFilterElectrons = cms.bool( False ), - beamSpotLabel = cms.InputTag( "hltOnlineBeamSpot" ), - isRecoCandidate = cms.bool( True ), - trackLabel = cms.InputTag( "hltEgammaGsfElectrons" ), - useTriggerFilterMuons = cms.bool( False ), - useBeamSpot = cms.bool( True ), - vertexLabel = cms.InputTag( "None" ), - triggerFilterElectronsSrc = cms.InputTag( "None" ), - triggerFilterMuonsSrc = cms.InputTag( "None" ), - useVertex = cms.bool( False ) -) -hltPixelLayerTriplets = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2+BPix3', - 'BPix1+BPix2+FPix1_pos', - 'BPix1+BPix2+FPix1_neg', - 'BPix1+FPix1_pos+FPix2_pos', - 'BPix1+FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - useErrorsFromParam = cms.bool( True ), - hitErrorRPhi = cms.double( 0.0051 ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - useErrorsFromParam = cms.bool( True ), - hitErrorRPhi = cms.double( 0.0027 ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ) - ), - TIB = cms.PSet( ) -) -hltPixelTracksElectrons = cms.EDProducer( "PixelTrackProducer", - useFilterWithES = cms.bool( False ), - FilterPSet = cms.PSet( - chi2 = cms.double( 1000.0 ), - nSigmaTipMaxTolerance = cms.double( 0.0 ), - ComponentName = cms.string( "PixelTrackFilterByKinematics" ), - nSigmaInvPtTolerance = cms.double( 0.0 ), - ptMin = cms.double( 0.1 ), - tipMax = cms.double( 1.0 ) - ), - passLabel = cms.string( "Pixel triplet primary tracks with vertex constraint" ), - FitterPSet = cms.PSet( - ComponentName = cms.string( "PixelFitterByHelixProjections" ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - fixImpactParameter = cms.double( 0.0 ) - ), - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "GlobalTrackingRegionWithVerticesProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.2 ), - ptMin = cms.double( 0.9 ), - originHalfLength = cms.double( 0.3 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - useFixedError = cms.bool( True ), - sigmaZVertex = cms.double( 3.0 ), - fixedError = cms.double( 0.2 ), - VertexCollection = cms.InputTag( "hltElectronsVertex" ), - useFoundVertices = cms.bool( True ), - nSigmaZ = cms.double( 4.0 ), - useFakeVertices = cms.bool( True ) - ) - ), - CleanerPSet = cms.PSet( ComponentName = cms.string( "PixelTrackCleanerBySharedHits" ) ), - OrderedHitsFactoryPSet = cms.PSet( - ComponentName = cms.string( "StandardHitTripletGenerator" ), - GeneratorPSet = cms.PSet( - useBending = cms.bool( True ), - useFixedPreFiltering = cms.bool( False ), - maxElement = cms.uint32( 100000 ), - phiPreFiltering = cms.double( 0.3 ), - extraHitRPhitolerance = cms.double( 0.06 ), - useMultScattering = cms.bool( True ), - SeedComparitorPSet = cms.PSet( - ComponentName = cms.string( "LowPtClusterShapeSeedComparitor" ), - clusterShapeCacheSrc = cms.InputTag( "hltSiPixelClustersCache" ) - ), - extraHitRZtolerance = cms.double( 0.06 ), - ComponentName = cms.string( "PixelTripletHLTGenerator" ) - ), - SeedingLayers = cms.InputTag( "hltPixelLayerTriplets" ) - ) -) -hltPixelVerticesElectrons = cms.EDProducer( "PixelVertexProducer", - WtAverage = cms.bool( True ), - Method2 = cms.bool( True ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - PVcomparer = cms.PSet( refToPSet_ = cms.string( "HLTPSetPvClusterComparer" ) ), - Verbosity = cms.int32( 0 ), - UseError = cms.bool( True ), - TrackCollection = cms.InputTag( "hltPixelTracksElectrons" ), - PtMin = cms.double( 1.0 ), - NTrkMin = cms.int32( 2 ), - ZOffset = cms.double( 5.0 ), - Finder = cms.string( "DivisiveVertexFinder" ), - ZSeparation = cms.double( 0.05 ) -) -hltIter0ElectronsPixelSeedsFromPixelTracks = cms.EDProducer( "SeedGeneratorFromProtoTracksEDProducer", - useEventsWithNoVertex = cms.bool( True ), - originHalfLength = cms.double( 0.3 ), - useProtoTrackKinematics = cms.bool( False ), - usePV = cms.bool( True ), - InputVertexCollection = cms.InputTag( "hltPixelVerticesElectrons" ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - InputCollection = cms.InputTag( "hltPixelTracksElectrons" ), - originRadius = cms.double( 0.1 ) -) -hltIter0ElectronsCkfTrackCandidates = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter0ElectronsPixelSeedsFromPixelTracks" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter0PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) -) -hltIter0ElectronsCtfWithMaterialTracks = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter0ElectronsCkfTrackCandidates" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -hltIter0ElectronsTrackSelectionHighPurity = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.4, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.35, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter0ElectronsCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesElectrons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.4, 4.0 ), - d0_par1 = cms.vdouble( 0.3, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -hltIter1ElectronsClustersRefRemoval = cms.EDProducer( "TrackClusterRemover", - minNumberOfLayersWithMeasBeforeFiltering = cms.int32( 0 ), - maxChi2 = cms.double( 9.0 ), - trajectories = cms.InputTag( "hltIter0ElectronsTrackSelectionHighPurity" ), - oldClusterRemovalInfo = cms.InputTag( "" ), - stripClusters = cms.InputTag( "hltSiStripRawToClustersFacility" ), - overrideTrkQuals = cms.InputTag( "" ), - pixelClusters = cms.InputTag( "hltSiPixelClusters" ), - TrackQuality = cms.string( "highPurity" ) -) -hltIter1ElectronsMaskedMeasurementTrackerEvent = cms.EDProducer( "MaskedMeasurementTrackerEventProducer", - clustersToSkip = cms.InputTag( "hltIter1ElectronsClustersRefRemoval" ), - OnDemand = cms.bool( False ), - src = cms.InputTag( "hltSiStripClusters" ) -) -hltIter1ElectronsPixelLayerTriplets = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2+BPix3', - 'BPix1+BPix2+FPix1_pos', - 'BPix1+BPix2+FPix1_neg', - 'BPix1+FPix1_pos+FPix2_pos', - 'BPix1+FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter1ElectronsClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0051 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter1ElectronsClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0027 ) - ), - TIB = cms.PSet( ) -) -hltIter1ElectronsPixelSeeds = cms.EDProducer( "SeedGeneratorFromRegionHitsEDProducer", - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "CandidateSeededTrackingRegionsProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.05 ), - ptMin = cms.double( 0.5 ), - input = cms.InputTag( "hltEgammaCandidates" ), - maxNRegions = cms.int32( 10 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - vertexCollection = cms.InputTag( "hltPixelVerticesElectrons" ), - zErrorBeamSpot = cms.double( 24.2 ), - deltaEta = cms.double( 0.5 ), - deltaPhi = cms.double( 0.5 ), - nSigmaZVertex = cms.double( 3.0 ), - nSigmaZBeamSpot = cms.double( 4.0 ), - mode = cms.string( "VerticesFixed" ), - maxNVertices = cms.int32( 3 ), - zErrorVetex = cms.double( 0.2 ) - ) - ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ), - ClusterCheckPSet = cms.PSet( - PixelClusterCollectionLabel = cms.InputTag( "hltSiPixelClusters" ), - MaxNumberOfCosmicClusters = cms.uint32( 50000 ), - doClusterCheck = cms.bool( False ), - ClusterCollectionLabel = cms.InputTag( "hltSiStripClusters" ), - MaxNumberOfPixelClusters = cms.uint32( 10000 ) - ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitTripletGenerator" ), - GeneratorPSet = cms.PSet( - useBending = cms.bool( True ), - useFixedPreFiltering = cms.bool( False ), - maxElement = cms.uint32( 100000 ), - phiPreFiltering = cms.double( 0.3 ), - extraHitRPhitolerance = cms.double( 0.032 ), - useMultScattering = cms.bool( True ), - ComponentName = cms.string( "PixelTripletHLTGenerator" ), - extraHitRZtolerance = cms.double( 0.037 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) - ), - SeedingLayers = cms.InputTag( "hltIter1ElectronsPixelLayerTriplets" ) - ), - SeedCreatorPSet = cms.PSet( - ComponentName = cms.string( "SeedFromConsecutiveHitsTripletOnlyCreator" ), - propagator = cms.string( "PropagatorWithMaterialParabolicMf" ), - SeedMomentumForBOFF = cms.double( 5.0 ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - TTRHBuilder = cms.string( "(unused)" ) -) -hltIter1ElectronsCkfTrackCandidates = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter1ElectronsPixelSeeds" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter1ElectronsMaskedMeasurementTrackerEvent" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter1PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) -) -hltIter1ElectronsCtfWithMaterialTracks = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter1ElectronsCkfTrackCandidates" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter1ElectronsMaskedMeasurementTrackerEvent" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -hltIter1ElectronsTrackSelectionHighPurityLoose = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.9, 3.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.8, 3.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter1ElectronsCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesElectrons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.9, 3.0 ), - d0_par1 = cms.vdouble( 0.85, 3.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -hltIter1ElectronsTrackSelectionHighPurityTight = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 5 ), - chi2n_par = cms.double( 0.4 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 1.0, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 1.0, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter1ElectronsCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesElectrons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 1.0, 4.0 ), - d0_par1 = cms.vdouble( 1.0, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -hltIter1ElectronsTrackSelectionHighPurity = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter1ElectronsTrackSelectionHighPurityLoose','hltIter1ElectronsTrackSelectionHighPurityTight' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter1ElectronsTrackSelectionHighPurityLoose','hltIter1ElectronsTrackSelectionHighPurityTight' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -hltIter1MergedForElectrons = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter0ElectronsTrackSelectionHighPurity','hltIter1ElectronsTrackSelectionHighPurity' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter0ElectronsTrackSelectionHighPurity','hltIter1ElectronsTrackSelectionHighPurity' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -hltIter2ElectronsClustersRefRemoval = cms.EDProducer( "TrackClusterRemover", - minNumberOfLayersWithMeasBeforeFiltering = cms.int32( 0 ), - maxChi2 = cms.double( 16.0 ), - trajectories = cms.InputTag( "hltIter1ElectronsTrackSelectionHighPurity" ), - oldClusterRemovalInfo = cms.InputTag( "hltIter1ElectronsClustersRefRemoval" ), - stripClusters = cms.InputTag( "hltSiStripRawToClustersFacility" ), - overrideTrkQuals = cms.InputTag( "" ), - pixelClusters = cms.InputTag( "hltSiPixelClusters" ), - TrackQuality = cms.string( "highPurity" ) -) -hltIter2ElectronsMaskedMeasurementTrackerEvent = cms.EDProducer( "MaskedMeasurementTrackerEventProducer", - clustersToSkip = cms.InputTag( "hltIter2ElectronsClustersRefRemoval" ), - OnDemand = cms.bool( False ), - src = cms.InputTag( "hltSiStripClusters" ) -) -hltIter2ElectronsPixelLayerPairs = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2', - 'BPix1+BPix3', - 'BPix2+BPix3', - 'BPix1+FPix1_pos', - 'BPix1+FPix1_neg', - 'BPix1+FPix2_pos', - 'BPix1+FPix2_neg', - 'BPix2+FPix1_pos', - 'BPix2+FPix1_neg', - 'BPix2+FPix2_pos', - 'BPix2+FPix2_neg', - 'FPix1_pos+FPix2_pos', - 'FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter2ElectronsClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0051 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter2ElectronsClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0027 ) - ), - TIB = cms.PSet( ) -) -hltIter2ElectronsPixelSeeds = cms.EDProducer( "SeedGeneratorFromRegionHitsEDProducer", - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "CandidateSeededTrackingRegionsProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.05 ), - ptMin = cms.double( 1.2 ), - deltaEta = cms.double( 0.5 ), - deltaPhi = cms.double( 0.5 ), - vertexCollection = cms.InputTag( "hltPixelVerticesElectrons" ), - input = cms.InputTag( "hltEgammaCandidates" ), - mode = cms.string( "VerticesFixed" ), - maxNRegions = cms.int32( 10 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - maxNVertices = cms.int32( 3 ), - zErrorBeamSpot = cms.double( 24.2 ), - nSigmaZVertex = cms.double( 3.0 ), - nSigmaZBeamSpot = cms.double( 4.0 ), - zErrorVetex = cms.double( 0.2 ) - ) - ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ), - ClusterCheckPSet = cms.PSet( - PixelClusterCollectionLabel = cms.InputTag( "hltSiPixelClusters" ), - MaxNumberOfCosmicClusters = cms.uint32( 50000 ), - doClusterCheck = cms.bool( False ), - ClusterCollectionLabel = cms.InputTag( "hltSiStripClusters" ), - MaxNumberOfPixelClusters = cms.uint32( 10000 ) - ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitPairGenerator" ), - GeneratorPSet = cms.PSet( - maxElement = cms.uint32( 100000 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) - ), - SeedingLayers = cms.InputTag( "hltIter2ElectronsPixelLayerPairs" ) - ), - SeedCreatorPSet = cms.PSet( - ComponentName = cms.string( "SeedFromConsecutiveHitsCreator" ), - propagator = cms.string( "PropagatorWithMaterialParabolicMf" ), - SeedMomentumForBOFF = cms.double( 5.0 ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - TTRHBuilder = cms.string( "(unused)" ) -) -hltIter2ElectronsCkfTrackCandidates = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter2ElectronsPixelSeeds" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter2ElectronsMaskedMeasurementTrackerEvent" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter2PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) -) -hltIter2ElectronsCtfWithMaterialTracks = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter2ElectronsCkfTrackCandidates" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter2ElectronsMaskedMeasurementTrackerEvent" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -hltIter2ElectronsTrackSelectionHighPurity = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.4, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.35, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter2ElectronsCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesElectrons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.4, 4.0 ), - d0_par1 = cms.vdouble( 0.3, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -hltIter2MergedForElectrons = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter1MergedForElectrons','hltIter2ElectronsTrackSelectionHighPurity' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter1MergedForElectrons','hltIter2ElectronsTrackSelectionHighPurity' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -hltEgammaEleGsfTrackIso = cms.EDProducer( "EgammaHLTElectronTrackIsolationProducers", - egTrkIsoStripEndcap = cms.double( 0.03 ), - egTrkIsoVetoConeSizeBarrel = cms.double( 0.03 ), - useGsfTrack = cms.bool( True ), - useSCRefs = cms.bool( True ), - trackProducer = cms.InputTag( "hltIter2MergedForElectrons" ), - egTrkIsoStripBarrel = cms.double( 0.03 ), - electronProducer = cms.InputTag( "hltEgammaGsfElectrons" ), - egTrkIsoConeSize = cms.double( 0.3 ), - egTrkIsoRSpan = cms.double( 999999.0 ), - egTrkIsoVetoConeSizeEndcap = cms.double( 0.03 ), - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - beamSpotProducer = cms.InputTag( "hltOnlineBeamSpot" ), - egTrkIsoPtMin = cms.double( 1.0 ), - egTrkIsoZSpan = cms.double( 0.15 ) -) -hltEle27WP75GsfTrackIsoFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( True ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( -1.0 ), - thrOverEEE = cms.double( 0.05 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.05 ), - thrRegularEB = cms.double( -1.0 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaEleGsfTrackIso" ), - candTag = cms.InputTag( "hltEle27WP75GsfDphiFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -hltL1sL1SingleMu16ORSingleMu25 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleMu16 OR L1_SingleMu25" ), - saveTags = cms.bool( True ), - L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), - L1UseL1TriggerObjectMaps = cms.bool( True ), - L1UseAliasesForSeeding = cms.bool( True ), - L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), - L1CollectionsTag = cms.InputTag( "hltL1extraParticles" ), - L1NrBxInEvent = cms.int32( 3 ), - L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), - L1TechTriggerSeeding = cms.bool( False ) -) -hltPreMu50 = cms.EDFilter( "HLTPrescaler", - L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), - offset = cms.uint32( 0 ) -) -hltL1fL1sMu16orMu25L1Filtered0 = cms.EDFilter( "HLTMuonL1Filter", - saveTags = cms.bool( False ), - CSCTFtag = cms.InputTag( "unused" ), - PreviousCandTag = cms.InputTag( "hltL1sL1SingleMu16ORSingleMu25" ), - MinPt = cms.double( 0.0 ), - MinN = cms.int32( 1 ), - MaxEta = cms.double( 2.5 ), - SelectQualities = cms.vint32( ), - CandTag = cms.InputTag( "hltL1extraParticles" ), - ExcludeSingleSegmentCSC = cms.bool( False ) -) -hltMuonDTDigis = cms.EDProducer( "DTUnpackingModule", - useStandardFEDid = cms.bool( True ), - maxFEDid = cms.untracked.int32( 779 ), - inputLabel = cms.InputTag( "rawDataCollector" ), - minFEDid = cms.untracked.int32( 770 ), - dataType = cms.string( "DDU" ), - readOutParameters = cms.PSet( - debug = cms.untracked.bool( False ), - rosParameters = cms.PSet( - writeSC = cms.untracked.bool( True ), - readingDDU = cms.untracked.bool( True ), - performDataIntegrityMonitor = cms.untracked.bool( False ), - readDDUIDfromDDU = cms.untracked.bool( True ), - debug = cms.untracked.bool( False ), - localDAQ = cms.untracked.bool( False ) - ), - localDAQ = cms.untracked.bool( False ), - performDataIntegrityMonitor = cms.untracked.bool( False ) - ), - dqmOnly = cms.bool( False ) -) -hltDt1DRecHits = cms.EDProducer( "DTRecHitProducer", - debug = cms.untracked.bool( False ), - recAlgoConfig = cms.PSet( - tTrigMode = cms.string( "DTTTrigSyncFromDB" ), - minTime = cms.double( -3.0 ), - stepTwoFromDigi = cms.bool( False ), - doVdriftCorr = cms.bool( True ), - debug = cms.untracked.bool( False ), - maxTime = cms.double( 420.0 ), - tTrigModeConfig = cms.PSet( - vPropWire = cms.double( 24.4 ), - doTOFCorrection = cms.bool( True ), - tofCorrType = cms.int32( 0 ), - wirePropCorrType = cms.int32( 0 ), - tTrigLabel = cms.string( "" ), - doWirePropCorrection = cms.bool( True ), - doT0Correction = cms.bool( True ), - debug = cms.untracked.bool( False ) - ), - useUncertDB = cms.bool( True ) - ), - dtDigiLabel = cms.InputTag( "hltMuonDTDigis" ), - recAlgo = cms.string( "DTLinearDriftFromDBAlgo" ) -) -hltDt4DSegments = cms.EDProducer( "DTRecSegment4DProducer", - debug = cms.untracked.bool( False ), - Reco4DAlgoName = cms.string( "DTCombinatorialPatternReco4D" ), - recHits2DLabel = cms.InputTag( "dt2DSegments" ), - recHits1DLabel = cms.InputTag( "hltDt1DRecHits" ), - Reco4DAlgoConfig = cms.PSet( - segmCleanerMode = cms.int32( 2 ), - Reco2DAlgoName = cms.string( "DTCombinatorialPatternReco" ), - recAlgoConfig = cms.PSet( - tTrigMode = cms.string( "DTTTrigSyncFromDB" ), - minTime = cms.double( -3.0 ), - stepTwoFromDigi = cms.bool( False ), - doVdriftCorr = cms.bool( True ), - debug = cms.untracked.bool( False ), - maxTime = cms.double( 420.0 ), - tTrigModeConfig = cms.PSet( - vPropWire = cms.double( 24.4 ), - doTOFCorrection = cms.bool( True ), - tofCorrType = cms.int32( 0 ), - wirePropCorrType = cms.int32( 0 ), - tTrigLabel = cms.string( "" ), - doWirePropCorrection = cms.bool( True ), - doT0Correction = cms.bool( True ), - debug = cms.untracked.bool( False ) - ), - useUncertDB = cms.bool( True ) - ), - nSharedHitsMax = cms.int32( 2 ), - hit_afterT0_resolution = cms.double( 0.03 ), - Reco2DAlgoConfig = cms.PSet( - segmCleanerMode = cms.int32( 2 ), - recAlgoConfig = cms.PSet( - tTrigMode = cms.string( "DTTTrigSyncFromDB" ), - minTime = cms.double( -3.0 ), - stepTwoFromDigi = cms.bool( False ), - doVdriftCorr = cms.bool( True ), - debug = cms.untracked.bool( False ), - maxTime = cms.double( 420.0 ), - tTrigModeConfig = cms.PSet( - vPropWire = cms.double( 24.4 ), - doTOFCorrection = cms.bool( True ), - tofCorrType = cms.int32( 0 ), - wirePropCorrType = cms.int32( 0 ), - tTrigLabel = cms.string( "" ), - doWirePropCorrection = cms.bool( True ), - doT0Correction = cms.bool( True ), - debug = cms.untracked.bool( False ) - ), - useUncertDB = cms.bool( True ) - ), - nSharedHitsMax = cms.int32( 2 ), - AlphaMaxPhi = cms.double( 1.0 ), - hit_afterT0_resolution = cms.double( 0.03 ), - MaxAllowedHits = cms.uint32( 50 ), - performT0_vdriftSegCorrection = cms.bool( False ), - AlphaMaxTheta = cms.double( 0.9 ), - debug = cms.untracked.bool( False ), - recAlgo = cms.string( "DTLinearDriftFromDBAlgo" ), - nUnSharedHitsMin = cms.int32( 2 ), - performT0SegCorrection = cms.bool( False ), - perform_delta_rejecting = cms.bool( False ) - ), - performT0_vdriftSegCorrection = cms.bool( False ), - debug = cms.untracked.bool( False ), - recAlgo = cms.string( "DTLinearDriftFromDBAlgo" ), - nUnSharedHitsMin = cms.int32( 2 ), - AllDTRecHits = cms.bool( True ), - performT0SegCorrection = cms.bool( False ), - perform_delta_rejecting = cms.bool( False ) - ) -) -hltMuonCSCDigis = cms.EDProducer( "CSCDCCUnpacker", - PrintEventNumber = cms.untracked.bool( False ), - SuppressZeroLCT = cms.untracked.bool( True ), - UseExaminer = cms.bool( True ), - Debug = cms.untracked.bool( False ), - ErrorMask = cms.uint32( 0x0 ), - InputObjects = cms.InputTag( "rawDataCollector" ), - ExaminerMask = cms.uint32( 0x1febf3f6 ), - runDQM = cms.untracked.bool( False ), - UnpackStatusDigis = cms.bool( False ), - VisualFEDInspect = cms.untracked.bool( False ), - FormatedEventDump = cms.untracked.bool( False ), - UseFormatStatus = cms.bool( True ), - UseSelectiveUnpacking = cms.bool( True ), - VisualFEDShort = cms.untracked.bool( False ) -) -hltCsc2DRecHits = cms.EDProducer( "CSCRecHitDProducer", - XTasymmetry_ME1b = cms.double( 0.0 ), - XTasymmetry_ME1a = cms.double( 0.0 ), - ConstSyst_ME1a = cms.double( 0.022 ), - ConstSyst_ME1b = cms.double( 0.007 ), - XTasymmetry_ME41 = cms.double( 0.0 ), - CSCStripxtalksOffset = cms.double( 0.03 ), - CSCUseCalibrations = cms.bool( True ), - CSCUseTimingCorrections = cms.bool( True ), - CSCNoOfTimeBinsForDynamicPedestal = cms.int32( 2 ), - XTasymmetry_ME22 = cms.double( 0.0 ), - UseFivePoleFit = cms.bool( True ), - XTasymmetry_ME21 = cms.double( 0.0 ), - ConstSyst_ME21 = cms.double( 0.0 ), - CSCDebug = cms.untracked.bool( False ), - ConstSyst_ME22 = cms.double( 0.0 ), - CSCUseGasGainCorrections = cms.bool( False ), - XTasymmetry_ME31 = cms.double( 0.0 ), - readBadChambers = cms.bool( True ), - NoiseLevel_ME13 = cms.double( 8.0 ), - NoiseLevel_ME12 = cms.double( 9.0 ), - NoiseLevel_ME32 = cms.double( 9.0 ), - NoiseLevel_ME31 = cms.double( 9.0 ), - XTasymmetry_ME32 = cms.double( 0.0 ), - ConstSyst_ME41 = cms.double( 0.0 ), - CSCStripClusterSize = cms.untracked.int32( 3 ), - CSCStripClusterChargeCut = cms.double( 25.0 ), - CSCStripPeakThreshold = cms.double( 10.0 ), - readBadChannels = cms.bool( False ), - UseParabolaFit = cms.bool( False ), - XTasymmetry_ME13 = cms.double( 0.0 ), - XTasymmetry_ME12 = cms.double( 0.0 ), - wireDigiTag = cms.InputTag( 'hltMuonCSCDigis','MuonCSCWireDigi' ), - ConstSyst_ME12 = cms.double( 0.0 ), - ConstSyst_ME13 = cms.double( 0.0 ), - ConstSyst_ME32 = cms.double( 0.0 ), - ConstSyst_ME31 = cms.double( 0.0 ), - UseAverageTime = cms.bool( False ), - NoiseLevel_ME1a = cms.double( 7.0 ), - NoiseLevel_ME1b = cms.double( 8.0 ), - CSCWireClusterDeltaT = cms.int32( 1 ), - CSCUseStaticPedestals = cms.bool( False ), - stripDigiTag = cms.InputTag( 'hltMuonCSCDigis','MuonCSCStripDigi' ), - CSCstripWireDeltaTime = cms.int32( 8 ), - NoiseLevel_ME21 = cms.double( 9.0 ), - NoiseLevel_ME22 = cms.double( 9.0 ), - NoiseLevel_ME41 = cms.double( 9.0 ) -) -hltCscSegments = cms.EDProducer( "CSCSegmentProducer", - inputObjects = cms.InputTag( "hltCsc2DRecHits" ), - algo_psets = cms.VPSet( - cms.PSet( chamber_types = cms.vstring( 'ME1/a', - 'ME1/b', - 'ME1/2', - 'ME1/3', - 'ME2/1', - 'ME2/2', - 'ME3/1', - 'ME3/2', - 'ME4/1', - 'ME4/2' ), - algo_name = cms.string( "CSCSegAlgoST" ), - parameters_per_chamber_type = cms.vint32( 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 ), - algo_psets = cms.VPSet( - cms.PSet( maxRatioResidualPrune = cms.double( 3.0 ), - yweightPenalty = cms.double( 1.5 ), - maxRecHitsInCluster = cms.int32( 20 ), - dPhiFineMax = cms.double( 0.025 ), - preClusteringUseChaining = cms.bool( True ), - ForceCovariance = cms.bool( False ), - hitDropLimit6Hits = cms.double( 0.3333 ), - NormChi2Cut2D = cms.double( 20.0 ), - BPMinImprovement = cms.double( 10000.0 ), - Covariance = cms.double( 0.0 ), - tanPhiMax = cms.double( 0.5 ), - SeedBig = cms.double( 0.0015 ), - onlyBestSegment = cms.bool( False ), - dRPhiFineMax = cms.double( 8.0 ), - SeedSmall = cms.double( 2.0E-4 ), - curvePenalty = cms.double( 2.0 ), - dXclusBoxMax = cms.double( 4.0 ), - BrutePruning = cms.bool( True ), - curvePenaltyThreshold = cms.double( 0.85 ), - CorrectTheErrors = cms.bool( True ), - hitDropLimit4Hits = cms.double( 0.6 ), - useShowering = cms.bool( False ), - CSCDebug = cms.untracked.bool( False ), - tanThetaMax = cms.double( 1.2 ), - NormChi2Cut3D = cms.double( 10.0 ), - minHitsPerSegment = cms.int32( 3 ), - ForceCovarianceAll = cms.bool( False ), - yweightPenaltyThreshold = cms.double( 1.0 ), - prePrunLimit = cms.double( 3.17 ), - hitDropLimit5Hits = cms.double( 0.8 ), - preClustering = cms.bool( True ), - prePrun = cms.bool( True ), - maxDPhi = cms.double( 999.0 ), - maxDTheta = cms.double( 999.0 ), - Pruning = cms.bool( True ), - dYclusBoxMax = cms.double( 8.0 ) - ), - cms.PSet( maxRatioResidualPrune = cms.double( 3.0 ), - yweightPenalty = cms.double( 1.5 ), - maxRecHitsInCluster = cms.int32( 24 ), - dPhiFineMax = cms.double( 0.025 ), - preClusteringUseChaining = cms.bool( True ), - ForceCovariance = cms.bool( False ), - hitDropLimit6Hits = cms.double( 0.3333 ), - NormChi2Cut2D = cms.double( 20.0 ), - BPMinImprovement = cms.double( 10000.0 ), - Covariance = cms.double( 0.0 ), - tanPhiMax = cms.double( 0.5 ), - SeedBig = cms.double( 0.0015 ), - onlyBestSegment = cms.bool( False ), - dRPhiFineMax = cms.double( 8.0 ), - SeedSmall = cms.double( 2.0E-4 ), - curvePenalty = cms.double( 2.0 ), - dXclusBoxMax = cms.double( 4.0 ), - BrutePruning = cms.bool( True ), - curvePenaltyThreshold = cms.double( 0.85 ), - CorrectTheErrors = cms.bool( True ), - hitDropLimit4Hits = cms.double( 0.6 ), - useShowering = cms.bool( False ), - CSCDebug = cms.untracked.bool( False ), - tanThetaMax = cms.double( 1.2 ), - NormChi2Cut3D = cms.double( 10.0 ), - minHitsPerSegment = cms.int32( 3 ), - ForceCovarianceAll = cms.bool( False ), - yweightPenaltyThreshold = cms.double( 1.0 ), - prePrunLimit = cms.double( 3.17 ), - hitDropLimit5Hits = cms.double( 0.8 ), - preClustering = cms.bool( True ), - prePrun = cms.bool( True ), - maxDPhi = cms.double( 999.0 ), - maxDTheta = cms.double( 999.0 ), - Pruning = cms.bool( True ), - dYclusBoxMax = cms.double( 8.0 ) - ) - ) - ) - ), - algo_type = cms.int32( 1 ) -) -hltMuonRPCDigis = cms.EDProducer( "RPCUnpackingModule", - InputLabel = cms.InputTag( "rawDataCollector" ), - doSynchro = cms.bool( False ) -) -hltRpcRecHits = cms.EDProducer( "RPCRecHitProducer", - recAlgoConfig = cms.PSet( ), - deadvecfile = cms.FileInPath( "RecoLocalMuon/RPCRecHit/data/RPCDeadVec.dat" ), - rpcDigiLabel = cms.InputTag( "hltMuonRPCDigis" ), - maskvecfile = cms.FileInPath( "RecoLocalMuon/RPCRecHit/data/RPCMaskVec.dat" ), - recAlgo = cms.string( "RPCRecHitStandardAlgo" ), - deadSource = cms.string( "File" ), - maskSource = cms.string( "File" ) -) -hltL2OfflineMuonSeeds = cms.EDProducer( "MuonSeedGenerator", - SMB_21 = cms.vdouble( 1.043, -0.124, 0.0, 0.183, 0.0, 0.0 ), - SMB_20 = cms.vdouble( 1.011, -0.052, 0.0, 0.188, 0.0, 0.0 ), - SMB_22 = cms.vdouble( 1.474, -0.758, 0.0, 0.185, 0.0, 0.0 ), - OL_2213 = cms.vdouble( 0.117, 0.0, 0.0, 0.044, 0.0, 0.0 ), - SME_11 = cms.vdouble( 3.295, -1.527, 0.112, 0.378, 0.02, 0.0 ), - SME_13 = cms.vdouble( -1.286, 1.711, 0.0, 0.356, 0.0, 0.0 ), - SME_12 = cms.vdouble( 0.102, 0.599, 0.0, 0.38, 0.0, 0.0 ), - DT_34_2_scale = cms.vdouble( -11.901897, 0.0 ), - OL_1213_0_scale = cms.vdouble( -4.488158, 0.0 ), - OL_1222_0_scale = cms.vdouble( -5.810449, 0.0 ), - DT_13 = cms.vdouble( 0.315, 0.068, -0.127, 0.051, -0.002, 0.0 ), - DT_12 = cms.vdouble( 0.183, 0.054, -0.087, 0.028, 0.002, 0.0 ), - DT_14 = cms.vdouble( 0.359, 0.052, -0.107, 0.072, -0.004, 0.0 ), - CSC_13_3_scale = cms.vdouble( -1.701268, 0.0 ), - DT_24_2_scale = cms.vdouble( -6.63094, 0.0 ), - CSC_23 = cms.vdouble( -0.081, 0.113, -0.029, 0.015, 0.008, 0.0 ), - CSC_24 = cms.vdouble( 0.004, 0.021, -0.002, 0.053, 0.0, 0.0 ), - OL_2222 = cms.vdouble( 0.107, 0.0, 0.0, 0.04, 0.0, 0.0 ), - DT_14_2_scale = cms.vdouble( -4.808546, 0.0 ), - SMB_10 = cms.vdouble( 1.387, -0.038, 0.0, 0.19, 0.0, 0.0 ), - SMB_11 = cms.vdouble( 1.247, 0.72, -0.802, 0.229, -0.075, 0.0 ), - SMB_12 = cms.vdouble( 2.128, -0.956, 0.0, 0.199, 0.0, 0.0 ), - SME_21 = cms.vdouble( -0.529, 1.194, -0.358, 0.472, 0.086, 0.0 ), - SME_22 = cms.vdouble( -1.207, 1.491, -0.251, 0.189, 0.243, 0.0 ), - DT_13_2_scale = cms.vdouble( -4.257687, 0.0 ), - CSC_34 = cms.vdouble( 0.062, -0.067, 0.019, 0.021, 0.003, 0.0 ), - SME_22_0_scale = cms.vdouble( -3.457901, 0.0 ), - DT_24_1_scale = cms.vdouble( -7.490909, 0.0 ), - OL_1232_0_scale = cms.vdouble( -5.964634, 0.0 ), - DT_23_1_scale = cms.vdouble( -5.320346, 0.0 ), - SME_13_0_scale = cms.vdouble( 0.104905, 0.0 ), - SMB_22_0_scale = cms.vdouble( 1.346681, 0.0 ), - CSC_12_1_scale = cms.vdouble( -6.434242, 0.0 ), - DT_34 = cms.vdouble( 0.044, 0.004, -0.013, 0.029, 0.003, 0.0 ), - SME_32 = cms.vdouble( -0.901, 1.333, -0.47, 0.41, 0.073, 0.0 ), - SME_31 = cms.vdouble( -1.594, 1.482, -0.317, 0.487, 0.097, 0.0 ), - CSC_13_2_scale = cms.vdouble( -6.077936, 0.0 ), - crackEtas = cms.vdouble( 0.2, 1.6, 1.7 ), - SME_11_0_scale = cms.vdouble( 1.325085, 0.0 ), - SMB_20_0_scale = cms.vdouble( 1.486168, 0.0 ), - DT_13_1_scale = cms.vdouble( -4.520923, 0.0 ), - CSC_24_1_scale = cms.vdouble( -6.055701, 0.0 ), - CSC_01_1_scale = cms.vdouble( -1.915329, 0.0 ), - DT_23 = cms.vdouble( 0.13, 0.023, -0.057, 0.028, 0.004, 0.0 ), - DT_24 = cms.vdouble( 0.176, 0.014, -0.051, 0.051, 0.003, 0.0 ), - SMB_12_0_scale = cms.vdouble( 2.283221, 0.0 ), - deltaPhiSearchWindow = cms.double( 0.25 ), - SMB_30_0_scale = cms.vdouble( -3.629838, 0.0 ), - SME_42 = cms.vdouble( -0.003, 0.005, 0.005, 0.608, 0.076, 0.0 ), - SME_41 = cms.vdouble( -0.003, 0.005, 0.005, 0.608, 0.076, 0.0 ), - deltaEtaSearchWindow = cms.double( 0.2 ), - CSC_12_2_scale = cms.vdouble( -1.63622, 0.0 ), - DT_34_1_scale = cms.vdouble( -13.783765, 0.0 ), - CSC_34_1_scale = cms.vdouble( -11.520507, 0.0 ), - OL_2213_0_scale = cms.vdouble( -7.239789, 0.0 ), - SMB_32_0_scale = cms.vdouble( -3.054156, 0.0 ), - CSC_12_3_scale = cms.vdouble( -1.63622, 0.0 ), - deltaEtaCrackSearchWindow = cms.double( 0.25 ), - SME_21_0_scale = cms.vdouble( -0.040862, 0.0 ), - OL_1232 = cms.vdouble( 0.184, 0.0, 0.0, 0.066, 0.0, 0.0 ), - DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), - SMB_10_0_scale = cms.vdouble( 2.448566, 0.0 ), - EnableDTMeasurement = cms.bool( True ), - CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), - CSC_23_2_scale = cms.vdouble( -6.079917, 0.0 ), - scaleDT = cms.bool( True ), - DT_12_2_scale = cms.vdouble( -3.518165, 0.0 ), - OL_1222 = cms.vdouble( 0.848, -0.591, 0.0, 0.062, 0.0, 0.0 ), - CSC_23_1_scale = cms.vdouble( -19.084285, 0.0 ), - OL_1213 = cms.vdouble( 0.96, -0.737, 0.0, 0.052, 0.0, 0.0 ), - CSC_02 = cms.vdouble( 0.612, -0.207, 0.0, 0.067, -0.001, 0.0 ), - CSC_03 = cms.vdouble( 0.787, -0.338, 0.029, 0.101, -0.008, 0.0 ), - CSC_01 = cms.vdouble( 0.166, 0.0, 0.0, 0.031, 0.0, 0.0 ), - SMB_32 = cms.vdouble( 0.67, -0.327, 0.0, 0.22, 0.0, 0.0 ), - SMB_30 = cms.vdouble( 0.505, -0.022, 0.0, 0.215, 0.0, 0.0 ), - SMB_31 = cms.vdouble( 0.549, -0.145, 0.0, 0.207, 0.0, 0.0 ), - crackWindow = cms.double( 0.04 ), - CSC_14_3_scale = cms.vdouble( -1.969563, 0.0 ), - SMB_31_0_scale = cms.vdouble( -3.323768, 0.0 ), - DT_12_1_scale = cms.vdouble( -3.692398, 0.0 ), - SMB_21_0_scale = cms.vdouble( 1.58384, 0.0 ), - DT_23_2_scale = cms.vdouble( -5.117625, 0.0 ), - SME_12_0_scale = cms.vdouble( 2.279181, 0.0 ), - DT_14_1_scale = cms.vdouble( -5.644816, 0.0 ), - beamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), - SMB_11_0_scale = cms.vdouble( 2.56363, 0.0 ), - EnableCSCMeasurement = cms.bool( True ), - CSC_14 = cms.vdouble( 0.606, -0.181, -0.002, 0.111, -0.003, 0.0 ), - OL_2222_0_scale = cms.vdouble( -7.667231, 0.0 ), - CSC_13 = cms.vdouble( 0.901, -1.302, 0.533, 0.045, 0.005, 0.0 ), - CSC_12 = cms.vdouble( -0.161, 0.254, -0.047, 0.042, -0.007, 0.0 ) -) -hltL2MuonSeeds = cms.EDProducer( "L2MuonSeedGenerator", - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'SteppingHelixPropagatorAny' ), - RPCLayers = cms.bool( True ), - UseMuonNavigation = cms.untracked.bool( True ) - ), - InputObjects = cms.InputTag( "hltL1extraParticles" ), - L1MaxEta = cms.double( 2.5 ), - OfflineSeedLabel = cms.untracked.InputTag( "hltL2OfflineMuonSeeds" ), - L1MinPt = cms.double( 0.0 ), - L1MinQuality = cms.uint32( 1 ), - GMTReadoutCollection = cms.InputTag( "hltGtDigis" ), - UseUnassociatedL1 = cms.bool( False ), - UseOfflineSeed = cms.untracked.bool( True ), - Propagator = cms.string( "SteppingHelixPropagatorAny" ) -) -hltL2Muons = cms.EDProducer( "L2MuonProducer", - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPFastSteppingHelixPropagatorAny', - 'hltESPFastSteppingHelixPropagatorOpposite' ), - RPCLayers = cms.bool( True ), - UseMuonNavigation = cms.untracked.bool( True ) - ), - InputObjects = cms.InputTag( "hltL2MuonSeeds" ), - SeedTransformerParameters = cms.PSet( - Fitter = cms.string( "hltESPKFFittingSmootherForL2Muon" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - NMinRecHits = cms.uint32( 2 ), - UseSubRecHits = cms.bool( False ), - Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - RescaleError = cms.double( 100.0 ) - ), - L2TrajBuilderParameters = cms.PSet( - DoRefit = cms.bool( False ), - SeedPropagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - FilterParameters = cms.PSet( - NumberOfSigma = cms.double( 3.0 ), - FitDirection = cms.string( "insideOut" ), - DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), - MaxChi2 = cms.double( 1000.0 ), - MuonTrajectoryUpdatorParameters = cms.PSet( - MaxChi2 = cms.double( 25.0 ), - RescaleErrorFactor = cms.double( 100.0 ), - Granularity = cms.int32( 0 ), - ExcludeRPCFromFit = cms.bool( False ), - UseInvalidHits = cms.bool( True ), - RescaleError = cms.bool( False ) - ), - EnableRPCMeasurement = cms.bool( True ), - CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), - EnableDTMeasurement = cms.bool( True ), - RPCRecSegmentLabel = cms.InputTag( "hltRpcRecHits" ), - Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - EnableCSCMeasurement = cms.bool( True ) - ), - NavigationType = cms.string( "Standard" ), - SeedTransformerParameters = cms.PSet( - Fitter = cms.string( "hltESPKFFittingSmootherForL2Muon" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - NMinRecHits = cms.uint32( 2 ), - UseSubRecHits = cms.bool( False ), - Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - RescaleError = cms.double( 100.0 ) - ), - DoBackwardFilter = cms.bool( True ), - SeedPosition = cms.string( "in" ), - BWFilterParameters = cms.PSet( - NumberOfSigma = cms.double( 3.0 ), - CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), - FitDirection = cms.string( "outsideIn" ), - DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), - MaxChi2 = cms.double( 100.0 ), - MuonTrajectoryUpdatorParameters = cms.PSet( - MaxChi2 = cms.double( 25.0 ), - RescaleErrorFactor = cms.double( 100.0 ), - Granularity = cms.int32( 0 ), - ExcludeRPCFromFit = cms.bool( False ), - UseInvalidHits = cms.bool( True ), - RescaleError = cms.bool( False ) - ), - EnableRPCMeasurement = cms.bool( True ), - BWSeedType = cms.string( "fromGenerator" ), - EnableDTMeasurement = cms.bool( True ), - RPCRecSegmentLabel = cms.InputTag( "hltRpcRecHits" ), - Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - EnableCSCMeasurement = cms.bool( True ) - ), - DoSeedRefit = cms.bool( False ) - ), - DoSeedRefit = cms.bool( False ), - TrackLoaderParameters = cms.PSet( - Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), - DoSmoothing = cms.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MuonUpdatorAtVertexParameters = cms.PSet( - MaxChi2 = cms.double( 1000000.0 ), - BeamSpotPosition = cms.vdouble( 0.0, 0.0, 0.0 ), - Propagator = cms.string( "hltESPFastSteppingHelixPropagatorOpposite" ), - BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) - ), - VertexConstraint = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - MuonTrajectoryBuilder = cms.string( "Exhaustive" ) -) -hltL2MuonCandidates = cms.EDProducer( "L2MuonCandidateProducer", - InputObjects = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) -) -hltL2fL1sMu16orMu25L1f0L2Filtered16Q = cms.EDFilter( "HLTMuonL2PreFilter", - saveTags = cms.bool( True ), - MaxDr = cms.double( 9999.0 ), - CutOnChambers = cms.bool( False ), - PreviousCandTag = cms.InputTag( "hltL1fL1sMu16orMu25L1Filtered0" ), - MinPt = cms.double( 16.0 ), - MinN = cms.int32( 1 ), - SeedMapTag = cms.InputTag( "hltL2Muons" ), - MaxEta = cms.double( 2.5 ), - MinNhits = cms.vint32( 0, 1, 0, 1 ), - MinDxySig = cms.double( -1.0 ), - MinNchambers = cms.vint32( 0 ), - AbsEtaBins = cms.vdouble( 0.9, 1.5, 2.1, 5.0 ), - MaxDz = cms.double( 9999.0 ), - CandTag = cms.InputTag( "hltL2MuonCandidates" ), - BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), - MinDr = cms.double( -1.0 ), - NSigmaPt = cms.double( 0.0 ), - MinNstations = cms.vint32( 0, 2, 0, 2 ) -) -hltL3TrajSeedOIState = cms.EDProducer( "TSGFromL2Muon", - TkSeedGenerator = cms.PSet( - propagatorCompatibleName = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), - option = cms.uint32( 3 ), - maxChi2 = cms.double( 40.0 ), - errorMatrixPset = cms.PSet( - atIP = cms.bool( True ), - action = cms.string( "use" ), - errorMatrixValuesPSet = cms.PSet( - pf3_V12 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V13 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V11 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - pf3_V14 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V15 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), - pf3_V33 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - zAxis = cms.vdouble( -3.14159, 3.14159 ), - pf3_V44 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), - pf3_V22 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - pf3_V23 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V45 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V55 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - pf3_V34 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V35 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V25 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V24 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ) - ) - ), - propagatorName = cms.string( "hltESPSteppingHelixPropagatorAlong" ), - manySeeds = cms.bool( False ), - copyMuonRecHit = cms.bool( False ), - ComponentName = cms.string( "TSGForRoadSearch" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ) - ), - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPSteppingHelixPropagatorOpposite', - 'hltESPSteppingHelixPropagatorAlong' ), - RPCLayers = cms.bool( True ), - UseMuonNavigation = cms.untracked.bool( True ) - ), - MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), - MuonTrackingRegionBuilder = cms.PSet( ), - PCut = cms.double( 2.5 ), - TrackerSeedCleaner = cms.PSet( ), - PtCut = cms.double( 1.0 ) -) -hltL3TrackCandidateFromL2OIState = cms.EDProducer( "CkfTrajectoryMaker", - src = cms.InputTag( "hltL3TrajSeedOIState" ), - reverseTrajectories = cms.bool( True ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - trackCandidateAlso = cms.bool( True ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilderSeedHit" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "hltESPMuonCkfTrajectoryBuilderSeedHit" ), - maxNSeeds = cms.uint32( 100000 ) -) -hltL3TkTracksFromL2OIState = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltL3TrackCandidateFromL2OIState" ), - SimpleMagneticField = cms.string( "" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPKFFittingSmoother" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( False ), - Propagator = cms.string( "PropagatorWithMaterial" ) -) -hltL3MuonsOIState = cms.EDProducer( "L3MuonProducer", - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', - 'SteppingHelixPropagatorAny', - 'hltESPSmartPropagator', - 'hltESPSteppingHelixPropagatorOpposite' ), - RPCLayers = cms.bool( True ), - UseMuonNavigation = cms.untracked.bool( True ) - ), - L3TrajBuilderParameters = cms.PSet( - ScaleTECyFactor = cms.double( -1.0 ), - GlbRefitterParameters = cms.PSet( - TrackerSkipSection = cms.int32( -1 ), - DoPredictionsOnly = cms.bool( False ), - PropDirForCosmics = cms.bool( False ), - HitThreshold = cms.int32( 1 ), - MuonHitsOption = cms.int32( 1 ), - Chi2CutRPC = cms.double( 1.0 ), - Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), - DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - RefitDirection = cms.string( "insideOut" ), - CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), - Chi2CutCSC = cms.double( 150.0 ), - Chi2CutDT = cms.double( 10.0 ), - RefitRPCHits = cms.bool( True ), - SkipStation = cms.int32( -1 ), - Propagator = cms.string( "hltESPSmartPropagatorAny" ), - TrackerSkipSystem = cms.int32( -1 ), - DYTthrs = cms.vint32( 30, 15 ) - ), - ScaleTECxFactor = cms.double( -1.0 ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - MuonTrackingRegionBuilder = cms.PSet( - EtaR_UpperLimit_Par1 = cms.double( 0.25 ), - EtaR_UpperLimit_Par2 = cms.double( 0.15 ), - OnDemand = cms.double( -1.0 ), - Rescale_Dz = cms.double( 3.0 ), - vertexCollection = cms.InputTag( "pixelVertices" ), - Rescale_phi = cms.double( 3.0 ), - Eta_fixed = cms.double( 0.2 ), - DeltaZ_Region = cms.double( 15.9 ), - MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - PhiR_UpperLimit_Par2 = cms.double( 0.2 ), - Eta_min = cms.double( 0.05 ), - Phi_fixed = cms.double( 0.2 ), - DeltaR = cms.double( 0.2 ), - EscapePt = cms.double( 1.5 ), - UseFixedRegion = cms.bool( False ), - PhiR_UpperLimit_Par1 = cms.double( 0.6 ), - Rescale_eta = cms.double( 3.0 ), - Phi_min = cms.double( 0.05 ), - UseVertex = cms.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) - ), - RefitRPCHits = cms.bool( True ), - PCut = cms.double( 2.5 ), - TrackTransformer = cms.PSet( - DoPredictionsOnly = cms.bool( False ), - Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - RefitDirection = cms.string( "insideOut" ), - RefitRPCHits = cms.bool( True ), - Propagator = cms.string( "hltESPSmartPropagatorAny" ) - ), - GlobalMuonTrackMatcher = cms.PSet( - Pt_threshold1 = cms.double( 0.0 ), - DeltaDCut_3 = cms.double( 15.0 ), - MinP = cms.double( 2.5 ), - MinPt = cms.double( 1.0 ), - Chi2Cut_1 = cms.double( 50.0 ), - Pt_threshold2 = cms.double( 9.99999999E8 ), - LocChi2Cut = cms.double( 0.001 ), - Eta_threshold = cms.double( 1.2 ), - Quality_3 = cms.double( 7.0 ), - Quality_2 = cms.double( 15.0 ), - Chi2Cut_2 = cms.double( 50.0 ), - Chi2Cut_3 = cms.double( 200.0 ), - DeltaDCut_1 = cms.double( 40.0 ), - DeltaRCut_2 = cms.double( 0.2 ), - DeltaRCut_3 = cms.double( 1.0 ), - DeltaDCut_2 = cms.double( 10.0 ), - DeltaRCut_1 = cms.double( 0.1 ), - Propagator = cms.string( "hltESPSmartPropagator" ), - Quality_1 = cms.double( 20.0 ) - ), - PtCut = cms.double( 1.0 ), - TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), - tkTrajLabel = cms.InputTag( "hltL3TkTracksFromL2OIState" ), - tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - tkTrajMaxChi2 = cms.double( 9999.0 ), - tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), - tkTrajVertex = cms.InputTag( "pixelVertices" ), - tkTrajUseVertex = cms.bool( False ) - ), - TrackLoaderParameters = cms.PSet( - PutTkTrackIntoEvent = cms.untracked.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - SmoothTkTrack = cms.untracked.bool( False ), - MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), - Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), - MuonUpdatorAtVertexParameters = cms.PSet( - MaxChi2 = cms.double( 1000000.0 ), - Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), - BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) - ), - VertexConstraint = cms.bool( False ), - DoSmoothing = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) -) -hltL3TrajSeedOIHit = cms.EDProducer( "TSGFromL2Muon", - TkSeedGenerator = cms.PSet( - PSetNames = cms.vstring( 'skipTSG', - 'iterativeTSG' ), - L3TkCollectionA = cms.InputTag( "hltL3MuonsOIState" ), - iterativeTSG = cms.PSet( - ErrorRescaling = cms.double( 3.0 ), - beamSpot = cms.InputTag( "unused" ), - MaxChi2 = cms.double( 40.0 ), - errorMatrixPset = cms.PSet( - atIP = cms.bool( True ), - action = cms.string( "use" ), - errorMatrixValuesPSet = cms.PSet( - pf3_V12 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V13 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V11 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - pf3_V14 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V15 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), - pf3_V33 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - zAxis = cms.vdouble( -3.14159, 3.14159 ), - pf3_V44 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), - pf3_V22 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - pf3_V23 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V45 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V55 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - pf3_V34 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V35 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V25 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V24 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ) - ) - ), - UpdateState = cms.bool( True ), - MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - SelectState = cms.bool( False ), - SigmaZ = cms.double( 25.0 ), - ResetMethod = cms.string( "matrix" ), - ComponentName = cms.string( "TSGFromPropagation" ), - UseVertexState = cms.bool( True ), - Propagator = cms.string( "hltESPSmartPropagatorAnyOpposite" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ) - ), - skipTSG = cms.PSet( ), - ComponentName = cms.string( "DualByL2TSG" ) - ), - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'PropagatorWithMaterial', - 'hltESPSmartPropagatorAnyOpposite' ), - RPCLayers = cms.bool( True ), - UseMuonNavigation = cms.untracked.bool( True ) - ), - MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), - MuonTrackingRegionBuilder = cms.PSet( ), - PCut = cms.double( 2.5 ), - TrackerSeedCleaner = cms.PSet( - cleanerFromSharedHits = cms.bool( True ), - ptCleaner = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - directionCleaner = cms.bool( True ) - ), - PtCut = cms.double( 1.0 ) -) -hltL3TrackCandidateFromL2OIHit = cms.EDProducer( "CkfTrajectoryMaker", - src = cms.InputTag( "hltL3TrajSeedOIHit" ), - reverseTrajectories = cms.bool( True ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - trackCandidateAlso = cms.bool( True ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "hltESPMuonCkfTrajectoryBuilder" ), - maxNSeeds = cms.uint32( 100000 ) -) -hltL3TkTracksFromL2OIHit = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltL3TrackCandidateFromL2OIHit" ), - SimpleMagneticField = cms.string( "" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPKFFittingSmoother" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( False ), - Propagator = cms.string( "PropagatorWithMaterial" ) -) -hltL3MuonsOIHit = cms.EDProducer( "L3MuonProducer", - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', - 'SteppingHelixPropagatorAny', - 'hltESPSmartPropagator', - 'hltESPSteppingHelixPropagatorOpposite' ), - RPCLayers = cms.bool( True ), - UseMuonNavigation = cms.untracked.bool( True ) - ), - L3TrajBuilderParameters = cms.PSet( - ScaleTECyFactor = cms.double( -1.0 ), - GlbRefitterParameters = cms.PSet( - TrackerSkipSection = cms.int32( -1 ), - DoPredictionsOnly = cms.bool( False ), - PropDirForCosmics = cms.bool( False ), - HitThreshold = cms.int32( 1 ), - MuonHitsOption = cms.int32( 1 ), - Chi2CutRPC = cms.double( 1.0 ), - Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), - DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - RefitDirection = cms.string( "insideOut" ), - CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), - Chi2CutCSC = cms.double( 150.0 ), - Chi2CutDT = cms.double( 10.0 ), - RefitRPCHits = cms.bool( True ), - SkipStation = cms.int32( -1 ), - Propagator = cms.string( "hltESPSmartPropagatorAny" ), - TrackerSkipSystem = cms.int32( -1 ), - DYTthrs = cms.vint32( 30, 15 ) - ), - ScaleTECxFactor = cms.double( -1.0 ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - MuonTrackingRegionBuilder = cms.PSet( - EtaR_UpperLimit_Par1 = cms.double( 0.25 ), - EtaR_UpperLimit_Par2 = cms.double( 0.15 ), - OnDemand = cms.double( -1.0 ), - Rescale_Dz = cms.double( 3.0 ), - vertexCollection = cms.InputTag( "pixelVertices" ), - Rescale_phi = cms.double( 3.0 ), - Eta_fixed = cms.double( 0.2 ), - DeltaZ_Region = cms.double( 15.9 ), - MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - PhiR_UpperLimit_Par2 = cms.double( 0.2 ), - Eta_min = cms.double( 0.05 ), - Phi_fixed = cms.double( 0.2 ), - DeltaR = cms.double( 0.2 ), - EscapePt = cms.double( 1.5 ), - UseFixedRegion = cms.bool( False ), - PhiR_UpperLimit_Par1 = cms.double( 0.6 ), - Rescale_eta = cms.double( 3.0 ), - Phi_min = cms.double( 0.05 ), - UseVertex = cms.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) - ), - RefitRPCHits = cms.bool( True ), - PCut = cms.double( 2.5 ), - TrackTransformer = cms.PSet( - DoPredictionsOnly = cms.bool( False ), - Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - RefitDirection = cms.string( "insideOut" ), - RefitRPCHits = cms.bool( True ), - Propagator = cms.string( "hltESPSmartPropagatorAny" ) - ), - GlobalMuonTrackMatcher = cms.PSet( - Pt_threshold1 = cms.double( 0.0 ), - DeltaDCut_3 = cms.double( 15.0 ), - MinP = cms.double( 2.5 ), - MinPt = cms.double( 1.0 ), - Chi2Cut_1 = cms.double( 50.0 ), - Pt_threshold2 = cms.double( 9.99999999E8 ), - LocChi2Cut = cms.double( 0.001 ), - Eta_threshold = cms.double( 1.2 ), - Quality_3 = cms.double( 7.0 ), - Quality_2 = cms.double( 15.0 ), - Chi2Cut_2 = cms.double( 50.0 ), - Chi2Cut_3 = cms.double( 200.0 ), - DeltaDCut_1 = cms.double( 40.0 ), - DeltaRCut_2 = cms.double( 0.2 ), - DeltaRCut_3 = cms.double( 1.0 ), - DeltaDCut_2 = cms.double( 10.0 ), - DeltaRCut_1 = cms.double( 0.1 ), - Propagator = cms.string( "hltESPSmartPropagator" ), - Quality_1 = cms.double( 20.0 ) - ), - PtCut = cms.double( 1.0 ), - TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), - tkTrajLabel = cms.InputTag( "hltL3TkTracksFromL2OIHit" ), - tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - tkTrajMaxChi2 = cms.double( 9999.0 ), - tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), - tkTrajVertex = cms.InputTag( "pixelVertices" ), - tkTrajUseVertex = cms.bool( False ) - ), - TrackLoaderParameters = cms.PSet( - PutTkTrackIntoEvent = cms.untracked.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - SmoothTkTrack = cms.untracked.bool( False ), - MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), - Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), - MuonUpdatorAtVertexParameters = cms.PSet( - MaxChi2 = cms.double( 1000000.0 ), - Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), - BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) - ), - VertexConstraint = cms.bool( False ), - DoSmoothing = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) -) -hltL3TkFromL2OICombination = cms.EDProducer( "L3TrackCombiner", - labels = cms.VInputTag( 'hltL3MuonsOIState','hltL3MuonsOIHit' ) -) -hltPixelLayerPairs = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2', - 'BPix1+BPix3', - 'BPix2+BPix3', - 'BPix1+FPix1_pos', - 'BPix1+FPix1_neg', - 'BPix1+FPix2_pos', - 'BPix1+FPix2_neg', - 'BPix2+FPix1_pos', - 'BPix2+FPix1_neg', - 'BPix2+FPix2_pos', - 'BPix2+FPix2_neg', - 'FPix1_pos+FPix2_pos', - 'FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - useErrorsFromParam = cms.bool( True ), - hitErrorRPhi = cms.double( 0.0051 ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - useErrorsFromParam = cms.bool( True ), - hitErrorRPhi = cms.double( 0.0027 ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ) - ), - TIB = cms.PSet( ) +hltCsc2DRecHits = cms.EDProducer( "CSCRecHitDProducer", + XTasymmetry_ME1b = cms.double( 0.0 ), + XTasymmetry_ME1a = cms.double( 0.0 ), + ConstSyst_ME1a = cms.double( 0.022 ), + ConstSyst_ME1b = cms.double( 0.007 ), + XTasymmetry_ME41 = cms.double( 0.0 ), + CSCStripxtalksOffset = cms.double( 0.03 ), + CSCUseCalibrations = cms.bool( True ), + CSCUseTimingCorrections = cms.bool( True ), + CSCNoOfTimeBinsForDynamicPedestal = cms.int32( 2 ), + XTasymmetry_ME22 = cms.double( 0.0 ), + UseFivePoleFit = cms.bool( True ), + XTasymmetry_ME21 = cms.double( 0.0 ), + ConstSyst_ME21 = cms.double( 0.0 ), + CSCDebug = cms.untracked.bool( False ), + ConstSyst_ME22 = cms.double( 0.0 ), + CSCUseGasGainCorrections = cms.bool( False ), + XTasymmetry_ME31 = cms.double( 0.0 ), + readBadChambers = cms.bool( True ), + NoiseLevel_ME13 = cms.double( 8.0 ), + NoiseLevel_ME12 = cms.double( 9.0 ), + NoiseLevel_ME32 = cms.double( 9.0 ), + NoiseLevel_ME31 = cms.double( 9.0 ), + XTasymmetry_ME32 = cms.double( 0.0 ), + ConstSyst_ME41 = cms.double( 0.0 ), + CSCStripClusterSize = cms.untracked.int32( 3 ), + CSCStripClusterChargeCut = cms.double( 25.0 ), + CSCStripPeakThreshold = cms.double( 10.0 ), + readBadChannels = cms.bool( False ), + UseParabolaFit = cms.bool( False ), + XTasymmetry_ME13 = cms.double( 0.0 ), + XTasymmetry_ME12 = cms.double( 0.0 ), + wireDigiTag = cms.InputTag( 'hltMuonCSCDigis','MuonCSCWireDigi' ), + ConstSyst_ME12 = cms.double( 0.0 ), + ConstSyst_ME13 = cms.double( 0.0 ), + ConstSyst_ME32 = cms.double( 0.0 ), + ConstSyst_ME31 = cms.double( 0.0 ), + UseAverageTime = cms.bool( False ), + NoiseLevel_ME1a = cms.double( 7.0 ), + NoiseLevel_ME1b = cms.double( 8.0 ), + CSCWireClusterDeltaT = cms.int32( 1 ), + CSCUseStaticPedestals = cms.bool( False ), + stripDigiTag = cms.InputTag( 'hltMuonCSCDigis','MuonCSCStripDigi' ), + CSCstripWireDeltaTime = cms.int32( 8 ), + NoiseLevel_ME21 = cms.double( 9.0 ), + NoiseLevel_ME22 = cms.double( 9.0 ), + NoiseLevel_ME41 = cms.double( 9.0 ) ) -hltL3TrajSeedIOHit = cms.EDProducer( "TSGFromL2Muon", - TkSeedGenerator = cms.PSet( - PSetNames = cms.vstring( 'skipTSG', - 'iterativeTSG' ), - L3TkCollectionA = cms.InputTag( "hltL3TkFromL2OICombination" ), - iterativeTSG = cms.PSet( - firstTSG = cms.PSet( - ComponentName = cms.string( "TSGFromOrderedHits" ), - OrderedHitsFactoryPSet = cms.PSet( - ComponentName = cms.string( "StandardHitTripletGenerator" ), - GeneratorPSet = cms.PSet( - useBending = cms.bool( True ), - useFixedPreFiltering = cms.bool( False ), - maxElement = cms.uint32( 0 ), - phiPreFiltering = cms.double( 0.3 ), - extraHitRPhitolerance = cms.double( 0.06 ), - useMultScattering = cms.bool( True ), - ComponentName = cms.string( "PixelTripletHLTGenerator" ), - extraHitRZtolerance = cms.double( 0.06 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) - ), - SeedingLayers = cms.InputTag( "hltPixelLayerTriplets" ) - ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - PSetNames = cms.vstring( 'firstTSG', - 'secondTSG' ), - ComponentName = cms.string( "CombinedTSG" ), - thirdTSG = cms.PSet( - PSetNames = cms.vstring( 'endcapTSG', - 'barrelTSG' ), - barrelTSG = cms.PSet( ), - endcapTSG = cms.PSet( - ComponentName = cms.string( "TSGFromOrderedHits" ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitPairGenerator" ), - useOnDemandTracker = cms.untracked.int32( 0 ), - SeedingLayers = cms.InputTag( "hltMixedLayerPairs" ) - ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - etaSeparation = cms.double( 2.0 ), - ComponentName = cms.string( "DualByEtaTSG" ) - ), - secondTSG = cms.PSet( - ComponentName = cms.string( "TSGFromOrderedHits" ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitPairGenerator" ), - useOnDemandTracker = cms.untracked.int32( 0 ), - SeedingLayers = cms.InputTag( "hltPixelLayerPairs" ) +hltCscSegments = cms.EDProducer( "CSCSegmentProducer", + inputObjects = cms.InputTag( "hltCsc2DRecHits" ), + algo_psets = cms.VPSet( + cms.PSet( chamber_types = cms.vstring( 'ME1/a', + 'ME1/b', + 'ME1/2', + 'ME1/3', + 'ME2/1', + 'ME2/2', + 'ME3/1', + 'ME3/2', + 'ME4/1', + 'ME4/2' ), + algo_name = cms.string( "CSCSegAlgoST" ), + parameters_per_chamber_type = cms.vint32( 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 ), + algo_psets = cms.VPSet( + cms.PSet( maxRatioResidualPrune = cms.double( 3.0 ), + yweightPenalty = cms.double( 1.5 ), + maxRecHitsInCluster = cms.int32( 20 ), + dPhiFineMax = cms.double( 0.025 ), + preClusteringUseChaining = cms.bool( True ), + ForceCovariance = cms.bool( False ), + hitDropLimit6Hits = cms.double( 0.3333 ), + NormChi2Cut2D = cms.double( 20.0 ), + BPMinImprovement = cms.double( 10000.0 ), + Covariance = cms.double( 0.0 ), + tanPhiMax = cms.double( 0.5 ), + SeedBig = cms.double( 0.0015 ), + onlyBestSegment = cms.bool( False ), + dRPhiFineMax = cms.double( 8.0 ), + SeedSmall = cms.double( 2.0E-4 ), + curvePenalty = cms.double( 2.0 ), + dXclusBoxMax = cms.double( 4.0 ), + BrutePruning = cms.bool( True ), + curvePenaltyThreshold = cms.double( 0.85 ), + CorrectTheErrors = cms.bool( True ), + hitDropLimit4Hits = cms.double( 0.6 ), + useShowering = cms.bool( False ), + CSCDebug = cms.untracked.bool( False ), + tanThetaMax = cms.double( 1.2 ), + NormChi2Cut3D = cms.double( 10.0 ), + minHitsPerSegment = cms.int32( 3 ), + ForceCovarianceAll = cms.bool( False ), + yweightPenaltyThreshold = cms.double( 1.0 ), + prePrunLimit = cms.double( 3.17 ), + hitDropLimit5Hits = cms.double( 0.8 ), + preClustering = cms.bool( True ), + prePrun = cms.bool( True ), + maxDPhi = cms.double( 999.0 ), + maxDTheta = cms.double( 999.0 ), + Pruning = cms.bool( True ), + dYclusBoxMax = cms.double( 8.0 ) ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + cms.PSet( maxRatioResidualPrune = cms.double( 3.0 ), + yweightPenalty = cms.double( 1.5 ), + maxRecHitsInCluster = cms.int32( 24 ), + dPhiFineMax = cms.double( 0.025 ), + preClusteringUseChaining = cms.bool( True ), + ForceCovariance = cms.bool( False ), + hitDropLimit6Hits = cms.double( 0.3333 ), + NormChi2Cut2D = cms.double( 20.0 ), + BPMinImprovement = cms.double( 10000.0 ), + Covariance = cms.double( 0.0 ), + tanPhiMax = cms.double( 0.5 ), + SeedBig = cms.double( 0.0015 ), + onlyBestSegment = cms.bool( False ), + dRPhiFineMax = cms.double( 8.0 ), + SeedSmall = cms.double( 2.0E-4 ), + curvePenalty = cms.double( 2.0 ), + dXclusBoxMax = cms.double( 4.0 ), + BrutePruning = cms.bool( True ), + curvePenaltyThreshold = cms.double( 0.85 ), + CorrectTheErrors = cms.bool( True ), + hitDropLimit4Hits = cms.double( 0.6 ), + useShowering = cms.bool( False ), + CSCDebug = cms.untracked.bool( False ), + tanThetaMax = cms.double( 1.2 ), + NormChi2Cut3D = cms.double( 10.0 ), + minHitsPerSegment = cms.int32( 3 ), + ForceCovarianceAll = cms.bool( False ), + yweightPenaltyThreshold = cms.double( 1.0 ), + prePrunLimit = cms.double( 3.17 ), + hitDropLimit5Hits = cms.double( 0.8 ), + preClustering = cms.bool( True ), + prePrun = cms.bool( True ), + maxDPhi = cms.double( 999.0 ), + maxDTheta = cms.double( 999.0 ), + Pruning = cms.bool( True ), + dYclusBoxMax = cms.double( 8.0 ) + ) ) - ), - skipTSG = cms.PSet( ), - ComponentName = cms.string( "DualByL2TSG" ) + ) ), + algo_type = cms.int32( 1 ) +) +hltMuonRPCDigis = cms.EDProducer( "RPCUnpackingModule", + InputLabel = cms.InputTag( "rawDataCollector" ), + doSynchro = cms.bool( False ) +) +hltRpcRecHits = cms.EDProducer( "RPCRecHitProducer", + recAlgoConfig = cms.PSet( ), + deadvecfile = cms.FileInPath( "RecoLocalMuon/RPCRecHit/data/RPCDeadVec.dat" ), + rpcDigiLabel = cms.InputTag( "hltMuonRPCDigis" ), + maskvecfile = cms.FileInPath( "RecoLocalMuon/RPCRecHit/data/RPCMaskVec.dat" ), + recAlgo = cms.string( "RPCRecHitStandardAlgo" ), + deadSource = cms.string( "File" ), + maskSource = cms.string( "File" ) +) +hltL2OfflineMuonSeeds = cms.EDProducer( "MuonSeedGenerator", + SMB_21 = cms.vdouble( 1.043, -0.124, 0.0, 0.183, 0.0, 0.0 ), + SMB_20 = cms.vdouble( 1.011, -0.052, 0.0, 0.188, 0.0, 0.0 ), + SMB_22 = cms.vdouble( 1.474, -0.758, 0.0, 0.185, 0.0, 0.0 ), + OL_2213 = cms.vdouble( 0.117, 0.0, 0.0, 0.044, 0.0, 0.0 ), + SME_11 = cms.vdouble( 3.295, -1.527, 0.112, 0.378, 0.02, 0.0 ), + SME_13 = cms.vdouble( -1.286, 1.711, 0.0, 0.356, 0.0, 0.0 ), + SME_12 = cms.vdouble( 0.102, 0.599, 0.0, 0.38, 0.0, 0.0 ), + DT_34_2_scale = cms.vdouble( -11.901897, 0.0 ), + OL_1213_0_scale = cms.vdouble( -4.488158, 0.0 ), + OL_1222_0_scale = cms.vdouble( -5.810449, 0.0 ), + DT_13 = cms.vdouble( 0.315, 0.068, -0.127, 0.051, -0.002, 0.0 ), + DT_12 = cms.vdouble( 0.183, 0.054, -0.087, 0.028, 0.002, 0.0 ), + DT_14 = cms.vdouble( 0.359, 0.052, -0.107, 0.072, -0.004, 0.0 ), + CSC_13_3_scale = cms.vdouble( -1.701268, 0.0 ), + DT_24_2_scale = cms.vdouble( -6.63094, 0.0 ), + CSC_23 = cms.vdouble( -0.081, 0.113, -0.029, 0.015, 0.008, 0.0 ), + CSC_24 = cms.vdouble( 0.004, 0.021, -0.002, 0.053, 0.0, 0.0 ), + OL_2222 = cms.vdouble( 0.107, 0.0, 0.0, 0.04, 0.0, 0.0 ), + DT_14_2_scale = cms.vdouble( -4.808546, 0.0 ), + SMB_10 = cms.vdouble( 1.387, -0.038, 0.0, 0.19, 0.0, 0.0 ), + SMB_11 = cms.vdouble( 1.247, 0.72, -0.802, 0.229, -0.075, 0.0 ), + SMB_12 = cms.vdouble( 2.128, -0.956, 0.0, 0.199, 0.0, 0.0 ), + SME_21 = cms.vdouble( -0.529, 1.194, -0.358, 0.472, 0.086, 0.0 ), + SME_22 = cms.vdouble( -1.207, 1.491, -0.251, 0.189, 0.243, 0.0 ), + DT_13_2_scale = cms.vdouble( -4.257687, 0.0 ), + CSC_34 = cms.vdouble( 0.062, -0.067, 0.019, 0.021, 0.003, 0.0 ), + SME_22_0_scale = cms.vdouble( -3.457901, 0.0 ), + DT_24_1_scale = cms.vdouble( -7.490909, 0.0 ), + OL_1232_0_scale = cms.vdouble( -5.964634, 0.0 ), + DT_23_1_scale = cms.vdouble( -5.320346, 0.0 ), + SME_13_0_scale = cms.vdouble( 0.104905, 0.0 ), + SMB_22_0_scale = cms.vdouble( 1.346681, 0.0 ), + CSC_12_1_scale = cms.vdouble( -6.434242, 0.0 ), + DT_34 = cms.vdouble( 0.044, 0.004, -0.013, 0.029, 0.003, 0.0 ), + SME_32 = cms.vdouble( -0.901, 1.333, -0.47, 0.41, 0.073, 0.0 ), + SME_31 = cms.vdouble( -1.594, 1.482, -0.317, 0.487, 0.097, 0.0 ), + CSC_13_2_scale = cms.vdouble( -6.077936, 0.0 ), + crackEtas = cms.vdouble( 0.2, 1.6, 1.7 ), + SME_11_0_scale = cms.vdouble( 1.325085, 0.0 ), + SMB_20_0_scale = cms.vdouble( 1.486168, 0.0 ), + DT_13_1_scale = cms.vdouble( -4.520923, 0.0 ), + CSC_24_1_scale = cms.vdouble( -6.055701, 0.0 ), + CSC_01_1_scale = cms.vdouble( -1.915329, 0.0 ), + DT_23 = cms.vdouble( 0.13, 0.023, -0.057, 0.028, 0.004, 0.0 ), + DT_24 = cms.vdouble( 0.176, 0.014, -0.051, 0.051, 0.003, 0.0 ), + SMB_12_0_scale = cms.vdouble( 2.283221, 0.0 ), + deltaPhiSearchWindow = cms.double( 0.25 ), + SMB_30_0_scale = cms.vdouble( -3.629838, 0.0 ), + SME_42 = cms.vdouble( -0.003, 0.005, 0.005, 0.608, 0.076, 0.0 ), + SME_41 = cms.vdouble( -0.003, 0.005, 0.005, 0.608, 0.076, 0.0 ), + deltaEtaSearchWindow = cms.double( 0.2 ), + CSC_12_2_scale = cms.vdouble( -1.63622, 0.0 ), + DT_34_1_scale = cms.vdouble( -13.783765, 0.0 ), + CSC_34_1_scale = cms.vdouble( -11.520507, 0.0 ), + OL_2213_0_scale = cms.vdouble( -7.239789, 0.0 ), + SMB_32_0_scale = cms.vdouble( -3.054156, 0.0 ), + CSC_12_3_scale = cms.vdouble( -1.63622, 0.0 ), + deltaEtaCrackSearchWindow = cms.double( 0.25 ), + SME_21_0_scale = cms.vdouble( -0.040862, 0.0 ), + OL_1232 = cms.vdouble( 0.184, 0.0, 0.0, 0.066, 0.0, 0.0 ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + SMB_10_0_scale = cms.vdouble( 2.448566, 0.0 ), + EnableDTMeasurement = cms.bool( True ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + CSC_23_2_scale = cms.vdouble( -6.079917, 0.0 ), + scaleDT = cms.bool( True ), + DT_12_2_scale = cms.vdouble( -3.518165, 0.0 ), + OL_1222 = cms.vdouble( 0.848, -0.591, 0.0, 0.062, 0.0, 0.0 ), + CSC_23_1_scale = cms.vdouble( -19.084285, 0.0 ), + OL_1213 = cms.vdouble( 0.96, -0.737, 0.0, 0.052, 0.0, 0.0 ), + CSC_02 = cms.vdouble( 0.612, -0.207, 0.0, 0.067, -0.001, 0.0 ), + CSC_03 = cms.vdouble( 0.787, -0.338, 0.029, 0.101, -0.008, 0.0 ), + CSC_01 = cms.vdouble( 0.166, 0.0, 0.0, 0.031, 0.0, 0.0 ), + SMB_32 = cms.vdouble( 0.67, -0.327, 0.0, 0.22, 0.0, 0.0 ), + SMB_30 = cms.vdouble( 0.505, -0.022, 0.0, 0.215, 0.0, 0.0 ), + SMB_31 = cms.vdouble( 0.549, -0.145, 0.0, 0.207, 0.0, 0.0 ), + crackWindow = cms.double( 0.04 ), + CSC_14_3_scale = cms.vdouble( -1.969563, 0.0 ), + SMB_31_0_scale = cms.vdouble( -3.323768, 0.0 ), + DT_12_1_scale = cms.vdouble( -3.692398, 0.0 ), + SMB_21_0_scale = cms.vdouble( 1.58384, 0.0 ), + DT_23_2_scale = cms.vdouble( -5.117625, 0.0 ), + SME_12_0_scale = cms.vdouble( 2.279181, 0.0 ), + DT_14_1_scale = cms.vdouble( -5.644816, 0.0 ), + beamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + SMB_11_0_scale = cms.vdouble( 2.56363, 0.0 ), + EnableCSCMeasurement = cms.bool( True ), + CSC_14 = cms.vdouble( 0.606, -0.181, -0.002, 0.111, -0.003, 0.0 ), + OL_2222_0_scale = cms.vdouble( -7.667231, 0.0 ), + CSC_13 = cms.vdouble( 0.901, -1.302, 0.533, 0.045, 0.005, 0.0 ), + CSC_12 = cms.vdouble( -0.161, 0.254, -0.047, 0.042, -0.007, 0.0 ) +) +hltL2MuonSeeds = cms.EDProducer( "L2MuonSeedGenerator", ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'PropagatorWithMaterial' ), + Propagators = cms.untracked.vstring( 'SteppingHelixPropagatorAny' ), RPCLayers = cms.bool( True ), UseMuonNavigation = cms.untracked.bool( True ) ), - MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), - MuonTrackingRegionBuilder = cms.PSet( - EtaR_UpperLimit_Par1 = cms.double( 0.25 ), - EtaR_UpperLimit_Par2 = cms.double( 0.15 ), - OnDemand = cms.double( -1.0 ), - Rescale_Dz = cms.double( 3.0 ), - vertexCollection = cms.InputTag( "pixelVertices" ), - Rescale_phi = cms.double( 3.0 ), - Eta_fixed = cms.double( 0.2 ), - DeltaZ_Region = cms.double( 15.9 ), - MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - PhiR_UpperLimit_Par2 = cms.double( 0.2 ), - Eta_min = cms.double( 0.1 ), - Phi_fixed = cms.double( 0.2 ), - DeltaR = cms.double( 0.2 ), - EscapePt = cms.double( 1.5 ), - UseFixedRegion = cms.bool( False ), - PhiR_UpperLimit_Par1 = cms.double( 0.6 ), - Rescale_eta = cms.double( 3.0 ), - Phi_min = cms.double( 0.1 ), - UseVertex = cms.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) - ), - PCut = cms.double( 2.5 ), - TrackerSeedCleaner = cms.PSet( - cleanerFromSharedHits = cms.bool( True ), - ptCleaner = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - directionCleaner = cms.bool( True ) - ), - PtCut = cms.double( 1.0 ) -) -hltL3TrackCandidateFromL2IOHit = cms.EDProducer( "CkfTrajectoryMaker", - src = cms.InputTag( "hltL3TrajSeedIOHit" ), - reverseTrajectories = cms.bool( False ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - trackCandidateAlso = cms.bool( True ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "hltESPMuonCkfTrajectoryBuilder" ), - maxNSeeds = cms.uint32( 100000 ) -) -hltL3TkTracksFromL2IOHit = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltL3TrackCandidateFromL2IOHit" ), - SimpleMagneticField = cms.string( "" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPKFFittingSmoother" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( False ), - Propagator = cms.string( "PropagatorWithMaterial" ) + InputObjects = cms.InputTag( "hltL1extraParticles" ), + L1MaxEta = cms.double( 2.5 ), + OfflineSeedLabel = cms.untracked.InputTag( "hltL2OfflineMuonSeeds" ), + L1MinPt = cms.double( 0.0 ), + L1MinQuality = cms.uint32( 1 ), + GMTReadoutCollection = cms.InputTag( "hltGtDigis" ), + UseUnassociatedL1 = cms.bool( False ), + UseOfflineSeed = cms.untracked.bool( True ), + Propagator = cms.string( "SteppingHelixPropagatorAny" ) ) -hltL3MuonsIOHit = cms.EDProducer( "L3MuonProducer", +hltL2Muons = cms.EDProducer( "L2MuonProducer", ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', - 'SteppingHelixPropagatorAny', - 'hltESPSmartPropagator', - 'hltESPSteppingHelixPropagatorOpposite' ), + Propagators = cms.untracked.vstring( 'hltESPFastSteppingHelixPropagatorAny', + 'hltESPFastSteppingHelixPropagatorOpposite' ), RPCLayers = cms.bool( True ), UseMuonNavigation = cms.untracked.bool( True ) ), - L3TrajBuilderParameters = cms.PSet( - ScaleTECyFactor = cms.double( -1.0 ), - GlbRefitterParameters = cms.PSet( - TrackerSkipSection = cms.int32( -1 ), - DoPredictionsOnly = cms.bool( False ), - PropDirForCosmics = cms.bool( False ), - HitThreshold = cms.int32( 1 ), - MuonHitsOption = cms.int32( 1 ), - Chi2CutRPC = cms.double( 1.0 ), - Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + InputObjects = cms.InputTag( "hltL2MuonSeeds" ), + SeedTransformerParameters = cms.PSet( + Fitter = cms.string( "hltESPKFFittingSmootherForL2Muon" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + NMinRecHits = cms.uint32( 2 ), + UseSubRecHits = cms.bool( False ), + Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), + RescaleError = cms.double( 100.0 ) + ), + L2TrajBuilderParameters = cms.PSet( + DoRefit = cms.bool( False ), + SeedPropagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), + FilterParameters = cms.PSet( + NumberOfSigma = cms.double( 3.0 ), + FitDirection = cms.string( "insideOut" ), DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - RefitDirection = cms.string( "insideOut" ), + MaxChi2 = cms.double( 1000.0 ), + MuonTrajectoryUpdatorParameters = cms.PSet( + MaxChi2 = cms.double( 25.0 ), + RescaleErrorFactor = cms.double( 100.0 ), + Granularity = cms.int32( 0 ), + ExcludeRPCFromFit = cms.bool( False ), + UseInvalidHits = cms.bool( True ), + RescaleError = cms.bool( False ) + ), + EnableRPCMeasurement = cms.bool( True ), CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), - Chi2CutCSC = cms.double( 150.0 ), - Chi2CutDT = cms.double( 10.0 ), - RefitRPCHits = cms.bool( True ), - SkipStation = cms.int32( -1 ), - Propagator = cms.string( "hltESPSmartPropagatorAny" ), - TrackerSkipSystem = cms.int32( -1 ), - DYTthrs = cms.vint32( 30, 15 ) - ), - ScaleTECxFactor = cms.double( -1.0 ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - MuonTrackingRegionBuilder = cms.PSet( - EtaR_UpperLimit_Par1 = cms.double( 0.25 ), - EtaR_UpperLimit_Par2 = cms.double( 0.15 ), - OnDemand = cms.double( -1.0 ), - Rescale_Dz = cms.double( 3.0 ), - vertexCollection = cms.InputTag( "pixelVertices" ), - Rescale_phi = cms.double( 3.0 ), - Eta_fixed = cms.double( 0.2 ), - DeltaZ_Region = cms.double( 15.9 ), - MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - PhiR_UpperLimit_Par2 = cms.double( 0.2 ), - Eta_min = cms.double( 0.05 ), - Phi_fixed = cms.double( 0.2 ), - DeltaR = cms.double( 0.2 ), - EscapePt = cms.double( 1.5 ), - UseFixedRegion = cms.bool( False ), - PhiR_UpperLimit_Par1 = cms.double( 0.6 ), - Rescale_eta = cms.double( 3.0 ), - Phi_min = cms.double( 0.05 ), - UseVertex = cms.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + EnableDTMeasurement = cms.bool( True ), + RPCRecSegmentLabel = cms.InputTag( "hltRpcRecHits" ), + Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), + EnableCSCMeasurement = cms.bool( True ) ), - RefitRPCHits = cms.bool( True ), - PCut = cms.double( 2.5 ), - TrackTransformer = cms.PSet( - DoPredictionsOnly = cms.bool( False ), - Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + NavigationType = cms.string( "Standard" ), + SeedTransformerParameters = cms.PSet( + Fitter = cms.string( "hltESPKFFittingSmootherForL2Muon" ), MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - RefitDirection = cms.string( "insideOut" ), - RefitRPCHits = cms.bool( True ), - Propagator = cms.string( "hltESPSmartPropagatorAny" ) + NMinRecHits = cms.uint32( 2 ), + UseSubRecHits = cms.bool( False ), + Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), + RescaleError = cms.double( 100.0 ) ), - GlobalMuonTrackMatcher = cms.PSet( - Pt_threshold1 = cms.double( 0.0 ), - DeltaDCut_3 = cms.double( 15.0 ), - MinP = cms.double( 2.5 ), - MinPt = cms.double( 1.0 ), - Chi2Cut_1 = cms.double( 50.0 ), - Pt_threshold2 = cms.double( 9.99999999E8 ), - LocChi2Cut = cms.double( 0.001 ), - Eta_threshold = cms.double( 1.2 ), - Quality_3 = cms.double( 7.0 ), - Quality_2 = cms.double( 15.0 ), - Chi2Cut_2 = cms.double( 50.0 ), - Chi2Cut_3 = cms.double( 200.0 ), - DeltaDCut_1 = cms.double( 40.0 ), - DeltaRCut_2 = cms.double( 0.2 ), - DeltaRCut_3 = cms.double( 1.0 ), - DeltaDCut_2 = cms.double( 10.0 ), - DeltaRCut_1 = cms.double( 0.1 ), - Propagator = cms.string( "hltESPSmartPropagator" ), - Quality_1 = cms.double( 20.0 ) + DoBackwardFilter = cms.bool( True ), + SeedPosition = cms.string( "in" ), + BWFilterParameters = cms.PSet( + NumberOfSigma = cms.double( 3.0 ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + FitDirection = cms.string( "outsideIn" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + MaxChi2 = cms.double( 100.0 ), + MuonTrajectoryUpdatorParameters = cms.PSet( + MaxChi2 = cms.double( 25.0 ), + RescaleErrorFactor = cms.double( 100.0 ), + Granularity = cms.int32( 0 ), + ExcludeRPCFromFit = cms.bool( False ), + UseInvalidHits = cms.bool( True ), + RescaleError = cms.bool( False ) + ), + EnableRPCMeasurement = cms.bool( True ), + BWSeedType = cms.string( "fromGenerator" ), + EnableDTMeasurement = cms.bool( True ), + RPCRecSegmentLabel = cms.InputTag( "hltRpcRecHits" ), + Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), + EnableCSCMeasurement = cms.bool( True ) ), - PtCut = cms.double( 1.0 ), - TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), - tkTrajLabel = cms.InputTag( "hltL3TkTracksFromL2IOHit" ), - tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - tkTrajMaxChi2 = cms.double( 9999.0 ), - tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), - tkTrajVertex = cms.InputTag( "pixelVertices" ), - tkTrajUseVertex = cms.bool( False ) + DoSeedRefit = cms.bool( False ) ), + DoSeedRefit = cms.bool( False ), TrackLoaderParameters = cms.PSet( - PutTkTrackIntoEvent = cms.untracked.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - SmoothTkTrack = cms.untracked.bool( False ), - MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + DoSmoothing = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), MuonUpdatorAtVertexParameters = cms.PSet( MaxChi2 = cms.double( 1000000.0 ), - Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPosition = cms.vdouble( 0.0, 0.0, 0.0 ), + Propagator = cms.string( "hltESPFastSteppingHelixPropagatorOpposite" ), BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) ), - VertexConstraint = cms.bool( False ), - DoSmoothing = cms.bool( True ), + VertexConstraint = cms.bool( True ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) ), - MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) + MuonTrajectoryBuilder = cms.string( "Exhaustive" ) ) -hltL3TrajectorySeed = cms.EDProducer( "L3MuonTrajectorySeedCombiner", - labels = cms.VInputTag( 'hltL3TrajSeedIOHit','hltL3TrajSeedOIState','hltL3TrajSeedOIHit' ) -) -hltL3TrackCandidateFromL2 = cms.EDProducer( "L3TrackCandCombiner", - labels = cms.VInputTag( 'hltL3TrackCandidateFromL2IOHit','hltL3TrackCandidateFromL2OIHit','hltL3TrackCandidateFromL2OIState' ) -) -hltL3TkTracksMergeStep1 = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltL3TkTracksFromL2OIState','hltL3TkTracksFromL2OIHit' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 100.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltL3TkTracksFromL2OIState','hltL3TkTracksFromL2OIHit' ), - LostHitPenalty = cms.double( 0.0 ), - newQuality = cms.string( "confirmed" ) -) -hltL3TkTracksFromL2 = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltL3TkTracksMergeStep1','hltL3TkTracksFromL2IOHit' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 100.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltL3TkTracksMergeStep1','hltL3TkTracksFromL2IOHit' ), - LostHitPenalty = cms.double( 0.0 ), - newQuality = cms.string( "confirmed" ) +hltL2MuonCandidates = cms.EDProducer( "L2MuonCandidateProducer", + InputObjects = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) +) +hltHIL2Mu3L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) ) -hltL3MuonsLinksCombination = cms.EDProducer( "L3TrackLinksCombiner", - labels = cms.VInputTag( 'hltL3MuonsOIState','hltL3MuonsOIHit','hltL3MuonsIOHit' ) +hltPreHIL2Mu7 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) ) -hltL3Muons = cms.EDProducer( "L3TrackCombiner", - labels = cms.VInputTag( 'hltL3MuonsOIState','hltL3MuonsOIHit','hltL3MuonsIOHit' ) +hltHIL2Mu7L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 7.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) ) -hltL3MuonCandidates = cms.EDProducer( "L3MuonCandidateProducer", - InputLinksObjects = cms.InputTag( "hltL3MuonsLinksCombination" ), - InputObjects = cms.InputTag( "hltL3Muons" ), - MuonPtOption = cms.string( "Tracker" ) +hltPreHIL2Mu15 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) ) -hltL3fL1sMu16orMu25L1f0L2f16QL3Filtered50Q = cms.EDFilter( "HLTMuonL3PreFilter", - MaxNormalizedChi2 = cms.double( 20.0 ), +hltHIL2Mu15L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", saveTags = cms.bool( True ), - PreviousCandTag = cms.InputTag( "hltL2fL1sMu16orMu25L1f0L2Filtered16Q" ), - MinNmuonHits = cms.int32( 0 ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 15.0 ), MinN = cms.int32( 1 ), - MinTrackPt = cms.double( 0.0 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), MaxEta = cms.double( 2.5 ), - MaxDXYBeamSpot = cms.double( 0.1 ), - MinNhits = cms.int32( 0 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltPreHIL2Mu3NHitQ = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIL2Mu3N1HitQL2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 1 ), MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltPreHIL2DoubleMu0 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIDoubleMuLevel1PathL1OpenFiltered = cms.EDFilter( "HLTMuonL1Filter", + saveTags = cms.bool( True ), + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1DoubleMuOpenBptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "hltL1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) +) +hltHIL2DoubleMu0L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), MaxDz = cms.double( 9999.0 ), - MaxPtDifference = cms.double( 9999.0 ), - MaxDr = cms.double( 2.0 ), - CandTag = cms.InputTag( "hltL3MuonCandidates" ), - MinDXYBeamSpot = cms.double( -1.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltPreHIL2DoubleMu0NHitQ = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIL2DoubleMu0L2N1HitsFiltered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 1 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +hltPreHIL2DoubleMu3 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIL2DoubleMu3L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), - MinPt = cms.double( 50.0 ) + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) ) -hltPrePFJet260 = cms.EDFilter( "HLTPrescaler", +hltPreHIL3Mu3 = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) -hltSingleCaloJet210 = cms.EDFilter( "HLT1CaloJet", - saveTags = cms.bool( True ), - MinPt = cms.double( 210.0 ), - MinN = cms.int32( 1 ), - MaxEta = cms.double( 5.0 ), - MinMass = cms.double( -1.0 ), - inputTag = cms.InputTag( "hltAK4CaloJetsCorrectedIDPassed" ), - MinE = cms.double( -1.0 ), - triggerType = cms.int32( 85 ) -) -hltTowerMakerForPF = cms.EDProducer( "CaloTowersCreator", - EBSumThreshold = cms.double( 0.2 ), - MomHBDepth = cms.double( 0.2 ), - UseEtEBTreshold = cms.bool( False ), - hfInput = cms.InputTag( "hltHfreco" ), - AllowMissingInputs = cms.bool( False ), - MomEEDepth = cms.double( 0.0 ), - EESumThreshold = cms.double( 0.45 ), - HBGrid = cms.vdouble( ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - HBThreshold = cms.double( 0.4 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), - UseEcalRecoveredHits = cms.bool( False ), - MomConstrMethod = cms.int32( 1 ), - MomHEDepth = cms.double( 0.4 ), - HcalThreshold = cms.double( -1000.0 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), - UseSymEBTreshold = cms.bool( False ), - EEWeights = cms.vdouble( ), - EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), - HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HEDGrid = cms.vdouble( ), - EBWeight = cms.double( 1.0 ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), - HOWeight = cms.double( 1.0 ), - HESWeight = cms.double( 1.0 ), - HESThreshold = cms.double( 0.4 ), - hbheInput = cms.InputTag( "hltHbhereco" ), - HF2Weight = cms.double( 1.0 ), - HF2Threshold = cms.double( 1.8 ), - HcalAcceptSeverityLevel = cms.uint32( 11 ), - EEThreshold = cms.double( 0.3 ), - HOThresholdPlus1 = cms.double( 1.1 ), - HOThresholdPlus2 = cms.double( 1.1 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HF1Threshold = cms.double( 1.2 ), - HOThresholdMinus1 = cms.double( 1.1 ), - HESGrid = cms.vdouble( ), - EcutTower = cms.double( -1000.0 ), - UseRejectedRecoveredEcalHits = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - HESWeights = cms.vdouble( ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), - HEDWeight = cms.double( 1.0 ), - UseSymEETreshold = cms.bool( False ), - HEDThreshold = cms.double( 0.4 ), - EBThreshold = cms.double( 0.07 ), - UseRejectedHitsOnly = cms.bool( False ), - UseHcalRecoveredHits = cms.bool( True ), - HOThresholdMinus2 = cms.double( 1.1 ), - HOThreshold0 = cms.double( 1.1 ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), - UseRejectedRecoveredHcalHits = cms.bool( False ), - MomEBDepth = cms.double( 0.3 ), - HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ) -) -hltAK4CaloJetsPF = cms.EDProducer( "FastjetJetProducer", - Active_Area_Repeats = cms.int32( 5 ), - doAreaFastjet = cms.bool( False ), - voronoiRfact = cms.double( -9.0 ), - maxBadHcalCells = cms.uint32( 9999999 ), - doAreaDiskApprox = cms.bool( False ), - maxRecoveredEcalCells = cms.uint32( 9999999 ), - jetType = cms.string( "CaloJet" ), - minSeed = cms.uint32( 0 ), - Ghost_EtaMax = cms.double( 6.0 ), - doRhoFastjet = cms.bool( False ), - jetAlgorithm = cms.string( "AntiKt" ), - nSigmaPU = cms.double( 1.0 ), - GhostArea = cms.double( 0.01 ), - Rho_EtaMax = cms.double( 4.4 ), - maxBadEcalCells = cms.uint32( 9999999 ), - useDeterministicSeed = cms.bool( True ), - doPVCorrection = cms.bool( False ), - maxRecoveredHcalCells = cms.uint32( 9999999 ), - rParam = cms.double( 0.4 ), - maxProblematicHcalCells = cms.uint32( 9999999 ), - doOutputJets = cms.bool( True ), - src = cms.InputTag( "hltTowerMakerForPF" ), - inputEtMin = cms.double( 0.3 ), - puPtMin = cms.double( 10.0 ), - srcPVs = cms.InputTag( "NotUsed" ), - jetPtMin = cms.double( 1.0 ), - radiusPU = cms.double( 0.4 ), - maxProblematicEcalCells = cms.uint32( 9999999 ), - doPUOffsetCorr = cms.bool( False ), - inputEMin = cms.double( 0.0 ), - useMassDropTagger = cms.bool( False ), - muMin = cms.double( -1.0 ), - subtractorName = cms.string( "" ), - muCut = cms.double( -1.0 ), - subjetPtMin = cms.double( -1.0 ), - useTrimming = cms.bool( False ), - muMax = cms.double( -1.0 ), - yMin = cms.double( -1.0 ), - useFiltering = cms.bool( False ), - rFilt = cms.double( -1.0 ), - yMax = cms.double( -1.0 ), - zcut = cms.double( -1.0 ), - MinVtxNdof = cms.int32( 5 ), - MaxVtxZ = cms.double( 15.0 ), - UseOnlyVertexTracks = cms.bool( False ), - dRMin = cms.double( -1.0 ), - nFilt = cms.int32( -1 ), - usePruning = cms.bool( False ), - maxDepth = cms.int32( -1 ), - yCut = cms.double( -1.0 ), - DzTrVtxMax = cms.double( 0.0 ), - UseOnlyOnePV = cms.bool( False ), - rcut_factor = cms.double( -1.0 ), - sumRecHits = cms.bool( False ), - trimPtFracMin = cms.double( -1.0 ), - dRMax = cms.double( -1.0 ), - DxyTrVtxMax = cms.double( 0.0 ), - useCMSBoostedTauSeedingAlgorithm = cms.bool( False ) -) -hltAK4CaloJetsPFEt5 = cms.EDFilter( "EtMinCaloJetSelector", - filter = cms.bool( False ), - src = cms.InputTag( "hltAK4CaloJetsPF" ), - etMin = cms.double( 5.0 ) -) -hltPixelTracks = cms.EDProducer( "PixelTrackProducer", - useFilterWithES = cms.bool( False ), - FilterPSet = cms.PSet( - chi2 = cms.double( 1000.0 ), - nSigmaTipMaxTolerance = cms.double( 0.0 ), - ComponentName = cms.string( "PixelTrackFilterByKinematics" ), - nSigmaInvPtTolerance = cms.double( 0.0 ), - ptMin = cms.double( 0.1 ), - tipMax = cms.double( 1.0 ) - ), - passLabel = cms.string( "Pixel triplet primary tracks with vertex constraint" ), - FitterPSet = cms.PSet( - ComponentName = cms.string( "PixelFitterByHelixProjections" ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - fixImpactParameter = cms.double( 0.0 ) - ), - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "GlobalRegionProducerFromBeamSpot" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.2 ), - ptMin = cms.double( 0.9 ), - originHalfLength = cms.double( 24.0 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) - ) - ), - CleanerPSet = cms.PSet( ComponentName = cms.string( "PixelTrackCleanerBySharedHits" ) ), - OrderedHitsFactoryPSet = cms.PSet( - ComponentName = cms.string( "StandardHitTripletGenerator" ), - GeneratorPSet = cms.PSet( - useBending = cms.bool( True ), - useFixedPreFiltering = cms.bool( False ), - maxElement = cms.uint32( 100000 ), - phiPreFiltering = cms.double( 0.3 ), - extraHitRPhitolerance = cms.double( 0.06 ), - useMultScattering = cms.bool( True ), - SeedComparitorPSet = cms.PSet( - ComponentName = cms.string( "LowPtClusterShapeSeedComparitor" ), - clusterShapeCacheSrc = cms.InputTag( "hltSiPixelClustersCache" ) - ), - extraHitRZtolerance = cms.double( 0.06 ), - ComponentName = cms.string( "PixelTripletHLTGenerator" ) - ), - SeedingLayers = cms.InputTag( "hltPixelLayerTriplets" ) - ) +hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", + UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), + InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), + ErrorList = cms.vint32( ), + Regions = cms.PSet( ), + Timing = cms.untracked.bool( False ), + UserErrorList = cms.vint32( ) +) +hltHISiPixelClusters = cms.EDProducer( "SiPixelClusterProducer", + src = cms.InputTag( "hltSiPixelDigis" ), + ChannelThreshold = cms.int32( 1000 ), + maxNumberOfClusters = cms.int32( -1 ), + VCaltoElectronGain = cms.int32( 65 ), + MissCalibrate = cms.untracked.bool( True ), + SplitClusters = cms.bool( False ), + VCaltoElectronOffset = cms.int32( -414 ), + payloadType = cms.string( "HLT" ), + SeedThreshold = cms.int32( 1000 ), + ClusterThreshold = cms.double( 4000.0 ) ) -hltPixelVertices = cms.EDProducer( "PixelVertexProducer", - WtAverage = cms.bool( True ), - Method2 = cms.bool( True ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - PVcomparer = cms.PSet( refToPSet_ = cms.string( "HLTPSetPvClusterComparerForIT" ) ), - Verbosity = cms.int32( 0 ), - UseError = cms.bool( True ), - TrackCollection = cms.InputTag( "hltPixelTracks" ), - PtMin = cms.double( 1.0 ), - NTrkMin = cms.int32( 2 ), - ZOffset = cms.double( 5.0 ), - Finder = cms.string( "DivisiveVertexFinder" ), - ZSeparation = cms.double( 0.05 ) -) -hltTrimmedPixelVertices = cms.EDProducer( "PixelVertexCollectionTrimmer", - minSumPt2 = cms.double( 0.0 ), - PVcomparer = cms.PSet( refToPSet_ = cms.string( "HLTPSetPvClusterComparerForIT" ) ), - maxVtx = cms.uint32( 100 ), - fractionSumPt2 = cms.double( 0.3 ), - src = cms.InputTag( "hltPixelVertices" ) -) -hltIter0PFLowPixelSeedsFromPixelTracks = cms.EDProducer( "SeedGeneratorFromProtoTracksEDProducer", - useEventsWithNoVertex = cms.bool( True ), - originHalfLength = cms.double( 0.3 ), - useProtoTrackKinematics = cms.bool( False ), - usePV = cms.bool( False ), - InputVertexCollection = cms.InputTag( "hltTrimmedPixelVertices" ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - InputCollection = cms.InputTag( "hltPixelTracks" ), - originRadius = cms.double( 0.1 ) -) -hltIter0PFlowCkfTrackCandidates = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter0PFLowPixelSeedsFromPixelTracks" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter0PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) +hltHISiPixelClustersCache = cms.EDProducer( "SiPixelClusterShapeCacheProducer", + src = cms.InputTag( "hltHISiPixelClusters" ), + onDemand = cms.bool( False ) ) -hltIter0PFlowCtfWithMaterialTracks = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter0PFlowCkfTrackCandidates" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIter0" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -hltIter0PFlowTrackSelectionHighPurity = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.4, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.35, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter0PFlowCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltTrimmedPixelVertices" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.4, 4.0 ), - d0_par1 = cms.vdouble( 0.3, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -hltTrackIter0RefsForJets4Iter1 = cms.EDProducer( "ChargedRefCandidateProducer", - src = cms.InputTag( "hltIter0PFlowTrackSelectionHighPurity" ), - particleType = cms.string( "pi+" ) -) -hltAK4Iter0TrackJets4Iter1 = cms.EDProducer( "FastjetJetProducer", - Active_Area_Repeats = cms.int32( 5 ), - doAreaFastjet = cms.bool( False ), - voronoiRfact = cms.double( 0.9 ), - maxBadHcalCells = cms.uint32( 9999999 ), - doAreaDiskApprox = cms.bool( False ), - maxRecoveredEcalCells = cms.uint32( 9999999 ), - jetType = cms.string( "TrackJet" ), - minSeed = cms.uint32( 14327 ), - Ghost_EtaMax = cms.double( 6.0 ), - doRhoFastjet = cms.bool( False ), - jetAlgorithm = cms.string( "AntiKt" ), - nSigmaPU = cms.double( 1.0 ), - GhostArea = cms.double( 0.01 ), - Rho_EtaMax = cms.double( 4.4 ), - maxBadEcalCells = cms.uint32( 9999999 ), - useDeterministicSeed = cms.bool( True ), - doPVCorrection = cms.bool( False ), - maxRecoveredHcalCells = cms.uint32( 9999999 ), - rParam = cms.double( 0.4 ), - maxProblematicHcalCells = cms.uint32( 9999999 ), - doOutputJets = cms.bool( True ), - src = cms.InputTag( "hltTrackIter0RefsForJets4Iter1" ), - inputEtMin = cms.double( 0.1 ), - puPtMin = cms.double( 0.0 ), - srcPVs = cms.InputTag( "hltTrimmedPixelVertices" ), - jetPtMin = cms.double( 1.0 ), - radiusPU = cms.double( 0.4 ), - maxProblematicEcalCells = cms.uint32( 9999999 ), - doPUOffsetCorr = cms.bool( False ), - inputEMin = cms.double( 0.0 ), - useMassDropTagger = cms.bool( False ), - muMin = cms.double( -1.0 ), - subtractorName = cms.string( "" ), - muCut = cms.double( -1.0 ), - subjetPtMin = cms.double( -1.0 ), - useTrimming = cms.bool( False ), - muMax = cms.double( -1.0 ), - yMin = cms.double( -1.0 ), - useFiltering = cms.bool( False ), - rFilt = cms.double( -1.0 ), - yMax = cms.double( -1.0 ), - zcut = cms.double( -1.0 ), - MinVtxNdof = cms.int32( 0 ), - MaxVtxZ = cms.double( 30.0 ), - UseOnlyVertexTracks = cms.bool( False ), - dRMin = cms.double( -1.0 ), - nFilt = cms.int32( -1 ), - usePruning = cms.bool( False ), - maxDepth = cms.int32( -1 ), - yCut = cms.double( -1.0 ), - DzTrVtxMax = cms.double( 0.5 ), - UseOnlyOnePV = cms.bool( True ), - rcut_factor = cms.double( -1.0 ), - sumRecHits = cms.bool( False ), - trimPtFracMin = cms.double( -1.0 ), - dRMax = cms.double( -1.0 ), - DxyTrVtxMax = cms.double( 0.2 ), - useCMSBoostedTauSeedingAlgorithm = cms.bool( False ) -) -hltIter0TrackAndTauJets4Iter1 = cms.EDProducer( "TauJetSelectorForHLTTrackSeeding", - fractionMinCaloInTauCone = cms.double( 0.7 ), - fractionMaxChargedPUInCaloCone = cms.double( 0.3 ), - tauConeSize = cms.double( 0.2 ), - ptTrkMaxInCaloCone = cms.double( 1.0 ), - isolationConeSize = cms.double( 0.5 ), - inputTrackJetTag = cms.InputTag( "hltAK4Iter0TrackJets4Iter1" ), - nTrkMaxInCaloCone = cms.int32( 0 ), - inputCaloJetTag = cms.InputTag( "hltAK4CaloJetsPFEt5" ), - etaMinCaloJet = cms.double( -2.7 ), - etaMaxCaloJet = cms.double( 2.7 ), - ptMinCaloJet = cms.double( 5.0 ), - inputTrackTag = cms.InputTag( "hltIter0PFlowTrackSelectionHighPurity" ) -) -hltIter1ClustersRefRemoval = cms.EDProducer( "TrackClusterRemover", - minNumberOfLayersWithMeasBeforeFiltering = cms.int32( 0 ), - maxChi2 = cms.double( 9.0 ), - trajectories = cms.InputTag( "hltIter0PFlowTrackSelectionHighPurity" ), - oldClusterRemovalInfo = cms.InputTag( "" ), - stripClusters = cms.InputTag( "hltSiStripRawToClustersFacility" ), - overrideTrkQuals = cms.InputTag( "" ), - pixelClusters = cms.InputTag( "hltSiPixelClusters" ), - TrackQuality = cms.string( "highPurity" ) -) -hltIter1MaskedMeasurementTrackerEvent = cms.EDProducer( "MaskedMeasurementTrackerEventProducer", - clustersToSkip = cms.InputTag( "hltIter1ClustersRefRemoval" ), - OnDemand = cms.bool( False ), - src = cms.InputTag( "hltSiStripClusters" ) -) -hltIter1PixelLayerTriplets = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2+BPix3', - 'BPix1+BPix2+FPix1_pos', - 'BPix1+BPix2+FPix1_neg', - 'BPix1+FPix1_pos+FPix2_pos', - 'BPix1+FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter1ClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0051 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter1ClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0027 ) - ), - TIB = cms.PSet( ) -) -hltIter1PFlowPixelSeeds = cms.EDProducer( "SeedGeneratorFromRegionHitsEDProducer", - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "CandidateSeededTrackingRegionsProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.05 ), - searchOpt = cms.bool( True ), - ptMin = cms.double( 0.5 ), - measurementTrackerName = cms.string( "hltIter1MaskedMeasurementTrackerEvent" ), - mode = cms.string( "VerticesFixed" ), - maxNRegions = cms.int32( 100 ), - maxNVertices = cms.int32( 10 ), - deltaPhi = cms.double( 1.0 ), - deltaEta = cms.double( 1.0 ), - zErrorBeamSpot = cms.double( 15.0 ), - nSigmaZBeamSpot = cms.double( 3.0 ), - zErrorVetex = cms.double( 0.1 ), - vertexCollection = cms.InputTag( "hltTrimmedPixelVertices" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - input = cms.InputTag( "hltIter0TrackAndTauJets4Iter1" ) - ) - ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ), - ClusterCheckPSet = cms.PSet( - PixelClusterCollectionLabel = cms.InputTag( "hltSiPixelClusters" ), - MaxNumberOfCosmicClusters = cms.uint32( 50000 ), - doClusterCheck = cms.bool( False ), - ClusterCollectionLabel = cms.InputTag( "hltSiStripClusters" ), - MaxNumberOfPixelClusters = cms.uint32( 10000 ) - ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitTripletGenerator" ), - GeneratorPSet = cms.PSet( - useBending = cms.bool( True ), - useFixedPreFiltering = cms.bool( False ), - maxElement = cms.uint32( 100000 ), - phiPreFiltering = cms.double( 0.3 ), - extraHitRPhitolerance = cms.double( 0.032 ), - useMultScattering = cms.bool( True ), - ComponentName = cms.string( "PixelTripletHLTGenerator" ), - extraHitRZtolerance = cms.double( 0.037 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) - ), - SeedingLayers = cms.InputTag( "hltIter1PixelLayerTriplets" ) - ), - SeedCreatorPSet = cms.PSet( - ComponentName = cms.string( "SeedFromConsecutiveHitsTripletOnlyCreator" ), - propagator = cms.string( "PropagatorWithMaterialParabolicMf" ), - SeedMomentumForBOFF = cms.double( 5.0 ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - TTRHBuilder = cms.string( "(unused)" ) +hltHISiPixelRecHits = cms.EDProducer( "SiPixelRecHitConverter", + VerboseLevel = cms.untracked.int32( 0 ), + src = cms.InputTag( "hltHISiPixelClusters" ), + CPE = cms.string( "hltESPPixelCPEGeneric" ) ) -hltIter1PFlowCkfTrackCandidates = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter1PFlowPixelSeeds" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter1MaskedMeasurementTrackerEvent" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter1PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) +hltSiStripExcludedFEDListProducer = cms.EDProducer( "SiStripExcludedFEDListProducer", + ProductLabel = cms.InputTag( "rawDataCollector" ) ) -hltIter1PFlowCtfWithMaterialTracks = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter1PFlowCkfTrackCandidates" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter1MaskedMeasurementTrackerEvent" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIter1" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -hltIter1PFlowTrackSelectionHighPurityLoose = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.9, 3.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.8, 3.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter1PFlowCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltTrimmedPixelVertices" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.9, 3.0 ), - d0_par1 = cms.vdouble( 0.85, 3.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -hltIter1PFlowTrackSelectionHighPurityTight = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 5 ), - chi2n_par = cms.double( 0.4 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 1.0, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 1.0, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter1PFlowCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltTrimmedPixelVertices" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 1.0, 4.0 ), - d0_par1 = cms.vdouble( 1.0, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -hltIter1PFlowTrackSelectionHighPurity = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter1PFlowTrackSelectionHighPurityLoose','hltIter1PFlowTrackSelectionHighPurityTight' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter1PFlowTrackSelectionHighPurityLoose','hltIter1PFlowTrackSelectionHighPurityTight' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -hltIter1Merged = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter0PFlowTrackSelectionHighPurity','hltIter1PFlowTrackSelectionHighPurity' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter0PFlowTrackSelectionHighPurity','hltIter1PFlowTrackSelectionHighPurity' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -hltIter1TrackRefsForJets4Iter2 = cms.EDProducer( "ChargedRefCandidateProducer", - src = cms.InputTag( "hltIter1Merged" ), - particleType = cms.string( "pi+" ) -) -hltAK4Iter1TrackJets4Iter2 = cms.EDProducer( "FastjetJetProducer", - Active_Area_Repeats = cms.int32( 5 ), - doAreaFastjet = cms.bool( False ), - voronoiRfact = cms.double( 0.9 ), - maxBadHcalCells = cms.uint32( 9999999 ), - doAreaDiskApprox = cms.bool( False ), - maxRecoveredEcalCells = cms.uint32( 9999999 ), - jetType = cms.string( "TrackJet" ), - minSeed = cms.uint32( 14327 ), - Ghost_EtaMax = cms.double( 6.0 ), - doRhoFastjet = cms.bool( False ), - jetAlgorithm = cms.string( "AntiKt" ), - nSigmaPU = cms.double( 1.0 ), - GhostArea = cms.double( 0.01 ), - Rho_EtaMax = cms.double( 4.4 ), - maxBadEcalCells = cms.uint32( 9999999 ), - useDeterministicSeed = cms.bool( True ), - doPVCorrection = cms.bool( False ), - maxRecoveredHcalCells = cms.uint32( 9999999 ), - rParam = cms.double( 0.4 ), - maxProblematicHcalCells = cms.uint32( 9999999 ), - doOutputJets = cms.bool( True ), - src = cms.InputTag( "hltIter1TrackRefsForJets4Iter2" ), - inputEtMin = cms.double( 0.1 ), - puPtMin = cms.double( 0.0 ), - srcPVs = cms.InputTag( "hltTrimmedPixelVertices" ), - jetPtMin = cms.double( 7.5 ), - radiusPU = cms.double( 0.4 ), - maxProblematicEcalCells = cms.uint32( 9999999 ), - doPUOffsetCorr = cms.bool( False ), - inputEMin = cms.double( 0.0 ), - useMassDropTagger = cms.bool( False ), - muMin = cms.double( -1.0 ), - subtractorName = cms.string( "" ), - muCut = cms.double( -1.0 ), - subjetPtMin = cms.double( -1.0 ), - useTrimming = cms.bool( False ), - muMax = cms.double( -1.0 ), - yMin = cms.double( -1.0 ), - useFiltering = cms.bool( False ), - rFilt = cms.double( -1.0 ), - yMax = cms.double( -1.0 ), - zcut = cms.double( -1.0 ), - MinVtxNdof = cms.int32( 0 ), - MaxVtxZ = cms.double( 30.0 ), - UseOnlyVertexTracks = cms.bool( False ), - dRMin = cms.double( -1.0 ), - nFilt = cms.int32( -1 ), - usePruning = cms.bool( False ), - maxDepth = cms.int32( -1 ), - yCut = cms.double( -1.0 ), - DzTrVtxMax = cms.double( 0.5 ), - UseOnlyOnePV = cms.bool( True ), - rcut_factor = cms.double( -1.0 ), - sumRecHits = cms.bool( False ), - trimPtFracMin = cms.double( -1.0 ), - dRMax = cms.double( -1.0 ), - DxyTrVtxMax = cms.double( 0.2 ), - useCMSBoostedTauSeedingAlgorithm = cms.bool( False ) -) -hltIter1TrackAndTauJets4Iter2 = cms.EDProducer( "TauJetSelectorForHLTTrackSeeding", - fractionMinCaloInTauCone = cms.double( 0.7 ), - fractionMaxChargedPUInCaloCone = cms.double( 0.3 ), - tauConeSize = cms.double( 0.2 ), - ptTrkMaxInCaloCone = cms.double( 1.4 ), - isolationConeSize = cms.double( 0.5 ), - inputTrackJetTag = cms.InputTag( "hltAK4Iter1TrackJets4Iter2" ), - nTrkMaxInCaloCone = cms.int32( 0 ), - inputCaloJetTag = cms.InputTag( "hltAK4CaloJetsPFEt5" ), - etaMinCaloJet = cms.double( -2.7 ), - etaMaxCaloJet = cms.double( 2.7 ), - ptMinCaloJet = cms.double( 5.0 ), - inputTrackTag = cms.InputTag( "hltIter1Merged" ) -) -hltIter2ClustersRefRemoval = cms.EDProducer( "TrackClusterRemover", - minNumberOfLayersWithMeasBeforeFiltering = cms.int32( 0 ), - maxChi2 = cms.double( 16.0 ), - trajectories = cms.InputTag( "hltIter1PFlowTrackSelectionHighPurity" ), - oldClusterRemovalInfo = cms.InputTag( "hltIter1ClustersRefRemoval" ), - stripClusters = cms.InputTag( "hltSiStripRawToClustersFacility" ), - overrideTrkQuals = cms.InputTag( "" ), - pixelClusters = cms.InputTag( "hltSiPixelClusters" ), - TrackQuality = cms.string( "highPurity" ) -) -hltIter2MaskedMeasurementTrackerEvent = cms.EDProducer( "MaskedMeasurementTrackerEventProducer", - clustersToSkip = cms.InputTag( "hltIter2ClustersRefRemoval" ), - OnDemand = cms.bool( False ), - src = cms.InputTag( "hltSiStripClusters" ) -) -hltIter2PixelLayerPairs = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2', - 'BPix1+BPix3', - 'BPix2+BPix3', - 'BPix1+FPix1_pos', - 'BPix1+FPix1_neg', - 'BPix1+FPix2_pos', - 'BPix1+FPix2_neg', - 'BPix2+FPix1_pos', - 'BPix2+FPix1_neg', - 'BPix2+FPix2_pos', - 'BPix2+FPix2_neg', - 'FPix1_pos+FPix2_pos', - 'FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter2ClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0051 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter2ClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0027 ) - ), - TIB = cms.PSet( ) -) -hltIter2PFlowPixelSeeds = cms.EDProducer( "SeedGeneratorFromRegionHitsEDProducer", - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "CandidateSeededTrackingRegionsProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.025 ), - searchOpt = cms.bool( True ), - originZPos = cms.double( 0.0 ), - ptMin = cms.double( 1.2 ), - measurementTrackerName = cms.string( "hltIter2MaskedMeasurementTrackerEvent" ), - mode = cms.string( "VerticesFixed" ), - maxNRegions = cms.int32( 100 ), - maxNVertices = cms.int32( 10 ), - deltaPhi = cms.double( 0.8 ), - deltaEta = cms.double( 0.8 ), - zErrorBeamSpot = cms.double( 15.0 ), - nSigmaZBeamSpot = cms.double( 3.0 ), - zErrorVetex = cms.double( 0.05 ), - vertexCollection = cms.InputTag( "hltTrimmedPixelVertices" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - input = cms.InputTag( "hltIter1TrackAndTauJets4Iter2" ) - ) - ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ), - ClusterCheckPSet = cms.PSet( - PixelClusterCollectionLabel = cms.InputTag( "hltSiPixelClusters" ), - MaxNumberOfCosmicClusters = cms.uint32( 50000 ), - doClusterCheck = cms.bool( False ), - ClusterCollectionLabel = cms.InputTag( "hltSiStripClusters" ), - MaxNumberOfPixelClusters = cms.uint32( 10000 ) - ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitPairGenerator" ), - GeneratorPSet = cms.PSet( - maxElement = cms.uint32( 100000 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) - ), - SeedingLayers = cms.InputTag( "hltIter2PixelLayerPairs" ) +hltSiStripRawToClustersFacility = cms.EDProducer( "SiStripClusterizerFromRaw", + ProductLabel = cms.InputTag( "rawDataCollector" ), + DoAPVEmulatorCheck = cms.bool( False ), + Algorithms = cms.PSet( + SiStripFedZeroSuppressionMode = cms.uint32( 4 ), + CommonModeNoiseSubtractionMode = cms.string( "Median" ), + PedestalSubtractionFedMode = cms.bool( True ), + TruncateInSuppressor = cms.bool( True ), + doAPVRestore = cms.bool( False ), + useCMMeanMap = cms.bool( False ) ), - SeedCreatorPSet = cms.PSet( - ComponentName = cms.string( "SeedFromConsecutiveHitsCreator" ), - propagator = cms.string( "PropagatorWithMaterialParabolicMf" ), - SeedMomentumForBOFF = cms.double( 5.0 ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + Clusterizer = cms.PSet( + ChannelThreshold = cms.double( 2.0 ), + MaxSequentialBad = cms.uint32( 1 ), + MaxSequentialHoles = cms.uint32( 0 ), + Algorithm = cms.string( "ThreeThresholdAlgorithm" ), + MaxAdjacentBad = cms.uint32( 0 ), + QualityLabel = cms.string( "" ), + SeedThreshold = cms.double( 3.0 ), + ClusterThreshold = cms.double( 5.0 ), + setDetId = cms.bool( True ), + RemoveApvShots = cms.bool( True ) ), - TTRHBuilder = cms.string( "(unused)" ) + onDemand = cms.bool( True ) ) -hltIter2PFlowCkfTrackCandidates = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter2PFlowPixelSeeds" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter2MaskedMeasurementTrackerEvent" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter2PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) +hltHISiStripClusters = cms.EDProducer( "MeasurementTrackerEventProducer", + inactivePixelDetectorLabels = cms.VInputTag( ), + stripClusterProducer = cms.string( "hltSiStripRawToClustersFacility" ), + pixelClusterProducer = cms.string( "hltHISiPixelClusters" ), + switchOffPixelsIfEmpty = cms.bool( True ), + inactiveStripDetectorLabels = cms.VInputTag( 'hltSiStripExcludedFEDListProducer' ), + skipClusters = cms.InputTag( "" ), + measurementTracker = cms.string( "hltESPMeasurementTracker" ) ) -hltIter2PFlowCtfWithMaterialTracks = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter2PFlowCkfTrackCandidates" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter2MaskedMeasurementTrackerEvent" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIter2" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -hltIter2PFlowTrackSelectionHighPurity = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.4, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.35, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter2PFlowCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltTrimmedPixelVertices" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.4, 4.0 ), - d0_par1 = cms.vdouble( 0.3, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -hltIter2Merged = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter1Merged','hltIter2PFlowTrackSelectionHighPurity' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter1Merged','hltIter2PFlowTrackSelectionHighPurity' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -hltPFMuonMerging = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltL3TkTracksFromL2','hltIter2Merged' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltL3TkTracksFromL2','hltIter2Merged' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -hltMuonLinks = cms.EDProducer( "MuonLinksProducerForHLT", - pMin = cms.double( 2.5 ), - InclusiveTrackerTrackCollection = cms.InputTag( "hltPFMuonMerging" ), - shareHitFraction = cms.double( 0.8 ), - LinkCollection = cms.InputTag( "hltL3MuonsLinksCombination" ), - ptMin = cms.double( 2.5 ) -) -hltMuons = cms.EDProducer( "MuonIdProducer", - TrackExtractorPSet = cms.PSet( - Diff_z = cms.double( 0.2 ), - inputTrackCollection = cms.InputTag( "hltPFMuonMerging" ), - BeamSpotLabel = cms.InputTag( "hltOnlineBeamSpot" ), - ComponentName = cms.string( "TrackExtractor" ), - DR_Max = cms.double( 1.0 ), - Diff_r = cms.double( 0.1 ), - Chi2Prob_Min = cms.double( -1.0 ), - DR_Veto = cms.double( 0.01 ), - NHits_Min = cms.uint32( 0 ), - Chi2Ndof_Max = cms.double( 1.0E64 ), - Pt_Min = cms.double( -1.0 ), - DepositLabel = cms.untracked.string( "" ), - BeamlineOption = cms.string( "BeamSpotFromEvent" ) - ), - maxAbsEta = cms.double( 3.0 ), - fillGlobalTrackRefits = cms.bool( False ), - arbitrationCleanerOptions = cms.PSet( - Clustering = cms.bool( True ), - ME1a = cms.bool( True ), - ClusterDPhi = cms.double( 0.6 ), - OverlapDTheta = cms.double( 0.02 ), - Overlap = cms.bool( True ), - OverlapDPhi = cms.double( 0.0786 ), - ClusterDTheta = cms.double( 0.02 ) - ), - globalTrackQualityInputTag = cms.InputTag( "glbTrackQual" ), - addExtraSoftMuons = cms.bool( False ), - debugWithTruthMatching = cms.bool( False ), - CaloExtractorPSet = cms.PSet( - PrintTimeReport = cms.untracked.bool( False ), - DR_Max = cms.double( 1.0 ), - DepositInstanceLabels = cms.vstring( 'ecal', - 'hcal', - 'ho' ), - Noise_HE = cms.double( 0.2 ), - NoiseTow_EB = cms.double( 0.04 ), - NoiseTow_EE = cms.double( 0.15 ), - Threshold_H = cms.double( 0.5 ), - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPFastSteppingHelixPropagatorAny' ), - RPCLayers = cms.bool( False ), - UseMuonNavigation = cms.untracked.bool( False ) - ), - Threshold_E = cms.double( 0.2 ), - PropagatorName = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - DepositLabel = cms.untracked.string( "Cal" ), - UseRecHitsFlag = cms.bool( False ), - TrackAssociatorParameters = cms.PSet( - muonMaxDistanceSigmaX = cms.double( 0.0 ), - muonMaxDistanceSigmaY = cms.double( 0.0 ), - CSCSegmentCollectionLabel = cms.InputTag( "hltCscSegments" ), - dRHcal = cms.double( 1.0 ), - dRPreshowerPreselection = cms.double( 0.2 ), - CaloTowerCollectionLabel = cms.InputTag( "hltTowerMakerForPF" ), - useEcal = cms.bool( False ), - dREcal = cms.double( 1.0 ), - dREcalPreselection = cms.double( 1.0 ), - HORecHitCollectionLabel = cms.InputTag( "hltHoreco" ), - dRMuon = cms.double( 9999.0 ), - propagateAllDirections = cms.bool( True ), - muonMaxDistanceX = cms.double( 5.0 ), - muonMaxDistanceY = cms.double( 5.0 ), - useHO = cms.bool( False ), - trajectoryUncertaintyTolerance = cms.double( -1.0 ), - usePreshower = cms.bool( False ), - DTRecSegment4DCollectionLabel = cms.InputTag( "hltDt4DSegments" ), - EERecHitCollectionLabel = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEE' ), - dRHcalPreselection = cms.double( 1.0 ), - useMuon = cms.bool( False ), - useCalo = cms.bool( True ), - accountForTrajectoryChangeCalo = cms.bool( False ), - EBRecHitCollectionLabel = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEB' ), - dRMuonPreselection = cms.double( 0.2 ), - truthMatch = cms.bool( False ), - HBHERecHitCollectionLabel = cms.InputTag( "hltHbhereco" ), - useHcal = cms.bool( False ) - ), - Threshold_HO = cms.double( 0.5 ), - Noise_EE = cms.double( 0.1 ), - Noise_EB = cms.double( 0.025 ), - DR_Veto_H = cms.double( 0.1 ), - CenterConeOnCalIntersection = cms.bool( False ), - ComponentName = cms.string( "CaloExtractorByAssociator" ), - Noise_HB = cms.double( 0.2 ), - DR_Veto_E = cms.double( 0.07 ), - DR_Veto_HO = cms.double( 0.1 ), - Noise_HO = cms.double( 0.2 ) - ), - runArbitrationCleaner = cms.bool( False ), - fillEnergy = cms.bool( True ), - TrackerKinkFinderParameters = cms.PSet( - usePosition = cms.bool( False ), - diagonalOnly = cms.bool( False ) - ), - TimingFillerParameters = cms.PSet( - UseDT = cms.bool( True ), - ErrorDT = cms.double( 6.0 ), - EcalEnergyCut = cms.double( 0.4 ), - ErrorEB = cms.double( 2.085 ), - ErrorCSC = cms.double( 7.4 ), - CSCTimingParameters = cms.PSet( - CSCsegments = cms.InputTag( "hltCscSegments" ), - CSCTimeOffset = cms.double( 0.0 ), - CSCStripTimeOffset = cms.double( 0.0 ), - MatchParameters = cms.PSet( - CSCsegments = cms.InputTag( "hltCscSegments" ), - DTsegments = cms.InputTag( "hltDt4DSegments" ), - DTradius = cms.double( 0.01 ), - TightMatchDT = cms.bool( False ), - TightMatchCSC = cms.bool( True ) - ), - debug = cms.bool( False ), - UseStripTime = cms.bool( True ), - CSCStripError = cms.double( 7.0 ), - CSCWireError = cms.double( 8.6 ), - CSCWireTimeOffset = cms.double( 0.0 ), - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPFastSteppingHelixPropagatorAny' ), - RPCLayers = cms.bool( True ) - ), - PruneCut = cms.double( 100.0 ), - UseWireTime = cms.bool( True ) - ), - DTTimingParameters = cms.PSet( - HitError = cms.double( 6.0 ), - DoWireCorr = cms.bool( False ), - MatchParameters = cms.PSet( - CSCsegments = cms.InputTag( "hltCscSegments" ), - DTsegments = cms.InputTag( "hltDt4DSegments" ), - DTradius = cms.double( 0.01 ), - TightMatchDT = cms.bool( False ), - TightMatchCSC = cms.bool( True ) - ), - debug = cms.bool( False ), - DTsegments = cms.InputTag( "hltDt4DSegments" ), - PruneCut = cms.double( 10000.0 ), - RequireBothProjections = cms.bool( False ), - HitsMin = cms.int32( 5 ), - DTTimeOffset = cms.double( 2.7 ), - DropTheta = cms.bool( True ), - UseSegmentT0 = cms.bool( False ), - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPFastSteppingHelixPropagatorAny' ), - RPCLayers = cms.bool( True ) - ) - ), - ErrorEE = cms.double( 6.95 ), - UseCSC = cms.bool( True ), - UseECAL = cms.bool( True ) - ), - inputCollectionTypes = cms.vstring( 'inner tracks', - 'links', - 'outer tracks' ), - minCaloCompatibility = cms.double( 0.6 ), - ecalDepositName = cms.string( "ecal" ), - minP = cms.double( 10.0 ), - fillIsolation = cms.bool( True ), - jetDepositName = cms.string( "jets" ), - hoDepositName = cms.string( "ho" ), - writeIsoDeposits = cms.bool( False ), - maxAbsPullX = cms.double( 4.0 ), - maxAbsPullY = cms.double( 9999.0 ), - minPt = cms.double( 10.0 ), - TrackAssociatorParameters = cms.PSet( - muonMaxDistanceSigmaX = cms.double( 0.0 ), - muonMaxDistanceSigmaY = cms.double( 0.0 ), - CSCSegmentCollectionLabel = cms.InputTag( "hltCscSegments" ), - dRHcal = cms.double( 9999.0 ), - dRPreshowerPreselection = cms.double( 0.2 ), - CaloTowerCollectionLabel = cms.InputTag( "hltTowerMakerForPF" ), - useEcal = cms.bool( True ), - dREcal = cms.double( 9999.0 ), - dREcalPreselection = cms.double( 0.05 ), - HORecHitCollectionLabel = cms.InputTag( "hltHoreco" ), - dRMuon = cms.double( 9999.0 ), - propagateAllDirections = cms.bool( True ), - muonMaxDistanceX = cms.double( 5.0 ), - muonMaxDistanceY = cms.double( 5.0 ), - useHO = cms.bool( True ), - trajectoryUncertaintyTolerance = cms.double( -1.0 ), - usePreshower = cms.bool( False ), - DTRecSegment4DCollectionLabel = cms.InputTag( "hltDt4DSegments" ), - EERecHitCollectionLabel = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEE' ), - dRHcalPreselection = cms.double( 0.2 ), - useMuon = cms.bool( True ), - useCalo = cms.bool( False ), - accountForTrajectoryChangeCalo = cms.bool( False ), - EBRecHitCollectionLabel = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEB' ), - dRMuonPreselection = cms.double( 0.2 ), - truthMatch = cms.bool( False ), - HBHERecHitCollectionLabel = cms.InputTag( "hltHbhereco" ), - useHcal = cms.bool( True ) - ), - JetExtractorPSet = cms.PSet( - PrintTimeReport = cms.untracked.bool( False ), - ExcludeMuonVeto = cms.bool( True ), - TrackAssociatorParameters = cms.PSet( - muonMaxDistanceSigmaX = cms.double( 0.0 ), - muonMaxDistanceSigmaY = cms.double( 0.0 ), - CSCSegmentCollectionLabel = cms.InputTag( "hltCscSegments" ), - dRHcal = cms.double( 0.5 ), - dRPreshowerPreselection = cms.double( 0.2 ), - CaloTowerCollectionLabel = cms.InputTag( "hltTowerMakerForPF" ), - useEcal = cms.bool( False ), - dREcal = cms.double( 0.5 ), - dREcalPreselection = cms.double( 0.5 ), - HORecHitCollectionLabel = cms.InputTag( "hltHoreco" ), - dRMuon = cms.double( 9999.0 ), - propagateAllDirections = cms.bool( True ), - muonMaxDistanceX = cms.double( 5.0 ), - muonMaxDistanceY = cms.double( 5.0 ), - useHO = cms.bool( False ), - trajectoryUncertaintyTolerance = cms.double( -1.0 ), - usePreshower = cms.bool( False ), - DTRecSegment4DCollectionLabel = cms.InputTag( "hltDt4DSegments" ), - EERecHitCollectionLabel = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEE' ), - dRHcalPreselection = cms.double( 0.5 ), - useMuon = cms.bool( False ), - useCalo = cms.bool( True ), - accountForTrajectoryChangeCalo = cms.bool( False ), - EBRecHitCollectionLabel = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEB' ), - dRMuonPreselection = cms.double( 0.2 ), - truthMatch = cms.bool( False ), - HBHERecHitCollectionLabel = cms.InputTag( "hltHbhereco" ), - useHcal = cms.bool( False ) - ), - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPFastSteppingHelixPropagatorAny' ), - RPCLayers = cms.bool( False ), - UseMuonNavigation = cms.untracked.bool( False ) - ), - ComponentName = cms.string( "JetExtractor" ), - DR_Max = cms.double( 1.0 ), - PropagatorName = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - JetCollectionLabel = cms.InputTag( "hltAK4CaloJetsPFEt5" ), - DR_Veto = cms.double( 0.1 ), - Threshold = cms.double( 5.0 ) - ), - fillGlobalTrackQuality = cms.bool( False ), - minPCaloMuon = cms.double( 1.0E9 ), - maxAbsDy = cms.double( 9999.0 ), - fillCaloCompatibility = cms.bool( True ), - fillMatching = cms.bool( True ), - MuonCaloCompatibility = cms.PSet( - allSiPMHO = cms.bool( False ), - PionTemplateFileName = cms.FileInPath( "RecoMuon/MuonIdentification/data/MuID_templates_pions_lowPt_3_1_norm.root" ), - MuonTemplateFileName = cms.FileInPath( "RecoMuon/MuonIdentification/data/MuID_templates_muons_lowPt_3_1_norm.root" ), - delta_eta = cms.double( 0.02 ), - delta_phi = cms.double( 0.02 ) - ), - fillTrackerKink = cms.bool( False ), - hcalDepositName = cms.string( "hcal" ), - sigmaThresholdToFillCandidateP4WithGlobalFit = cms.double( 2.0 ), - inputCollectionLabels = cms.VInputTag( 'hltPFMuonMerging','hltMuonLinks','hltL2Muons' ), - trackDepositName = cms.string( "tracker" ), - maxAbsDx = cms.double( 3.0 ), - ptThresholdToFillCandidateP4WithGlobalFit = cms.double( 200.0 ), - minNumberOfMatches = cms.int32( 1 ) -) -hltParticleFlowRecHitECALUnseeded = cms.EDProducer( "PFRecHitProducer", - producers = cms.VPSet( - cms.PSet( src = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEB' ), - qualityTests = cms.VPSet( - cms.PSet( threshold = cms.double( 0.08 ), - name = cms.string( "PFRecHitQTestThreshold" ) +hltHIL3TrajSeedOIState = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + propagatorCompatibleName = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + option = cms.uint32( 3 ), + maxChi2 = cms.double( 40.0 ), + errorMatrixPset = cms.PSet( + atIP = cms.bool( True ), + action = cms.string( "use" ), + errorMatrixValuesPSet = cms.PSet( + pf3_V12 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) ), - cms.PSet( timingCleaning = cms.bool( True ), - topologicalCleaning = cms.bool( True ), - cleaningThreshold = cms.double( 2.0 ), - skipTTRecoveredHits = cms.bool( True ), - name = cms.string( "PFRecHitQTestECAL" ) - ) - ), - name = cms.string( "PFEBRecHitCreator" ) - ), - cms.PSet( src = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEE' ), - qualityTests = cms.VPSet( - cms.PSet( threshold = cms.double( 0.3 ), - name = cms.string( "PFRecHitQTestThreshold" ) + pf3_V13 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) ), - cms.PSet( timingCleaning = cms.bool( True ), - topologicalCleaning = cms.bool( True ), - cleaningThreshold = cms.double( 2.0 ), - skipTTRecoveredHits = cms.bool( True ), - name = cms.string( "PFRecHitQTestECAL" ) - ) - ), - name = cms.string( "PFEERecHitCreator" ) - ) - ), - navigator = cms.PSet( - barrel = cms.PSet( ), - endcap = cms.PSet( ), - name = cms.string( "PFRecHitECALNavigator" ) - ) -) -hltParticleFlowRecHitHCAL = cms.EDProducer( "PFCTRecHitProducer", - ECAL_Compensate = cms.bool( False ), - ECAL_Dead_Code = cms.uint32( 10 ), - MinLongTiming_Cut = cms.double( -5.0 ), - ECAL_Compensation = cms.double( 0.5 ), - MaxLongTiming_Cut = cms.double( 5.0 ), - weight_HFhad = cms.double( 1.0 ), - ApplyPulseDPG = cms.bool( False ), - navigator = cms.PSet( name = cms.string( "PFRecHitCaloTowerNavigator" ) ), - ECAL_Threshold = cms.double( 10.0 ), - ApplyTimeDPG = cms.bool( False ), - caloTowers = cms.InputTag( "hltTowerMakerForPF" ), - hcalRecHitsHBHE = cms.InputTag( "hltHbhereco" ), - LongFibre_Fraction = cms.double( 0.1 ), - MaxShortTiming_Cut = cms.double( 5.0 ), - HcalMaxAllowedHFLongShortSev = cms.int32( 9 ), - thresh_Barrel = cms.double( 0.4 ), - navigation_HF = cms.bool( True ), - HcalMaxAllowedHFInTimeWindowSev = cms.int32( 9 ), - HF_Calib_29 = cms.double( 1.07 ), - LongFibre_Cut = cms.double( 120.0 ), - EM_Depth = cms.double( 22.0 ), - weight_HFem = cms.double( 1.0 ), - LongShortFibre_Cut = cms.double( 1.0E9 ), - MinShortTiming_Cut = cms.double( -5.0 ), - HCAL_Calib = cms.bool( True ), - thresh_HF = cms.double( 0.4 ), - HcalMaxAllowedHFDigiTimeSev = cms.int32( 9 ), - thresh_Endcap = cms.double( 0.4 ), - HcalMaxAllowedChannelStatusSev = cms.int32( 9 ), - hcalRecHitsHF = cms.InputTag( "hltHfreco" ), - ShortFibre_Cut = cms.double( 60.0 ), - ApplyLongShortDPG = cms.bool( True ), - HF_Calib = cms.bool( True ), - HAD_Depth = cms.double( 47.0 ), - ShortFibre_Fraction = cms.double( 0.01 ), - HCAL_Calib_29 = cms.double( 1.35 ) -) -hltParticleFlowRecHitPSUnseeded = cms.EDProducer( "PFRecHitProducer", - producers = cms.VPSet( - cms.PSet( src = cms.InputTag( 'hltEcalPreshowerRecHit','EcalRecHitsES' ), - qualityTests = cms.VPSet( - cms.PSet( threshold = cms.double( 7.0E-6 ), - name = cms.string( "PFRecHitQTestThreshold" ) - ) - ), - name = cms.string( "PFPSRecHitCreator" ) - ) - ), - navigator = cms.PSet( name = cms.string( "PFRecHitPreshowerNavigator" ) ) -) -hltParticleFlowClusterECALUncorrectedUnseeded = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.08 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( 9 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - minFracTot = cms.double( 1.0E-20 ), - positionCalcForConvergence = cms.PSet( - minFractionInCalc = cms.double( 0.0 ), - W0 = cms.double( 4.2 ), - minAllowedNormalization = cms.double( 0.0 ), - T0_EB = cms.double( 7.4 ), - X0 = cms.double( 0.89 ), - T0_ES = cms.double( 1.2 ), - T0_EE = cms.double( 3.1 ), - algoName = cms.string( "ECAL2DPositionCalcWithDepthCorr" ) - ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 1.5 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "ECAL_BARREL" ), - recHitEnergyNorm = cms.double( 0.08 ) - ), - cms.PSet( detector = cms.string( "ECAL_ENDCAP" ), - recHitEnergyNorm = cms.double( 0.3 ) - ) - ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ), - allCellsPositionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.08 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ) - ), - positionReCalc = cms.PSet( - minFractionInCalc = cms.double( 0.0 ), - W0 = cms.double( 4.2 ), - minAllowedNormalization = cms.double( 0.0 ), - T0_EB = cms.double( 7.4 ), - X0 = cms.double( 0.89 ), - T0_ES = cms.double( 1.2 ), - T0_EE = cms.double( 3.1 ), - algoName = cms.string( "ECAL2DPositionCalcWithDepthCorr" ) - ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 0.08 ), - detector = cms.string( "ECAL_BARREL" ), - gatheringThresholdPt = cms.double( 0.0 ) - ), - cms.PSet( gatheringThreshold = cms.double( 0.3 ), - detector = cms.string( "ECAL_ENDCAP" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) - ), - useCornerCells = cms.bool( True ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - cms.PSet( cleaningByDetector = cms.VPSet( - cms.PSet( doubleSpikeS6S2 = cms.double( 0.04 ), - fractionThresholdModifier = cms.double( 3.0 ), - doubleSpikeThresh = cms.double( 10.0 ), - minS4S1_b = cms.double( -0.024 ), - singleSpikeThresh = cms.double( 4.0 ), - detector = cms.string( "ECAL_BARREL" ), - minS4S1_a = cms.double( 0.04 ), - energyThresholdModifier = cms.double( 2.0 ) - ), - cms.PSet( doubleSpikeS6S2 = cms.double( -1.0 ), - fractionThresholdModifier = cms.double( 3.0 ), - doubleSpikeThresh = cms.double( 1.0E9 ), - minS4S1_b = cms.double( -0.0125 ), - singleSpikeThresh = cms.double( 15.0 ), - detector = cms.string( "ECAL_ENDCAP" ), - minS4S1_a = cms.double( 0.02 ), - energyThresholdModifier = cms.double( 2.0 ) - ) -), - algoName = cms.string( "SpikeAndDoubleSpikeCleaner" ) - ) - ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 8 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 0.6 ), - seedingThresholdPt = cms.double( 0.15 ), - detector = cms.string( "ECAL_ENDCAP" ) - ), - cms.PSet( seedingThreshold = cms.double( 0.23 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "ECAL_BARREL" ) - ) - ), - algoName = cms.string( "LocalMaximumSeedFinder" ) - ), - recHitsSource = cms.InputTag( "hltParticleFlowRecHitECALUnseeded" ) -) -hltParticleFlowClusterPSUnseeded = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - minFracTot = cms.double( 1.0E-20 ), - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 6.0E-5 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 0.3 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "PS1" ), - recHitEnergyNorm = cms.double( 6.0E-5 ) - ), - cms.PSet( detector = cms.string( "PS2" ), - recHitEnergyNorm = cms.double( 6.0E-5 ) - ) - ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ) - ), - positionReCalc = cms.PSet( ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 6.0E-5 ), - detector = cms.string( "PS1" ), - gatheringThresholdPt = cms.double( 0.0 ) - ), - cms.PSet( gatheringThreshold = cms.double( 6.0E-5 ), - detector = cms.string( "PS2" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) - ), - useCornerCells = cms.bool( False ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 4 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 1.2E-4 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "PS1" ) - ), - cms.PSet( seedingThreshold = cms.double( 1.2E-4 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "PS2" ) - ) - ), - algoName = cms.string( "LocalMaximumSeedFinder" ) - ), - recHitsSource = cms.InputTag( "hltParticleFlowRecHitPSUnseeded" ) -) -hltParticleFlowClusterECALUnseeded = cms.EDProducer( "CorrectedECALPFClusterProducer", - inputPS = cms.InputTag( "hltParticleFlowClusterPSUnseeded" ), - minimumPSEnergy = cms.double( 0.0 ), - energyCorrector = cms.PSet( - applyCrackCorrections = cms.bool( False ), - algoName = cms.string( "PFClusterEMEnergyCorrector" ) - ), - inputECAL = cms.InputTag( "hltParticleFlowClusterECALUncorrectedUnseeded" ) -) -hltParticleFlowClusterHCAL = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( 5 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - minFracTot = cms.double( 1.0E-20 ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 10.0 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "HCAL_BARREL1" ), - recHitEnergyNorm = cms.double( 0.8 ) - ), - cms.PSet( detector = cms.string( "HCAL_ENDCAP" ), - recHitEnergyNorm = cms.double( 0.8 ) - ) - ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ), - allCellsPositionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ) - ), - positionReCalc = cms.PSet( ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 0.8 ), - detector = cms.string( "HCAL_BARREL1" ), - gatheringThresholdPt = cms.double( 0.0 ) - ), - cms.PSet( gatheringThreshold = cms.double( 0.8 ), - detector = cms.string( "HCAL_ENDCAP" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) - ), - useCornerCells = cms.bool( True ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - cms.PSet( algoName = cms.string( "RBXAndHPDCleaner" ) ) - ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 4 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 0.8 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "HCAL_BARREL1" ) - ), - cms.PSet( seedingThreshold = cms.double( 1.1 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "HCAL_ENDCAP" ) + pf3_V11 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V14 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V15 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), + pf3_V33 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + zAxis = cms.vdouble( -3.14159, 3.14159 ), + pf3_V44 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), + pf3_V22 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V23 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V45 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V55 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V34 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V35 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V25 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V24 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ) ) ), - algoName = cms.string( "LocalMaximumSeedFinder" ) + propagatorName = cms.string( "hltESPSteppingHelixPropagatorAlong" ), + manySeeds = cms.bool( False ), + copyMuonRecHit = cms.bool( False ), + ComponentName = cms.string( "TSGForRoadSearch" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ) ), - recHitsSource = cms.InputTag( "hltParticleFlowRecHitHCAL" ) -) -hltParticleFlowClusterHFEM = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( 5 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - minFracTot = cms.double( 1.0E-20 ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 10.0 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "HF_EM" ), - recHitEnergyNorm = cms.double( 0.8 ) - ) - ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ), - allCellsPositionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ) + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSteppingHelixPropagatorOpposite', + 'hltESPSteppingHelixPropagatorAlong' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) ), - positionReCalc = cms.PSet( ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 0.8 ), - detector = cms.string( "HF_EM" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) - ), - useCornerCells = cms.bool( False ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( ), + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( ), + PtCut = cms.double( 1.0 ) +) +hltHIL3TrackCandidateFromL2OIState = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedOIState" ), + reverseTrajectories = cms.bool( True ), + TransientInitialStateEstimatorParameters = cms.PSet( + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), + numberMeasurementsForFit = cms.int32( 4 ), + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - cms.PSet( cleaningByDetector = cms.VPSet( - cms.PSet( doubleSpikeS6S2 = cms.double( -1.0 ), - fractionThresholdModifier = cms.double( 1.0 ), - doubleSpikeThresh = cms.double( 1.0E9 ), - minS4S1_b = cms.double( -0.19 ), - singleSpikeThresh = cms.double( 80.0 ), - detector = cms.string( "HF_EM" ), - minS4S1_a = cms.double( 0.11 ), - energyThresholdModifier = cms.double( 1.0 ) - ) -), - algoName = cms.string( "SpikeAndDoubleSpikeCleaner" ) - ) + TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + cleanTrajectoryAfterInOut = cms.bool( False ), + useHitsSplitting = cms.bool( False ), + RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), + doSeedingRegionRebuilding = cms.bool( False ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilderSeedHit" ) ), + NavigationSchool = cms.string( "SimpleNavigationSchool" ), + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) +) +hltHIL3TkTracksFromL2OIState = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2OIState" ), + SimpleMagneticField = cms.string( "" ), + clusterRemovalInfo = cms.InputTag( "" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), + useHitsSplitting = cms.bool( False ), + MeasurementTracker = cms.string( "" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), + NavigationSchool = cms.string( "" ), + TrajectoryInEvent = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + GeometricInnerState = cms.bool( True ), + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +hltHIL3MuonsOIState = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 0 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 1.4 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "HF_EM" ) - ) + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) ), - algoName = cms.string( "LocalMaximumSeedFinder" ) - ), - recHitsSource = cms.InputTag( 'hltParticleFlowRecHitHCAL','HFEM' ) -) -hltParticleFlowClusterHFHAD = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( 5 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) ), - minFracTot = cms.double( 1.0E-20 ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 10.0 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "HF_HAD" ), - recHitEnergyNorm = cms.double( 0.8 ) - ) + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ), - allCellsPositionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ) - ), - positionReCalc = cms.PSet( ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 0.8 ), - detector = cms.string( "HF_HAD" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) ), - useCornerCells = cms.bool( False ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - cms.PSet( cleaningByDetector = cms.VPSet( - cms.PSet( doubleSpikeS6S2 = cms.double( -1.0 ), - fractionThresholdModifier = cms.double( 1.0 ), - doubleSpikeThresh = cms.double( 1.0E9 ), - minS4S1_b = cms.double( -0.08 ), - singleSpikeThresh = cms.double( 120.0 ), - detector = cms.string( "HF_HAD" ), - minS4S1_a = cms.double( 0.045 ), - energyThresholdModifier = cms.double( 1.0 ) - ) -), - algoName = cms.string( "SpikeAndDoubleSpikeCleaner" ) - ) + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2OIState" ), + tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 0 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 1.4 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "HF_HAD" ) - ) + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) ), - algoName = cms.string( "LocalMaximumSeedFinder" ) + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) ), - recHitsSource = cms.InputTag( 'hltParticleFlowRecHitHCAL','HFHAD' ) -) -hltLightPFTracks = cms.EDProducer( "LightPFTrackProducer", - TrackQuality = cms.string( "none" ), - UseQuality = cms.bool( False ), - TkColList = cms.VInputTag( 'hltPFMuonMerging' ) + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) ) -hltParticleFlowBlock = cms.EDProducer( "PFBlockProducer", - debug = cms.untracked.bool( False ), - linkDefinitions = cms.VPSet( - cms.PSet( useKDTree = cms.bool( True ), - linkType = cms.string( "PS1:ECAL" ), - linkerName = cms.string( "PreshowerAndECALLinker" ) - ), - cms.PSet( useKDTree = cms.bool( True ), - linkType = cms.string( "PS2:ECAL" ), - linkerName = cms.string( "PreshowerAndECALLinker" ) - ), - cms.PSet( useKDTree = cms.bool( True ), - linkType = cms.string( "TRACK:ECAL" ), - linkerName = cms.string( "TrackAndECALLinker" ) - ), - cms.PSet( useKDTree = cms.bool( True ), - linkType = cms.string( "TRACK:HCAL" ), - linkerName = cms.string( "TrackAndHCALLinker" ) - ), - cms.PSet( useKDTree = cms.bool( False ), - linkType = cms.string( "ECAL:HCAL" ), - linkerName = cms.string( "ECALAndHCALLinker" ) - ), - cms.PSet( useKDTree = cms.bool( False ), - linkType = cms.string( "HFEM:HFHAD" ), - linkerName = cms.string( "HFEMAndHFHADLinker" ) - ) - ), - elementImporters = cms.VPSet( - cms.PSet( importerName = cms.string( "GeneralTracksImporter" ), - useIterativeTracking = cms.bool( False ), - source = cms.InputTag( "hltLightPFTracks" ), - NHitCuts_byTrackAlgo = cms.vuint32( 3, 3, 3, 3, 3 ), - muonSrc = cms.InputTag( "hltMuons" ), - DPtOverPtCuts_byTrackAlgo = cms.vdouble( 0.5, 0.5, 0.5, 0.5, 0.5 ) - ), - cms.PSet( importerName = cms.string( "ECALClusterImporter" ), - source = cms.InputTag( "hltParticleFlowClusterECALUnseeded" ), - BCtoPFCMap = cms.InputTag( "" ) - ), - cms.PSet( importerName = cms.string( "GenericClusterImporter" ), - source = cms.InputTag( "hltParticleFlowClusterHCAL" ) - ), - cms.PSet( importerName = cms.string( "GenericClusterImporter" ), - source = cms.InputTag( "hltParticleFlowClusterHFEM" ) - ), - cms.PSet( importerName = cms.string( "GenericClusterImporter" ), - source = cms.InputTag( "hltParticleFlowClusterHFHAD" ) +hltHIL3TrajSeedOIHit = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + PSetNames = cms.vstring( 'skipTSG', + 'iterativeTSG' ), + L3TkCollectionA = cms.InputTag( "hltHIL3MuonsOIState" ), + iterativeTSG = cms.PSet( + ErrorRescaling = cms.double( 3.0 ), + beamSpot = cms.InputTag( "unused" ), + MaxChi2 = cms.double( 40.0 ), + errorMatrixPset = cms.PSet( + atIP = cms.bool( True ), + action = cms.string( "use" ), + errorMatrixValuesPSet = cms.PSet( + pf3_V12 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V13 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V11 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V14 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V15 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), + pf3_V33 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + zAxis = cms.vdouble( -3.14159, 3.14159 ), + pf3_V44 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), + pf3_V22 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V23 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V45 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V55 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V34 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V35 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V25 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V24 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ) + ) + ), + UpdateState = cms.bool( True ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + SelectState = cms.bool( False ), + SigmaZ = cms.double( 25.0 ), + ResetMethod = cms.string( "matrix" ), + ComponentName = cms.string( "TSGFromPropagation" ), + UseVertexState = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAnyOpposite" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ) ), - cms.PSet( importerName = cms.string( "GenericClusterImporter" ), - source = cms.InputTag( "hltParticleFlowClusterPSUnseeded" ) - ) - ), - verbose = cms.untracked.bool( False ) -) -hltParticleFlow = cms.EDProducer( "PFProducer", - photon_SigmaiEtaiEta_endcap = cms.double( 0.034 ), - minPtForPostCleaning = cms.double( 20.0 ), - pf_nsigma_ECAL = cms.double( 0.0 ), - GedPhotonValueMap = cms.InputTag( 'tmpGedPhotons','valMapPFEgammaCandToPhoton' ), - sumPtTrackIsoForPhoton = cms.double( -1.0 ), - metFactorForFakes = cms.double( 4.0 ), - muon_HO = cms.vdouble( 0.9, 0.9 ), - electron_missinghits = cms.uint32( 1 ), - metSignificanceForCleaning = cms.double( 3.0 ), - usePFPhotons = cms.bool( False ), - dptRel_DispVtx = cms.double( 10.0 ), - nTrackIsoForEgammaSC = cms.uint32( 2 ), - pf_nsigma_HCAL = cms.double( 1.0 ), - cosmicRejectionDistance = cms.double( 1.0 ), - useEGammaFilters = cms.bool( False ), - useEGammaElectrons = cms.bool( False ), - nsigma_TRACK = cms.double( 1.0 ), - useEGammaSupercluster = cms.bool( False ), - sumPtTrackIsoForEgammaSC_barrel = cms.double( 4.0 ), - eventFractionForCleaning = cms.double( 0.8 ), - usePFDecays = cms.bool( False ), - rejectTracks_Step45 = cms.bool( False ), - eventFractionForRejection = cms.double( 0.8 ), - photon_MinEt = cms.double( 10.0 ), - usePFNuclearInteractions = cms.bool( False ), - maxSignificance = cms.double( 2.5 ), - electron_iso_mva_endcap = cms.double( -0.1075 ), - debug = cms.untracked.bool( False ), - pf_convID_mvaWeightFile = cms.string( "RecoParticleFlow/PFProducer/data/MVAnalysis_BDT.weights_pfConversionAug0411.txt" ), - calibHF_eta_step = cms.vdouble( 0.0, 2.9, 3.0, 3.2, 4.2, 4.4, 4.6, 4.8, 5.2, 5.4 ), - ptErrorScale = cms.double( 8.0 ), - minSignificance = cms.double( 2.5 ), - minMomentumForPunchThrough = cms.double( 100.0 ), - pf_conv_mvaCut = cms.double( 0.0 ), - useCalibrationsFromDB = cms.bool( True ), - usePFElectrons = cms.bool( False ), - electron_iso_combIso_endcap = cms.double( 10.0 ), - photon_combIso = cms.double( 10.0 ), - electron_iso_mva_barrel = cms.double( -0.1875 ), - postHFCleaning = cms.bool( False ), - factors_45 = cms.vdouble( 10.0, 100.0 ), - cleanedHF = cms.VInputTag( 'hltParticleFlowRecHitHCAL:Cleaned','hltParticleFlowClusterHFHAD:Cleaned','hltParticleFlowClusterHFEM:Cleaned' ), - coneEcalIsoForEgammaSC = cms.double( 0.3 ), - minSignificanceReduction = cms.double( 1.4 ), - photon_SigmaiEtaiEta_barrel = cms.double( 0.0125 ), - calibHF_b_HADonly = cms.vdouble( 1.27541, 0.85361, 0.86333, 0.89091, 0.94348, 0.94348, 0.9437, 1.0034, 1.0444, 1.0444 ), - minPixelHits = cms.int32( 1 ), - maxDPtOPt = cms.double( 1.0 ), - useHO = cms.bool( False ), - pf_electron_output_col = cms.string( "electrons" ), - electron_noniso_mvaCut = cms.double( -0.1 ), - GedElectronValueMap = cms.InputTag( "gedGsfElectronsTmp" ), - useVerticesForNeutral = cms.bool( True ), - pf_Res_mvaWeightFile = cms.string( "RecoParticleFlow/PFProducer/data/TMVARegression_BDTG_PFRes.root" ), - PFEGammaCandidates = cms.InputTag( "particleFlowEGamma" ), - sumPtTrackIsoSlopeForPhoton = cms.double( -1.0 ), - coneTrackIsoForEgammaSC = cms.double( 0.3 ), - minDeltaMet = cms.double( 0.4 ), - pt_Error = cms.double( 1.0 ), - useProtectionsForJetMET = cms.bool( True ), - metFactorForRejection = cms.double( 4.0 ), - sumPtTrackIsoForEgammaSC_endcap = cms.double( 4.0 ), - calibHF_use = cms.bool( False ), - verbose = cms.untracked.bool( False ), - usePFConversions = cms.bool( False ), - trackQuality = cms.string( "highPurity" ), - calibPFSCEle_endcap = cms.vdouble( 1.153, -16.5975, 5.668, -0.1772, 16.22, 7.326, 0.0483, -4.068, 9.406 ), - metFactorForCleaning = cms.double( 4.0 ), - eventFactorForCosmics = cms.double( 10.0 ), - egammaElectrons = cms.InputTag( "" ), - minEnergyForPunchThrough = cms.double( 100.0 ), - minTrackerHits = cms.int32( 8 ), - iCfgCandConnector = cms.PSet( - bCalibSecondary = cms.bool( False ), - bCalibPrimary = cms.bool( False ), - bCorrect = cms.bool( False ), - nuclCalibFactors = cms.vdouble( 0.8, 0.15, 0.5, 0.5, 0.05 ) + skipTSG = cms.PSet( ), + ComponentName = cms.string( "DualByL2TSG" ) ), - rejectTracks_Bad = cms.bool( False ), - pf_electronID_crackCorrection = cms.bool( False ), - pf_locC_mvaWeightFile = cms.string( "RecoParticleFlow/PFProducer/data/TMVARegression_BDTG_PFClusterCorr.root" ), - calibHF_a_EMonly = cms.vdouble( 0.96945, 0.96701, 0.76309, 0.82268, 0.87583, 0.89718, 0.98674, 1.4681, 1.458, 1.458 ), - muons = cms.InputTag( "hltMuons" ), - metFactorForHighEta = cms.double( 25.0 ), - minHFCleaningPt = cms.double( 5.0 ), - muon_HCAL = cms.vdouble( 3.0, 3.0 ), - pf_electron_mvaCut = cms.double( -0.1 ), - ptFactorForHighEta = cms.double( 2.0 ), - maxDeltaPhiPt = cms.double( 7.0 ), - pf_electronID_mvaWeightFile = cms.string( "RecoParticleFlow/PFProducer/data/MVAnalysis_BDT.weights_PfElectrons23Jan_IntToFloat.txt" ), - sumEtEcalIsoForEgammaSC_endcap = cms.double( 2.0 ), - calibHF_b_EMHAD = cms.vdouble( 1.27541, 0.85361, 0.86333, 0.89091, 0.94348, 0.94348, 0.9437, 1.0034, 1.0444, 1.0444 ), - pf_GlobC_mvaWeightFile = cms.string( "RecoParticleFlow/PFProducer/data/TMVARegression_BDTG_PFGlobalCorr.root" ), - photon_HoE = cms.double( 0.1 ), - sumEtEcalIsoForEgammaSC_barrel = cms.double( 1.0 ), - calibPFSCEle_Fbrem_endcap = cms.vdouble( 0.9, 6.5, -0.0692932, 0.101776, 0.995338, -0.00236548, 0.874998, 1.653, -0.0750184, 0.147, 0.923165, 4.74665E-4, 1.10782 ), - punchThroughFactor = cms.double( 3.0 ), - algoType = cms.uint32( 0 ), - electron_iso_combIso_barrel = cms.double( 10.0 ), - postMuonCleaning = cms.bool( True ), - calibPFSCEle_barrel = cms.vdouble( 1.004, -1.536, 22.88, -1.467, 0.3555, 0.6227, 14.65, 2051.0, 25.0, 0.9932, -0.5444, 0.0, 0.5438, 0.7109, 7.645, 0.2904, 0.0 ), - electron_protectionsForJetMET = cms.PSet( - maxE = cms.double( 50.0 ), - maxTrackPOverEele = cms.double( 1.0 ), - maxEcalEOverP_2 = cms.double( 0.2 ), - maxHcalEOverEcalE = cms.double( 0.1 ), - maxEcalEOverP_1 = cms.double( 0.5 ), - maxHcalEOverP = cms.double( 1.0 ), - maxEcalEOverPRes = cms.double( 0.2 ), - maxHcalE = cms.double( 10.0 ), - maxEeleOverPout = cms.double( 0.2 ), - maxNtracks = cms.double( 3.0 ), - maxEleHcalEOverEcalE = cms.double( 0.1 ), - maxDPhiIN = cms.double( 0.1 ), - maxEeleOverPoutRes = cms.double( 0.5 ) + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'PropagatorWithMaterial', + 'hltESPSmartPropagatorAnyOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) ), - electron_iso_pt = cms.double( 10.0 ), - isolatedElectronID_mvaWeightFile = cms.string( "RecoEgamma/ElectronIdentification/data/TMVA_BDTSimpleCat_17Feb2011.weights.xml" ), - vertexCollection = cms.InputTag( "hltPixelVertices" ), - X0_Map = cms.string( "RecoParticleFlow/PFProducer/data/allX0histos.root" ), - calibPFSCEle_Fbrem_barrel = cms.vdouble( 0.6, 6.0, -0.0255975, 0.0576727, 0.975442, -5.46394E-4, 1.26147, 25.0, -0.02025, 0.04537, 0.9728, -8.962E-4, 1.172 ), - blocks = cms.InputTag( "hltParticleFlowBlock" ), - punchThroughMETFactor = cms.double( 4.0 ), - metSignificanceForRejection = cms.double( 4.0 ), - photon_protectionsForJetMET = cms.PSet( - sumPtTrackIsoSlope = cms.double( 0.001 ), - sumPtTrackIso = cms.double( 2.0 ) + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( ), + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( + cleanerFromSharedHits = cms.bool( True ), + ptCleaner = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + directionCleaner = cms.bool( True ) ), - usePhotonReg = cms.bool( False ), - dzPV = cms.double( 0.2 ), - calibHF_a_EMHAD = cms.vdouble( 1.42215, 1.00496, 0.68961, 0.81656, 0.98504, 0.98504, 1.00802, 1.0593, 1.4576, 1.4576 ), - useRegressionFromDB = cms.bool( False ), - muon_ECAL = cms.vdouble( 0.5, 0.5 ), - usePFSCEleCalib = cms.bool( True ) -) -hltAK4PFJets = cms.EDProducer( "FastjetJetProducer", - Active_Area_Repeats = cms.int32( 5 ), - doAreaFastjet = cms.bool( False ), - voronoiRfact = cms.double( -9.0 ), - maxBadHcalCells = cms.uint32( 9999999 ), - doAreaDiskApprox = cms.bool( True ), - maxRecoveredEcalCells = cms.uint32( 9999999 ), - jetType = cms.string( "PFJet" ), - minSeed = cms.uint32( 0 ), - Ghost_EtaMax = cms.double( 6.0 ), - doRhoFastjet = cms.bool( False ), - jetAlgorithm = cms.string( "AntiKt" ), - nSigmaPU = cms.double( 1.0 ), - GhostArea = cms.double( 0.01 ), - Rho_EtaMax = cms.double( 4.4 ), - maxBadEcalCells = cms.uint32( 9999999 ), - useDeterministicSeed = cms.bool( True ), - doPVCorrection = cms.bool( False ), - maxRecoveredHcalCells = cms.uint32( 9999999 ), - rParam = cms.double( 0.4 ), - maxProblematicHcalCells = cms.uint32( 9999999 ), - doOutputJets = cms.bool( True ), - src = cms.InputTag( "hltParticleFlow" ), - inputEtMin = cms.double( 0.0 ), - puPtMin = cms.double( 10.0 ), - srcPVs = cms.InputTag( "hltPixelVertices" ), - jetPtMin = cms.double( 0.0 ), - radiusPU = cms.double( 0.4 ), - maxProblematicEcalCells = cms.uint32( 9999999 ), - doPUOffsetCorr = cms.bool( False ), - inputEMin = cms.double( 0.0 ), - useMassDropTagger = cms.bool( False ), - muMin = cms.double( -1.0 ), - subtractorName = cms.string( "" ), - muCut = cms.double( -1.0 ), - subjetPtMin = cms.double( -1.0 ), - useTrimming = cms.bool( False ), - muMax = cms.double( -1.0 ), - yMin = cms.double( -1.0 ), - useFiltering = cms.bool( False ), - rFilt = cms.double( -1.0 ), - yMax = cms.double( -1.0 ), - zcut = cms.double( -1.0 ), - MinVtxNdof = cms.int32( 0 ), - MaxVtxZ = cms.double( 15.0 ), - UseOnlyVertexTracks = cms.bool( False ), - dRMin = cms.double( -1.0 ), - nFilt = cms.int32( -1 ), - usePruning = cms.bool( False ), - maxDepth = cms.int32( -1 ), - yCut = cms.double( -1.0 ), - DzTrVtxMax = cms.double( 0.0 ), - UseOnlyOnePV = cms.bool( False ), - rcut_factor = cms.double( -1.0 ), - sumRecHits = cms.bool( False ), - trimPtFracMin = cms.double( -1.0 ), - dRMax = cms.double( -1.0 ), - DxyTrVtxMax = cms.double( 0.0 ), - useCMSBoostedTauSeedingAlgorithm = cms.bool( False ) -) -hltFixedGridRhoFastjetAll = cms.EDProducer( "FixedGridRhoProducerFastjet", - gridSpacing = cms.double( 0.55 ), - maxRapidity = cms.double( 5.0 ), - pfCandidatesTag = cms.InputTag( "hltParticleFlow" ) -) -hltAK4PFJetsCorrected = cms.EDProducer( "PFJetCorrectionProducer", - src = cms.InputTag( "hltAK4PFJets" ), - correctors = cms.vstring( 'hltESPAK4PFCorrection' ) -) -hltPFJetsCorrectedMatchedToCaloJets210 = cms.EDProducer( "PFJetsMatchedToFilteredCaloJetsProducer", - DeltaR = cms.double( 0.5 ), - CaloJetFilter = cms.InputTag( "hltSingleCaloJet210" ), - TriggerType = cms.int32( 85 ), - PFJetSrc = cms.InputTag( "hltAK4PFJetsCorrected" ) -) -hltSinglePFJet260 = cms.EDFilter( "HLT1PFJet", - saveTags = cms.bool( True ), - MinPt = cms.double( 260.0 ), - MinN = cms.int32( 1 ), - MaxEta = cms.double( 5.0 ), - MinMass = cms.double( -1.0 ), - inputTag = cms.InputTag( "hltPFJetsCorrectedMatchedToCaloJets210" ), - MinE = cms.double( -1.0 ), - triggerType = cms.int32( 85 ) -) -hltL1sL1SingleEG10 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleEG10" ), - saveTags = cms.bool( True ), - L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), - L1UseL1TriggerObjectMaps = cms.bool( True ), - L1UseAliasesForSeeding = cms.bool( True ), - L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), - L1CollectionsTag = cms.InputTag( "hltL1extraParticles" ), - L1NrBxInEvent = cms.int32( 3 ), - L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), - L1TechTriggerSeeding = cms.bool( False ) -) -hltPrePhoton20CaloIdVLIsoL = cms.EDFilter( "HLTPrescaler", - L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), - offset = cms.uint32( 0 ) + PtCut = cms.double( 1.0 ) ) -hltEGL1SingleEG12Filter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", - doIsolated = cms.bool( False ), - endcap_end = cms.double( 2.65 ), - saveTags = cms.bool( False ), - region_eta_size_ecap = cms.double( 1.0 ), - barrel_end = cms.double( 1.4791 ), - l1IsolatedTag = cms.InputTag( 'hltL1extraParticles','Isolated' ), - candIsolatedTag = cms.InputTag( "hltEgammaCandidates" ), - region_phi_size = cms.double( 1.044 ), - region_eta_size = cms.double( 0.522 ), - L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleEG10" ), - candNonIsolatedTag = cms.InputTag( "" ), - l1NonIsolatedTag = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), - ncandcut = cms.int32( 1 ) -) -hltEG20EtFilter = cms.EDFilter( "HLTEgammaEtFilter", - saveTags = cms.bool( False ), - L1NonIsoCand = cms.InputTag( "" ), - relaxed = cms.untracked.bool( False ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - inputTag = cms.InputTag( "hltEGL1SingleEG12Filter" ), - etcutEB = cms.double( 20.0 ), - etcutEE = cms.double( 20.0 ), - ncandcut = cms.int32( 1 ) -) -hltEG20CaloIdVLClusterShapeFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( 0.04 ), - thrOverEEE = cms.double( -1.0 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( -1.0 ), - thrRegularEB = cms.double( 0.024 ), - lessThan = cms.bool( True ), - useEt = cms.bool( False ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( 'hltEgammaClusterShape','sigmaIEtaIEta5x5' ), - candTag = cms.InputTag( "hltEG20EtFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -hltEG20CaloIdVLHEFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( -1.0 ), - thrOverEEE = cms.double( 0.1 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.15 ), - thrRegularEB = cms.double( -1.0 ), - lessThan = cms.bool( True ), - useEt = cms.bool( False ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaHoverE" ), - candTag = cms.InputTag( "hltEG20CaloIdVLClusterShapeFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -hltEG20CaloIdVLIsoLEcalIsoFilter = cms.EDFilter( "HLTEgammaGenericQuadraticFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( 0.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( 0.0 ), - thrRegularEE = cms.double( 5.5 ), - thrOverEEE = cms.double( 0.012 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.012 ), - thrRegularEB = cms.double( 5.5 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaEcalPFClusterIso" ), - candTag = cms.InputTag( "hltEG20CaloIdVLHEFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -hltEG20CaloIdVLIsoLHcalIsoFilter = cms.EDFilter( "HLTEgammaGenericQuadraticFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( 0.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( 0.0 ), - thrRegularEE = cms.double( 3.5 ), - thrOverEEE = cms.double( 0.005 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.005 ), - thrRegularEB = cms.double( 3.5 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaHcalPFClusterIso" ), - candTag = cms.InputTag( "hltEG20CaloIdVLHEFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -hltPixelVerticesForPhotons = cms.EDProducer( "PixelVertexProducer", - WtAverage = cms.bool( True ), - Method2 = cms.bool( True ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - PVcomparer = cms.PSet( refToPSet_ = cms.string( "HLTPSetPvClusterComparer" ) ), - Verbosity = cms.int32( 0 ), - UseError = cms.bool( True ), - TrackCollection = cms.InputTag( "hltPixelTracks" ), - PtMin = cms.double( 1.0 ), - NTrkMin = cms.int32( 2 ), - ZOffset = cms.double( 5.0 ), - Finder = cms.string( "DivisiveVertexFinder" ), - ZSeparation = cms.double( 0.05 ) -) -hltIter0PFlowPixelSeedsFromPixelTracksForPhotons = cms.EDProducer( "SeedGeneratorFromProtoTracksEDProducer", - useEventsWithNoVertex = cms.bool( True ), - originHalfLength = cms.double( 0.3 ), - useProtoTrackKinematics = cms.bool( False ), - usePV = cms.bool( True ), - InputVertexCollection = cms.InputTag( "hltPixelVerticesForPhotons" ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - InputCollection = cms.InputTag( "hltPixelTracks" ), - originRadius = cms.double( 0.1 ) -) -hltIter0PFlowCkfTrackCandidatesForPhotons = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter0PFlowPixelSeedsFromPixelTracksForPhotons" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), +hltHIL3TrackCandidateFromL2OIHit = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedOIHit" ), + reverseTrajectories = cms.bool( True ), TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) ), TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), cleanTrajectoryAfterInOut = cms.bool( False ), useHitsSplitting = cms.bool( False ), RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter0PSetTrajectoryBuilderIT" ) ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) ) -hltIter0PFlowCtfWithMaterialTracksForPhotons = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter0PFlowCkfTrackCandidatesForPhotons" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), +hltHIL3TkTracksFromL2OIHit = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2OIHit" ), + SimpleMagneticField = cms.string( "" ), clusterRemovalInfo = cms.InputTag( "" ), beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), useHitsSplitting = cms.bool( False ), MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), NavigationSchool = cms.string( "" ), TrajectoryInEvent = cms.bool( True ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -hltIter0PFlowTrackSelectionHighPurityForPhotons = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.4, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.35, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter0PFlowCtfWithMaterialTracksForPhotons" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesForPhotons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.4, 4.0 ), - d0_par1 = cms.vdouble( 0.3, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -hltIter1ClustersRefRemovalForPhotons = cms.EDProducer( "TrackClusterRemover", - minNumberOfLayersWithMeasBeforeFiltering = cms.int32( 0 ), - maxChi2 = cms.double( 9.0 ), - trajectories = cms.InputTag( "hltIter0PFlowTrackSelectionHighPurityForPhotons" ), - oldClusterRemovalInfo = cms.InputTag( "" ), - stripClusters = cms.InputTag( "hltSiStripRawToClustersFacility" ), - overrideTrkQuals = cms.InputTag( "" ), - pixelClusters = cms.InputTag( "hltSiPixelClusters" ), - TrackQuality = cms.string( "highPurity" ) -) -hltIter1MaskedMeasurementTrackerEventForPhotons = cms.EDProducer( "MaskedMeasurementTrackerEventProducer", - clustersToSkip = cms.InputTag( "hltIter1ClustersRefRemovalForPhotons" ), - OnDemand = cms.bool( False ), - src = cms.InputTag( "hltSiStripClusters" ) -) -hltIter1PixelLayerTripletsForPhotons = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2+BPix3', - 'BPix1+BPix2+FPix1_pos', - 'BPix1+BPix2+FPix1_neg', - 'BPix1+FPix1_pos+FPix2_pos', - 'BPix1+FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter1ClustersRefRemovalForPhotons" ), - hitErrorRPhi = cms.double( 0.0051 ) + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +hltHIL3MuonsOIHit = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) + ), + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + ), + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) + ), + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) + ), + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2OIHit" ), + tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter1ClustersRefRemovalForPhotons" ), - hitErrorRPhi = cms.double( 0.0027 ) + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) + ), + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) ), - TIB = cms.PSet( ) -) -hltIter1PFlowPixelSeedsForPhotons = cms.EDProducer( "SeedGeneratorFromRegionHitsEDProducer", - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "CandidateSeededTrackingRegionsProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.05 ), - ptMin = cms.double( 0.5 ), - input = cms.InputTag( "hltEgammaCandidates" ), - maxNRegions = cms.int32( 10 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - vertexCollection = cms.InputTag( "hltPixelVerticesForPhotons" ), - zErrorBeamSpot = cms.double( 24.2 ), - deltaEta = cms.double( 0.5 ), - deltaPhi = cms.double( 0.5 ), - nSigmaZVertex = cms.double( 3.0 ), - nSigmaZBeamSpot = cms.double( 4.0 ), - mode = cms.string( "VerticesFixed" ), - maxNVertices = cms.int32( 3 ), - zErrorVetex = cms.double( 0.2 ) - ) + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) +) +hltHIL3TkFromL2OICombination = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit' ) +) +hltHIL3TrajSeedIOHit = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + PSetNames = cms.vstring( 'skipTSG', + 'skipTSG' ), + L3TkCollectionA = cms.InputTag( "hltHIL3TkFromL2OICombination" ), + iterativeTSG = cms.PSet( + firstTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + ComponentName = cms.string( "StandardHitTripletGenerator" ), + GeneratorPSet = cms.PSet( + useBending = cms.bool( True ), + useFixedPreFiltering = cms.bool( False ), + maxElement = cms.uint32( 0 ), + phiPreFiltering = cms.double( 0.3 ), + extraHitRPhitolerance = cms.double( 0.06 ), + useMultScattering = cms.bool( True ), + ComponentName = cms.string( "PixelTripletHLTGenerator" ), + extraHitRZtolerance = cms.double( 0.06 ), + SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) + ), + SeedingLayers = cms.InputTag( "hltPixelLayerTriplets" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ), + PSetNames = cms.vstring( 'firstTSG', + 'secondTSG' ), + ComponentName = cms.string( "CombinedTSG" ), + thirdTSG = cms.PSet( + PSetNames = cms.vstring( 'endcapTSG', + 'barrelTSG' ), + barrelTSG = cms.PSet( ), + endcapTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + maxElement = cms.uint32( 0 ), + ComponentName = cms.string( "StandardHitPairGenerator" ), + useOnDemandTracker = cms.untracked.int32( 0 ), + SeedingLayers = cms.InputTag( "hltMixedLayerPairs" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ), + etaSeparation = cms.double( 2.0 ), + ComponentName = cms.string( "DualByEtaTSG" ) + ), + secondTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + maxElement = cms.uint32( 0 ), + ComponentName = cms.string( "StandardHitPairGenerator" ), + useOnDemandTracker = cms.untracked.int32( 0 ), + SeedingLayers = cms.InputTag( "hltPixelLayerPairs" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ) + ), + skipTSG = cms.PSet( ), + ComponentName = cms.string( "DualByL2TSG" ) ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ), - ClusterCheckPSet = cms.PSet( - PixelClusterCollectionLabel = cms.InputTag( "hltSiPixelClusters" ), - MaxNumberOfCosmicClusters = cms.uint32( 50000 ), - doClusterCheck = cms.bool( False ), - ClusterCollectionLabel = cms.InputTag( "hltSiStripClusters" ), - MaxNumberOfPixelClusters = cms.uint32( 10000 ) + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'PropagatorWithMaterial' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitTripletGenerator" ), - GeneratorPSet = cms.PSet( - useBending = cms.bool( True ), - useFixedPreFiltering = cms.bool( False ), - maxElement = cms.uint32( 100000 ), - phiPreFiltering = cms.double( 0.3 ), - extraHitRPhitolerance = cms.double( 0.032 ), - useMultScattering = cms.bool( True ), - ComponentName = cms.string( "PixelTripletHLTGenerator" ), - extraHitRZtolerance = cms.double( 0.037 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) - ), - SeedingLayers = cms.InputTag( "hltIter1PixelLayerTripletsForPhotons" ) + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.1 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.1 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) ), - SeedCreatorPSet = cms.PSet( - ComponentName = cms.string( "SeedFromConsecutiveHitsTripletOnlyCreator" ), - propagator = cms.string( "PropagatorWithMaterialParabolicMf" ), - SeedMomentumForBOFF = cms.double( 5.0 ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( + cleanerFromSharedHits = cms.bool( True ), + ptCleaner = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + directionCleaner = cms.bool( True ) ), - TTRHBuilder = cms.string( "(unused)" ) + PtCut = cms.double( 1.0 ) ) -hltIter1PFlowCkfTrackCandidatesForPhotons = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter1PFlowPixelSeedsForPhotons" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), +hltHIL3TrackCandidateFromL2IOHit = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedIOHit" ), + reverseTrajectories = cms.bool( False ), TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) ), TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter1MaskedMeasurementTrackerEventForPhotons" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), cleanTrajectoryAfterInOut = cms.bool( False ), useHitsSplitting = cms.bool( False ), RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter1PSetTrajectoryBuilderIT" ) ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) ) -hltIter1PFlowCtfWithMaterialTracksForPhotons = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter1PFlowCkfTrackCandidatesForPhotons" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), +hltHIL3TkTracksFromL2IOHit = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2IOHit" ), + SimpleMagneticField = cms.string( "" ), clusterRemovalInfo = cms.InputTag( "" ), beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter1MaskedMeasurementTrackerEventForPhotons" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), useHitsSplitting = cms.bool( False ), MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), NavigationSchool = cms.string( "" ), TrajectoryInEvent = cms.bool( True ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -hltIter1PFlowTrackSelectionHighPurityLooseForPhotons = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.9, 3.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.8, 3.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter1PFlowCtfWithMaterialTracksForPhotons" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesForPhotons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.9, 3.0 ), - d0_par1 = cms.vdouble( 0.85, 3.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -hltIter1PFlowTrackSelectionHighPurityTightForPhotons = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 5 ), - chi2n_par = cms.double( 0.4 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 1.0, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 1.0, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter1PFlowCtfWithMaterialTracksForPhotons" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesForPhotons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 1.0, 4.0 ), - d0_par1 = cms.vdouble( 1.0, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -hltIter1PFlowTrackSelectionHighPurityForPhotons = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter1PFlowTrackSelectionHighPurityLooseForPhotons','hltIter1PFlowTrackSelectionHighPurityTightForPhotons' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter1PFlowTrackSelectionHighPurityLooseForPhotons','hltIter1PFlowTrackSelectionHighPurityTightForPhotons' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -hltIter1MergedForPhotons = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter0PFlowTrackSelectionHighPurityForPhotons','hltIter1PFlowTrackSelectionHighPurityForPhotons' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter0PFlowTrackSelectionHighPurityForPhotons','hltIter1PFlowTrackSelectionHighPurityForPhotons' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -hltIter2ClustersRefRemovalForPhotons = cms.EDProducer( "TrackClusterRemover", - minNumberOfLayersWithMeasBeforeFiltering = cms.int32( 0 ), - maxChi2 = cms.double( 16.0 ), - trajectories = cms.InputTag( "hltIter1PFlowTrackSelectionHighPurityForPhotons" ), - oldClusterRemovalInfo = cms.InputTag( "hltIter1ClustersRefRemovalForPhotons" ), - stripClusters = cms.InputTag( "hltSiStripRawToClustersFacility" ), - overrideTrkQuals = cms.InputTag( "" ), - pixelClusters = cms.InputTag( "hltSiPixelClusters" ), - TrackQuality = cms.string( "highPurity" ) -) -hltIter2MaskedMeasurementTrackerEventForPhotons = cms.EDProducer( "MaskedMeasurementTrackerEventProducer", - clustersToSkip = cms.InputTag( "hltIter2ClustersRefRemovalForPhotons" ), - OnDemand = cms.bool( False ), - src = cms.InputTag( "hltSiStripClusters" ) -) -hltIter2PixelLayerPairsForPhotons = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2', - 'BPix1+BPix3', - 'BPix2+BPix3', - 'BPix1+FPix1_pos', - 'BPix1+FPix1_neg', - 'BPix1+FPix2_pos', - 'BPix1+FPix2_neg', - 'BPix2+FPix1_pos', - 'BPix2+FPix1_neg', - 'BPix2+FPix2_pos', - 'BPix2+FPix2_neg', - 'FPix1_pos+FPix2_pos', - 'FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter2ClustersRefRemovalForPhotons" ), - hitErrorRPhi = cms.double( 0.0051 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter2ClustersRefRemovalForPhotons" ), - hitErrorRPhi = cms.double( 0.0027 ) - ), - TIB = cms.PSet( ) -) -hltIter2PFlowPixelSeedsForPhotons = cms.EDProducer( "SeedGeneratorFromRegionHitsEDProducer", - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "CandidateSeededTrackingRegionsProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.05 ), - ptMin = cms.double( 1.2 ), - deltaEta = cms.double( 0.5 ), - deltaPhi = cms.double( 0.5 ), - vertexCollection = cms.InputTag( "hltPixelVerticesForPhotons" ), - input = cms.InputTag( "hltEgammaCandidates" ), - mode = cms.string( "VerticesFixed" ), - maxNRegions = cms.int32( 10 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - maxNVertices = cms.int32( 3 ), - zErrorBeamSpot = cms.double( 24.2 ), - nSigmaZVertex = cms.double( 3.0 ), - nSigmaZBeamSpot = cms.double( 4.0 ), - zErrorVetex = cms.double( 0.2 ) - ) - ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ), - ClusterCheckPSet = cms.PSet( - PixelClusterCollectionLabel = cms.InputTag( "hltSiPixelClusters" ), - MaxNumberOfCosmicClusters = cms.uint32( 50000 ), - doClusterCheck = cms.bool( False ), - ClusterCollectionLabel = cms.InputTag( "hltSiStripClusters" ), - MaxNumberOfPixelClusters = cms.uint32( 10000 ) + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +hltHIAllL3MuonsIOHit = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitPairGenerator" ), - GeneratorPSet = cms.PSet( - maxElement = cms.uint32( 100000 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) + ), + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + ), + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) + ), + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) ), - SeedingLayers = cms.InputTag( "hltIter2PixelLayerPairsForPhotons" ) + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2IOHit" ), + tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) ), - SeedCreatorPSet = cms.PSet( - ComponentName = cms.string( "SeedFromConsecutiveHitsCreator" ), - propagator = cms.string( "PropagatorWithMaterialParabolicMf" ), - SeedMomentumForBOFF = cms.double( 5.0 ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) + ), + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) ), - TTRHBuilder = cms.string( "(unused)" ) + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) ) -hltIter2PFlowCkfTrackCandidatesForPhotons = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter2PFlowPixelSeedsForPhotons" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter2MaskedMeasurementTrackerEventForPhotons" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter2PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) +hltHIL3TrajectorySeed = cms.EDProducer( "L3MuonTrajectorySeedCombiner", + labels = cms.VInputTag( 'hltHIL3TrajSeedIOHit','hltHIL3TrajSeedOIState','hltHIL3TrajSeedOIHit' ) ) -hltIter2PFlowCtfWithMaterialTracksForPhotons = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter2PFlowCkfTrackCandidatesForPhotons" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter2MaskedMeasurementTrackerEventForPhotons" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -hltIter2PFlowTrackSelectionHighPurityForPhotons = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.4, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.35, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter2PFlowCtfWithMaterialTracksForPhotons" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesForPhotons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.4, 4.0 ), - d0_par1 = cms.vdouble( 0.3, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -hltIter2MergedForPhotons = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter1MergedForPhotons','hltIter2PFlowTrackSelectionHighPurityForPhotons' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter1MergedForPhotons','hltIter2PFlowTrackSelectionHighPurityForPhotons' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -hltEgammaHollowTrackIso = cms.EDProducer( "EgammaHLTPhotonTrackIsolationProducersRegional", - egTrkIsoStripEndcap = cms.double( 0.03 ), - egTrkIsoConeSize = cms.double( 0.29 ), - trackProducer = cms.InputTag( "hltIter2MergedForPhotons" ), - egTrkIsoStripBarrel = cms.double( 0.03 ), - countTracks = cms.bool( False ), - egTrkIsoRSpan = cms.double( 999999.0 ), - egTrkIsoVetoConeSize = cms.double( 0.06 ), - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - egTrkIsoPtMin = cms.double( 1.0 ), - egTrkIsoZSpan = cms.double( 999999.0 ) -) -hltEG20CaloIdVLIsoLTrackIsoFilter = cms.EDFilter( "HLTEgammaGenericQuadraticFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( 0.0 ), - L1NonIsoCand = cms.InputTag( "" ), +hltHIL3TrackCandidateFromL2 = cms.EDProducer( "L3TrackCandCombiner", + labels = cms.VInputTag( 'hltHIL3TrackCandidateFromL2IOHit','hltHIL3TrackCandidateFromL2OIHit','hltHIL3TrackCandidateFromL2OIState' ) +) +hltHIL3TkTracksFromL2 = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3TkTracksFromL2IOHit','hltHIL3TkTracksFromL2OIHit','hltHIL3TkTracksFromL2OIState' ) +) +hltHIL3MuonsLinksCombination = cms.EDProducer( "L3TrackLinksCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit','hltHIAllL3MuonsIOHit' ) +) +hltHIL3Muons = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit','hltHIAllL3MuonsIOHit' ) +) +hltHIL3MuonCandidates = cms.EDProducer( "L3MuonCandidateProducer", + InputLinksObjects = cms.InputTag( "hltHIL3MuonsLinksCombination" ), + InputObjects = cms.InputTag( "hltHIL3Muons" ), + MuonPtOption = cms.string( "Global" ) +) +hltHISingleMu3L3Filtered = cms.EDFilter( "HLTMuonL3PreFilter", + MaxNormalizedChi2 = cms.double( 20.0 ), + saveTags = cms.bool( True ), + PreviousCandTag = cms.InputTag( "hltHIL2Mu3L2Filtered" ), + MinNmuonHits = cms.int32( 0 ), + MinN = cms.int32( 1 ), + MinTrackPt = cms.double( 0.0 ), + MaxEta = cms.double( 2.5 ), + MaxDXYBeamSpot = cms.double( 0.1 ), + MinNhits = cms.int32( 0 ), + MinDxySig = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MaxDz = cms.double( 9999.0 ), + MaxPtDifference = cms.double( 9999.0 ), + MaxDr = cms.double( 2.0 ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + MinDXYBeamSpot = cms.double( -1.0 ), + MinDr = cms.double( -1.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinPt = cms.double( 3.0 ) +) +hltPreHIL3DoubleMuOpen = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIDimuonL2PreFiltered0 = cms.EDFilter( "HLTMuonL2PreFilter", saveTags = cms.bool( True ), - thrOverE2EB = cms.double( 0.0 ), - thrRegularEE = cms.double( 3.5 ), - thrOverEEE = cms.double( 0.002 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.002 ), - thrRegularEB = cms.double( 3.5 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaHollowTrackIso" ), - candTag = cms.InputTag( "hltEG20CaloIdVLIsoLHcalIsoFilter" ), - nonIsoTag = cms.InputTag( "" ) + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) ) -hltPrePhysics = cms.EDFilter( "HLTPrescaler", +hltHIDimuonL3FilterOpen = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( 0 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +hltPreHIL3DoubleMuOpenSS = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIDimuonL3FilterOpenSS = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( 1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +hltPreHIL3DoubleMuOpenOS = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +hltHIDimuonL3FilterOpenOS = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( -1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +hltPreHIL3DoubleMuOpenOSNoCowboy = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) +hltHIDimuonL3FilterOpenOSNoCowboy = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( -1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( True ), + MinInvMass = cms.vdouble( 0.0 ) +) hltFEDSelector = cms.EDProducer( "EvFFEDSelector", inputTag = cms.InputTag( "rawDataCollector" ), fedList = cms.vuint32( 1023 ) @@ -7934,71 +3370,36 @@ HLTL1UnpackerSequence = cms.Sequence( hltGtDigis + hltGctDigis + hltL1GtObjectMap + hltL1extraParticles ) HLTBeamSpot = cms.Sequence( hltScalersRawToDigi + hltOnlineBeamSpot ) HLTBeginSequence = cms.Sequence( hltTriggerType + HLTL1UnpackerSequence + HLTBeamSpot ) -HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence = cms.Sequence( hltEcalDigis + hltEcalUncalibRecHit + hltEcalDetIdToBeRecovered + hltEcalRecHit ) -HLTDoLocalHcalSequence = cms.Sequence( hltHcalDigis + hltHbhereco + hltHfreco + hltHoreco ) -HLTDoCaloSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence + HLTDoLocalHcalSequence + hltTowerMakerForAll ) -HLTAK4CaloJetsReconstructionSequence = cms.Sequence( HLTDoCaloSequence + hltAK4CaloJets + hltAK4CaloJetsIDPassed ) -HLTAK4CaloJetsCorrectionSequence = cms.Sequence( hltFixedGridRhoFastjetAllCalo + hltAK4CaloJetsCorrected + hltAK4CaloJetsCorrectedIDPassed ) -HLTAK4CaloJetsSequence = cms.Sequence( HLTAK4CaloJetsReconstructionSequence + HLTAK4CaloJetsCorrectionSequence ) HLTEndSequence = cms.Sequence( hltBoolEnd ) -HLTDoFullUnpackingEgammaEcalSequence = cms.Sequence( hltEcalDigis + hltEcalPreshowerDigis + hltEcalUncalibRecHit + hltEcalDetIdToBeRecovered + hltEcalRecHit + hltEcalPreshowerRecHit ) -HLTPFClusteringForEgamma = cms.Sequence( hltRechitInRegionsECAL + hltRechitInRegionsES + hltParticleFlowRecHitECALL1Seeded + hltParticleFlowRecHitPSL1Seeded + hltParticleFlowClusterPSL1Seeded + hltParticleFlowClusterECALUncorrectedL1Seeded + hltParticleFlowClusterECALL1Seeded + hltParticleFlowSuperClusterECALL1Seeded ) -HLTDoLocalHcalWithTowerSequence = cms.Sequence( hltHcalDigis + hltHbhereco + hltHfreco + hltHoreco + hltTowerMakerForAll ) -HLTFastJetForEgamma = cms.Sequence( hltFixedGridRhoFastjetAllCaloForMuons ) -HLTPFHcalClusteringForEgamma = cms.Sequence( hltRegionalTowerForEgamma + hltParticleFlowRecHitHCALForEgamma + hltParticleFlowClusterHCALForEgamma ) -HLTDoLocalPixelSequence = cms.Sequence( hltSiPixelDigis + hltSiPixelClusters + hltSiPixelClustersCache + hltSiPixelRecHits ) -HLTDoLocalStripSequence = cms.Sequence( hltSiStripExcludedFEDListProducer + hltSiStripRawToClustersFacility + hltSiStripClusters ) -HLTGsfElectronSequence = cms.Sequence( hltEgammaCkfTrackCandidatesForGSF + hltEgammaGsfTracks + hltEgammaGsfElectrons + hltEgammaGsfTrackVars ) -HLTRecoPixelVertexingForElectronSequence = cms.Sequence( hltPixelLayerTriplets + hltPixelTracksElectrons + hltPixelVerticesElectrons ) -HLTPixelTrackingForElectron = cms.Sequence( hltElectronsVertex + HLTDoLocalPixelSequence + HLTRecoPixelVertexingForElectronSequence ) -HLTIterativeTrackingForElectronsIteration0 = cms.Sequence( hltIter0ElectronsPixelSeedsFromPixelTracks + hltIter0ElectronsCkfTrackCandidates + hltIter0ElectronsCtfWithMaterialTracks + hltIter0ElectronsTrackSelectionHighPurity ) -HLTIterativeTrackingForElectronsIteration1 = cms.Sequence( hltIter1ElectronsClustersRefRemoval + hltIter1ElectronsMaskedMeasurementTrackerEvent + hltIter1ElectronsPixelLayerTriplets + hltIter1ElectronsPixelSeeds + hltIter1ElectronsCkfTrackCandidates + hltIter1ElectronsCtfWithMaterialTracks + hltIter1ElectronsTrackSelectionHighPurityLoose + hltIter1ElectronsTrackSelectionHighPurityTight + hltIter1ElectronsTrackSelectionHighPurity ) -HLTIterativeTrackingForElectronsIteration2 = cms.Sequence( hltIter2ElectronsClustersRefRemoval + hltIter2ElectronsMaskedMeasurementTrackerEvent + hltIter2ElectronsPixelLayerPairs + hltIter2ElectronsPixelSeeds + hltIter2ElectronsCkfTrackCandidates + hltIter2ElectronsCtfWithMaterialTracks + hltIter2ElectronsTrackSelectionHighPurity ) -HLTIterativeTrackingForElectronIter02 = cms.Sequence( HLTIterativeTrackingForElectronsIteration0 + HLTIterativeTrackingForElectronsIteration1 + hltIter1MergedForElectrons + HLTIterativeTrackingForElectronsIteration2 + hltIter2MergedForElectrons ) -HLTTrackReconstructionForIsoElectronIter02 = cms.Sequence( HLTPixelTrackingForElectron + HLTDoLocalStripSequence + HLTIterativeTrackingForElectronIter02 ) -HLTEle27erWP75GsfSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleIsoEG22erFilter + hltEG27EtL1IsoEG22erFilter + hltEgammaClusterShape + hltEle27WP75ClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEle27WP75HcEFilter + hltEgammaEcalPFClusterIso + hltEle27WP75EcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltEle27WP75HcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltMixedLayerPairs + hltEgammaElectronPixelSeeds + hltEle27WP75PixelMatchFilter + HLTGsfElectronSequence + hltEle27WP75GsfOneOEMinusOneOPFilter + hltEle27WP75GsfChi2Filter + hltEle27WP75GsfDetaFilter + hltEle27WP75GsfDphiFilter + HLTTrackReconstructionForIsoElectronIter02 + hltEgammaEleGsfTrackIso + hltEle27WP75GsfTrackIsoFilter ) HLTMuonLocalRecoSequence = cms.Sequence( hltMuonDTDigis + hltDt1DRecHits + hltDt4DSegments + hltMuonCSCDigis + hltCsc2DRecHits + hltCscSegments + hltMuonRPCDigis + hltRpcRecHits ) HLTL2muonrecoNocandSequence = cms.Sequence( HLTMuonLocalRecoSequence + hltL2OfflineMuonSeeds + hltL2MuonSeeds + hltL2Muons ) HLTL2muonrecoSequence = cms.Sequence( HLTL2muonrecoNocandSequence + hltL2MuonCandidates ) -HLTL3muonTkCandidateSequence = cms.Sequence( HLTDoLocalPixelSequence + HLTDoLocalStripSequence + hltL3TrajSeedOIState + hltL3TrackCandidateFromL2OIState + hltL3TkTracksFromL2OIState + hltL3MuonsOIState + hltL3TrajSeedOIHit + hltL3TrackCandidateFromL2OIHit + hltL3TkTracksFromL2OIHit + hltL3MuonsOIHit + hltL3TkFromL2OICombination + hltPixelLayerTriplets + hltPixelLayerPairs + hltMixedLayerPairs + hltL3TrajSeedIOHit + hltL3TrackCandidateFromL2IOHit + hltL3TkTracksFromL2IOHit + hltL3MuonsIOHit + hltL3TrajectorySeed + hltL3TrackCandidateFromL2 ) -HLTL3muonrecoNocandSequence = cms.Sequence( HLTL3muonTkCandidateSequence + hltL3TkTracksMergeStep1 + hltL3TkTracksFromL2 + hltL3MuonsLinksCombination + hltL3Muons ) -HLTL3muonrecoSequence = cms.Sequence( HLTL3muonrecoNocandSequence + hltL3MuonCandidates ) -HLTDoCaloSequencePF = cms.Sequence( HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence + HLTDoLocalHcalSequence + hltTowerMakerForPF ) -HLTAK4CaloJetsPrePFRecoSequence = cms.Sequence( HLTDoCaloSequencePF + hltAK4CaloJetsPF ) -HLTPreAK4PFJetsRecoSequence = cms.Sequence( HLTAK4CaloJetsPrePFRecoSequence + hltAK4CaloJetsPFEt5 ) -HLTRecopixelvertexingSequence = cms.Sequence( hltPixelLayerTriplets + hltPixelTracks + hltPixelVertices + hltTrimmedPixelVertices ) -HLTIterativeTrackingIteration0 = cms.Sequence( hltIter0PFLowPixelSeedsFromPixelTracks + hltIter0PFlowCkfTrackCandidates + hltIter0PFlowCtfWithMaterialTracks + hltIter0PFlowTrackSelectionHighPurity ) -HLTIter0TrackAndTauJet4Iter1Sequence = cms.Sequence( hltTrackIter0RefsForJets4Iter1 + hltAK4Iter0TrackJets4Iter1 + hltIter0TrackAndTauJets4Iter1 ) -HLTIterativeTrackingIteration1 = cms.Sequence( hltIter1ClustersRefRemoval + hltIter1MaskedMeasurementTrackerEvent + hltIter1PixelLayerTriplets + hltIter1PFlowPixelSeeds + hltIter1PFlowCkfTrackCandidates + hltIter1PFlowCtfWithMaterialTracks + hltIter1PFlowTrackSelectionHighPurityLoose + hltIter1PFlowTrackSelectionHighPurityTight + hltIter1PFlowTrackSelectionHighPurity ) -HLTIter1TrackAndTauJets4Iter2Sequence = cms.Sequence( hltIter1TrackRefsForJets4Iter2 + hltAK4Iter1TrackJets4Iter2 + hltIter1TrackAndTauJets4Iter2 ) -HLTIterativeTrackingIteration2 = cms.Sequence( hltIter2ClustersRefRemoval + hltIter2MaskedMeasurementTrackerEvent + hltIter2PixelLayerPairs + hltIter2PFlowPixelSeeds + hltIter2PFlowCkfTrackCandidates + hltIter2PFlowCtfWithMaterialTracks + hltIter2PFlowTrackSelectionHighPurity ) -HLTIterativeTrackingIter02 = cms.Sequence( HLTIterativeTrackingIteration0 + HLTIter0TrackAndTauJet4Iter1Sequence + HLTIterativeTrackingIteration1 + hltIter1Merged + HLTIter1TrackAndTauJets4Iter2Sequence + HLTIterativeTrackingIteration2 + hltIter2Merged ) -HLTTrackReconstructionForPF = cms.Sequence( HLTDoLocalPixelSequence + HLTRecopixelvertexingSequence + HLTDoLocalStripSequence + HLTIterativeTrackingIter02 + hltPFMuonMerging + hltMuonLinks + hltMuons ) -HLTPreshowerSequence = cms.Sequence( hltEcalPreshowerDigis + hltEcalPreshowerRecHit ) -HLTParticleFlowSequence = cms.Sequence( HLTPreshowerSequence + hltParticleFlowRecHitECALUnseeded + hltParticleFlowRecHitHCAL + hltParticleFlowRecHitPSUnseeded + hltParticleFlowClusterECALUncorrectedUnseeded + hltParticleFlowClusterPSUnseeded + hltParticleFlowClusterECALUnseeded + hltParticleFlowClusterHCAL + hltParticleFlowClusterHFEM + hltParticleFlowClusterHFHAD + hltLightPFTracks + hltParticleFlowBlock + hltParticleFlow ) -HLTAK4PFJetsReconstructionSequence = cms.Sequence( HLTL2muonrecoSequence + HLTL3muonrecoSequence + HLTTrackReconstructionForPF + HLTParticleFlowSequence + hltAK4PFJets ) -HLTAK4PFJetsCorrectionSequence = cms.Sequence( hltFixedGridRhoFastjetAll + hltAK4PFJetsCorrected ) -HLTAK4PFJetsSequence = cms.Sequence( HLTPreAK4PFJetsRecoSequence + HLTAK4PFJetsReconstructionSequence + HLTAK4PFJetsCorrectionSequence ) -HLTRecoPixelVertexingForPhotonsSequence = cms.Sequence( hltPixelLayerTriplets + hltPixelTracks + hltPixelVerticesForPhotons ) -HLTIterativeTrackingForPhotonsIteration0 = cms.Sequence( hltIter0PFlowPixelSeedsFromPixelTracksForPhotons + hltIter0PFlowCkfTrackCandidatesForPhotons + hltIter0PFlowCtfWithMaterialTracksForPhotons + hltIter0PFlowTrackSelectionHighPurityForPhotons ) -HLTIterativeTrackingForPhotonsIteration1 = cms.Sequence( hltIter1ClustersRefRemovalForPhotons + hltIter1MaskedMeasurementTrackerEventForPhotons + hltIter1PixelLayerTripletsForPhotons + hltIter1PFlowPixelSeedsForPhotons + hltIter1PFlowCkfTrackCandidatesForPhotons + hltIter1PFlowCtfWithMaterialTracksForPhotons + hltIter1PFlowTrackSelectionHighPurityLooseForPhotons + hltIter1PFlowTrackSelectionHighPurityTightForPhotons + hltIter1PFlowTrackSelectionHighPurityForPhotons ) -HLTIterativeTrackingForPhotonsIteration2 = cms.Sequence( hltIter2ClustersRefRemovalForPhotons + hltIter2MaskedMeasurementTrackerEventForPhotons + hltIter2PixelLayerPairsForPhotons + hltIter2PFlowPixelSeedsForPhotons + hltIter2PFlowCkfTrackCandidatesForPhotons + hltIter2PFlowCtfWithMaterialTracksForPhotons + hltIter2PFlowTrackSelectionHighPurityForPhotons ) -HLTIterativeTrackingForPhotonsIter02 = cms.Sequence( HLTIterativeTrackingForPhotonsIteration0 + HLTIterativeTrackingForPhotonsIteration1 + hltIter1MergedForPhotons + HLTIterativeTrackingForPhotonsIteration2 + hltIter2MergedForPhotons ) -HLTTrackReconstructionForIsoForPhotons = cms.Sequence( HLTDoLocalPixelSequence + HLTRecoPixelVertexingForPhotonsSequence + HLTDoLocalStripSequence + HLTIterativeTrackingForPhotonsIter02 ) -HLTPhoton20CaloIdVLIsoLSequence = cms.Sequence( HLTDoFullUnpackingEgammaEcalSequence + HLTPFClusteringForEgamma + hltEgammaCandidates + hltEGL1SingleEG12Filter + hltEG20EtFilter + hltEgammaClusterShape + hltEG20CaloIdVLClusterShapeFilter + HLTDoLocalHcalWithTowerSequence + HLTFastJetForEgamma + hltEgammaHoverE + hltEG20CaloIdVLHEFilter + hltEgammaEcalPFClusterIso + hltEG20CaloIdVLIsoLEcalIsoFilter + HLTPFHcalClusteringForEgamma + hltEgammaHcalPFClusterIso + hltEG20CaloIdVLIsoLHcalIsoFilter + HLTDoLocalPixelSequence + HLTDoLocalStripSequence + HLTTrackReconstructionForIsoForPhotons + hltEgammaHollowTrackIso + hltEG20CaloIdVLIsoLTrackIsoFilter ) +HLTDoHILocalPixelSequence = cms.Sequence( hltSiPixelDigis + hltHISiPixelClusters + hltHISiPixelClustersCache + hltHISiPixelRecHits ) +HLTDoHILocalStripSequence = cms.Sequence( hltSiStripExcludedFEDListProducer + hltSiStripRawToClustersFacility + hltHISiStripClusters ) +HLTHIL3muonTkCandidateSequence = cms.Sequence( HLTDoHILocalPixelSequence + HLTDoHILocalStripSequence + hltHIL3TrajSeedOIState + hltHIL3TrackCandidateFromL2OIState + hltHIL3TkTracksFromL2OIState + hltHIL3MuonsOIState + hltHIL3TrajSeedOIHit + hltHIL3TrackCandidateFromL2OIHit + hltHIL3TkTracksFromL2OIHit + hltHIL3MuonsOIHit + hltHIL3TkFromL2OICombination + hltHIL3TrajSeedIOHit + hltHIL3TrackCandidateFromL2IOHit + hltHIL3TkTracksFromL2IOHit + hltHIAllL3MuonsIOHit + hltHIL3TrajectorySeed + hltHIL3TrackCandidateFromL2 ) +HLTHIL3muonrecoNocandSequence = cms.Sequence( HLTHIL3muonTkCandidateSequence + hltHIL3TkTracksFromL2 + hltHIL3MuonsLinksCombination + hltHIL3Muons ) +HLTHIL3muonrecoSequence = cms.Sequence( HLTHIL3muonrecoNocandSequence + hltHIL3MuonCandidates ) HLTriggerFirstPath = cms.Path( hltGetConditions + hltGetRaw + hltBoolFalse ) -HLT_CaloJet260_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleJet200 + hltPreCaloJet260 + HLTAK4CaloJetsSequence + hltSingleCaloJet260 + HLTEndSequence ) -HLT_Ele27_eta2p1_WP75_Gsf_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleIsoEG22er + hltPreEle27eta2p1WP75Gsf + HLTEle27erWP75GsfSequence + HLTEndSequence ) -HLT_Mu50_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleMu16ORSingleMu25 + hltPreMu50 + hltL1fL1sMu16orMu25L1Filtered0 + HLTL2muonrecoSequence + hltL2fL1sMu16orMu25L1f0L2Filtered16Q + HLTL3muonrecoSequence + hltL3fL1sMu16orMu25L1f0L2f16QL3Filtered50Q + HLTEndSequence ) -HLT_PFJet260_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleJet200 + hltPrePFJet260 + HLTAK4CaloJetsSequence + hltSingleCaloJet210 + HLTAK4PFJetsSequence + hltPFJetsCorrectedMatchedToCaloJets210 + hltSinglePFJet260 + HLTEndSequence ) -HLT_Photon20_CaloIdVL_IsoL_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleEG10 + hltPrePhoton20CaloIdVLIsoL + HLTPhoton20CaloIdVLIsoLSequence + HLTEndSequence ) HLT_Physics_v1 = cms.Path( HLTBeginSequence + hltPrePhysics + HLTEndSequence ) +HLT_HIL1DoubleMu0_HighQ_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL1DoubleMu0HighQ + hltL1fL1DoubleMu0HQL1Filtered0 + HLTEndSequence ) +HLT_HIL2Mu3_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleMu3BptxAND + hltPreHIL2Mu3 + hltHIL1SingleMu3Filtered + HLTL2muonrecoSequence + hltHIL2Mu3L2Filtered + HLTEndSequence ) +HLT_HIL2Mu7_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleMu3BptxAND + hltPreHIL2Mu7 + hltHIL1SingleMu3Filtered + HLTL2muonrecoSequence + hltHIL2Mu7L2Filtered + HLTEndSequence ) +HLT_HIL2Mu15_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleMu3BptxAND + hltPreHIL2Mu15 + hltHIL1SingleMu3Filtered + HLTL2muonrecoSequence + hltHIL2Mu15L2Filtered + HLTEndSequence ) +HLT_HIL2Mu3_NHitQ_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleMu3BptxAND + hltPreHIL2Mu3NHitQ + hltHIL1SingleMu3Filtered + HLTL2muonrecoSequence + hltHIL2Mu3N1HitQL2Filtered + HLTEndSequence ) +HLT_HIL2DoubleMu0_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL2DoubleMu0 + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIL2DoubleMu0L2Filtered + HLTEndSequence ) +HLT_HIL2DoubleMu0_NHitQ_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL2DoubleMu0NHitQ + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIL2DoubleMu0L2N1HitsFiltered + HLTEndSequence ) +HLT_HIL2DoubleMu3_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL2DoubleMu3 + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIL2DoubleMu3L2Filtered + HLTEndSequence ) +HLT_HIL3Mu3_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleMu3BptxAND + hltPreHIL3Mu3 + hltHIL1SingleMu3Filtered + HLTL2muonrecoSequence + hltHIL2Mu3L2Filtered + HLTHIL3muonrecoSequence + hltHISingleMu3L3Filtered + HLTEndSequence ) +HLT_HIL3DoubleMuOpen_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL3DoubleMuOpen + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIDimuonL2PreFiltered0 + HLTHIL3muonrecoSequence + hltHIDimuonL3FilterOpen + HLTEndSequence ) +HLT_HIL3DoubleMuOpen_SS_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL3DoubleMuOpenSS + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIDimuonL2PreFiltered0 + HLTHIL3muonrecoSequence + hltHIDimuonL3FilterOpenSS + HLTEndSequence ) +HLT_HIL3DoubleMuOpen_OS_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL3DoubleMuOpenOS + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIDimuonL2PreFiltered0 + HLTHIL3muonrecoSequence + hltHIDimuonL3FilterOpenOS + HLTEndSequence ) +HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMuOpenBptxAND + hltPreHIL3DoubleMuOpenOSNoCowboy + hltHIDoubleMuLevel1PathL1OpenFiltered + HLTL2muonrecoSequence + hltHIDimuonL2PreFiltered0 + HLTHIL3muonrecoSequence + hltHIDimuonL3FilterOpenOSNoCowboy + HLTEndSequence ) HLTriggerFinalPath = cms.Path( hltGtDigis + hltScalersRawToDigi + hltFEDSelector + hltTriggerSummaryAOD + hltTriggerSummaryRAW ) HLTAnalyzerEndpath = cms.EndPath( hltL1GtTrigReport + hltTrigReport ) -HLTSchedule = cms.Schedule( *(HLTriggerFirstPath, HLT_CaloJet260_v1, HLT_Ele27_eta2p1_WP75_Gsf_v1, HLT_Mu50_v1, HLT_PFJet260_v1, HLT_Photon20_CaloIdVL_IsoL_v1, HLT_Physics_v1, HLTriggerFinalPath, HLTAnalyzerEndpath )) +HLTSchedule = cms.Schedule( *(HLTriggerFirstPath, HLT_Physics_v1, HLT_HIL1DoubleMu0_HighQ_v1, HLT_HIL2Mu3_v1, HLT_HIL2Mu7_v1, HLT_HIL2Mu15_v1, HLT_HIL2Mu3_NHitQ_v1, HLT_HIL2DoubleMu0_v1, HLT_HIL2DoubleMu0_NHitQ_v1, HLT_HIL2DoubleMu3_v1, HLT_HIL3Mu3_v1, HLT_HIL3DoubleMuOpen_v1, HLT_HIL3DoubleMuOpen_SS_v1, HLT_HIL3DoubleMuOpen_OS_v1, HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1, HLTriggerFinalPath, HLTAnalyzerEndpath )) diff --git a/HLTrigger/Configuration/python/HLT_PIon_cff.py b/HLTrigger/Configuration/python/HLT_PIon_cff.py index ad3f9b174636d..56ca02f1124e6 100644 --- a/HLTrigger/Configuration/python/HLT_PIon_cff.py +++ b/HLTrigger/Configuration/python/HLT_PIon_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_4_0/PIon/V4 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/PIon/V5 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/PIon/V4') + tableName = cms.string('/dev/CMSSW_7_4_0/PIon/V5') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( diff --git a/HLTrigger/Configuration/python/HLTrigger_Datasets_HIon_cff.py b/HLTrigger/Configuration/python/HLTrigger_Datasets_HIon_cff.py index 6b499037ce936..a1029111e316e 100644 --- a/HLTrigger/Configuration/python/HLTrigger_Datasets_HIon_cff.py +++ b/HLTrigger/Configuration/python/HLTrigger_Datasets_HIon_cff.py @@ -9,15 +9,23 @@ streamA_datasetInitialPD_selector.hltResults = cms.InputTag('TriggerResults', '', 'HLT') streamA_datasetInitialPD_selector.l1tResults = cms.InputTag('') streamA_datasetInitialPD_selector.throw = cms.bool(False) -streamA_datasetInitialPD_selector.triggerConditions = cms.vstring('HLT_Ele27_eta2p1_WP75_Gsf_v1', - 'HLT_Mu50_v1', - 'HLT_PFJet260_v1', - 'HLT_Physics_v1') +streamA_datasetInitialPD_selector.triggerConditions = cms.vstring('HLT_Physics_v1') -from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter as streamA_datasetTemplates_selector -streamA_datasetTemplates_selector.hltResults = cms.InputTag('TriggerResults', '', 'HLT') -streamA_datasetTemplates_selector.l1tResults = cms.InputTag('') -streamA_datasetTemplates_selector.throw = cms.bool(False) -streamA_datasetTemplates_selector.triggerConditions = cms.vstring('HLT_CaloJet260_v1', - 'HLT_Photon20_CaloIdVL_IsoL_v1') +from HLTrigger.HLTfilters.triggerResultsFilter_cfi import triggerResultsFilter as streamA_datasetInitialPDForHI_selector +streamA_datasetInitialPDForHI_selector.hltResults = cms.InputTag('TriggerResults', '', 'HLT') +streamA_datasetInitialPDForHI_selector.l1tResults = cms.InputTag('') +streamA_datasetInitialPDForHI_selector.throw = cms.bool(False) +streamA_datasetInitialPDForHI_selector.triggerConditions = cms.vstring('HLT_HIL1DoubleMu0_HighQ_v1', + 'HLT_HIL2DoubleMu0_NHitQ_v1', + 'HLT_HIL2DoubleMu0_v1', + 'HLT_HIL2DoubleMu3_v1', + 'HLT_HIL2Mu15_v1', + 'HLT_HIL2Mu3_NHitQ_v1', + 'HLT_HIL2Mu3_v1', + 'HLT_HIL2Mu7_v1', + 'HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1', + 'HLT_HIL3DoubleMuOpen_OS_v1', + 'HLT_HIL3DoubleMuOpen_SS_v1', + 'HLT_HIL3DoubleMuOpen_v1', + 'HLT_HIL3Mu3_v1') diff --git a/HLTrigger/Configuration/tables/HIon.txt b/HLTrigger/Configuration/tables/HIon.txt index 78fa0f070ae03..7471dcac4924f 100644 --- a/HLTrigger/Configuration/tables/HIon.txt +++ b/HLTrigger/Configuration/tables/HIon.txt @@ -1,10 +1,19 @@ -# "HIon" menu (placeholder) +# "HIon" menu + +HLT_HIL1DoubleMu0_HighQ_v* # CMSHLT-198 +HLT_HIL2Mu3_v* # CMSHLT-198 +HLT_HIL2Mu7_v* # CMSHLT-198 +HLT_HIL2Mu15_v* # CMSHLT-198 +HLT_HIL2Mu3_NHitQ_v* # CMSHLT-198 +HLT_HIL2DoubleMu0_v* # CMSHLT-198 +HLT_HIL2DoubleMu0_NHitQ_v* # CMSHLT-198 +HLT_HIL2DoubleMu3_v* # CMSHLT-198 +HLT_HIL3Mu3_v* # CMSHLT-198 +HLT_HIL3DoubleMuOpen_v* # CMSHLT-198 +HLT_HIL3DoubleMuOpen_SS_v* # CMSHLT-198 +HLT_HIL3DoubleMuOpen_OS_v* # CMSHLT-198 +HLT_HIL3DoubleMuOpen_OS_NoCowboy_v* # CMSHLT-198 -HLT_CaloJet260_v* -HLT_PFJet260_v* -HLT_Photon20_CaloIdVL_IsoL_v* -HLT_Ele27_eta2p1_WP75_Gsf_v* -HLT_Mu50_v* HLT_Physics_v* HLTriggerFirstPath diff --git a/HLTrigger/Configuration/test/OnData_HLT_50nsGRun.py b/HLTrigger/Configuration/test/OnData_HLT_50nsGRun.py index b0782430f67c1..fe2545b141c06 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_50nsGRun.py +++ b/HLTrigger/Configuration/test/OnData_HLT_50nsGRun.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/50nsGRun/V9 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/50nsGRun/V11 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLT50nsGRun" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V9') + tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V11') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -158,7 +158,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), MeasurementTrackerName = cms.string( "hltIter4ESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator16" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator16" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -173,7 +173,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), MeasurementTrackerName = cms.string( "hltIter3ESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator16" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator16" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -187,7 +187,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), MeasurementTrackerName = cms.string( "hltIter2ESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator16" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator16" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -201,7 +201,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), MeasurementTrackerName = cms.string( "hltIter1ESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator16" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator16" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -229,7 +229,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialOpposite" ), MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -259,7 +259,7 @@ useSeedLayer = cms.bool( True ), deltaEta = cms.double( -1.0 ), deltaPhi = cms.double( -1.0 ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), rescaleErrorIfFail = cms.double( 1.0 ), propagatorProximity = cms.string( "SteppingHelixPropagatorAny" ), updator = cms.string( "hltESPKFUpdator" ), @@ -278,7 +278,7 @@ useSeedLayer = cms.bool( False ), deltaEta = cms.double( -1.0 ), deltaPhi = cms.double( -1.0 ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), rescaleErrorIfFail = cms.double( 1.0 ), propagatorProximity = cms.string( "SteppingHelixPropagatorAny" ), updator = cms.string( "hltESPKFUpdator" ), @@ -300,7 +300,7 @@ maxCand = cms.int32( 2 ), ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator9" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator9" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -343,7 +343,7 @@ maxCand = cms.int32( 4 ), ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( True ), @@ -356,7 +356,7 @@ maxCand = cms.int32( 2 ), ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -16001,8 +16001,8 @@ reqOppCharge = cms.untracked.bool( False ), nZcandcut = cms.int32( 1 ) ) -process.hltL1sL1SingleIsoEG18 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG18" ), +process.hltL1sL1SingleIsoEG20er = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG20er" ), saveTags = cms.bool( True ), L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), L1UseL1TriggerObjectMaps = cms.bool( True ), @@ -16017,7 +16017,7 @@ L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) -process.hltEGL1SingleIsoEG18erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", +process.hltEGL1SingleIsoEG20erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", doIsolated = cms.bool( False ), endcap_end = cms.double( 2.17 ), saveTags = cms.bool( False ), @@ -16027,7 +16027,7 @@ candIsolatedTag = cms.InputTag( "hltEgammaCandidates" ), region_phi_size = cms.double( 1.044 ), region_eta_size = cms.double( 0.522 ), - L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG18" ), + L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG20er" ), candNonIsolatedTag = cms.InputTag( "" ), l1NonIsolatedTag = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), ncandcut = cms.int32( 1 ) @@ -16037,7 +16037,7 @@ L1NonIsoCand = cms.InputTag( "" ), relaxed = cms.untracked.bool( False ), L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - inputTag = cms.InputTag( "hltEGL1SingleIsoEG18erFilter" ), + inputTag = cms.InputTag( "hltEGL1SingleIsoEG20erFilter" ), etcutEB = cms.double( 22.0 ), etcutEE = cms.double( 22.0 ), ncandcut = cms.int32( 1 ) @@ -39660,7 +39660,7 @@ tanhSO10ForwardThres = cms.double( 1.0 ), L1IsoPixelSeedsTag = cms.InputTag( "hltEgammaElectronPixelSeedsUnseeded" ), L1NonIsoCand = cms.InputTag( "" ), - ncandcut = cms.int32( 1 ), + ncandcut = cms.int32( 2 ), tanhSO10BarrelThres = cms.double( 0.35 ), s_a_rF = cms.double( 0.04 ), L1NonIsoPixelSeedsTag = cms.InputTag( "" ), @@ -44211,7 +44211,7 @@ process.HLTTrackReconstructionIter02 = cms.Sequence( process.HLTPixelTrackingL3Muon + process.HLTDoLocalStripSequence + process.HLTIterativeTrackingL3MuonIter02 ) process.HLTDoublePho85Sequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleEG40ORL1SingleEG35Filter + process.hltEG85EtFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEG85HEFilter + process.HLTPFClusteringForEgammaUnseeded + process.hltEgammaCandidatesUnseeded + process.hltEgammaCandidatesWrapperUnseeded + process.hltDiEG85EtUnseededFilter + process.hltEgammaHoverEUnseeded + process.hltDiEG85HEUnseededFilter ) process.HLTEle20WP60Ele8Mass55Sequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleEG20Filter + process.hltEle20WP60Ele8EtFilter + process.hltEgammaClusterShape + process.hltEle20WP60Ele8ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEle20WP60Ele8HEFilter + process.hltEgammaEcalPFClusterIso + process.hltEle20WP60Ele8EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltEle20WP60Ele8HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltEle20WP60Ele8PixelMatchFilter + process.HLTGsfElectronSequence + process.hltEle20WP60Ele8OneOEMinusOneOPFilter + process.hltEle20WP60Ele8DetaFilter + process.hltEle20WP60Ele8DphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltEle20WP60Ele8TrackIsoFilter + process.HLTPFClusteringForEgammaUnseeded + process.hltEgammaCandidatesUnseeded + process.hltEgammaCandidatesWrapperUnseeded + process.hltEle20WP60Ele8EtUnseededFilter + process.HLTElePixelMatchUnseededSequence + process.hltEle20WP60Ele8PixelMatchUnseededFilter + process.hltEle20WP60Ele8Mass55Filter ) -process.HLTSingleEle22erWP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleIsoEG18erFilter + process.hltSingleEG22EtFilter + process.hltEgammaClusterShape + process.hltSingleEle22WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltSingleEle22WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltSingleEle22WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltSingleEle22WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltSingleEle22WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + process.hltSingleEle22WP75GsfChi2Filter + process.hltSingleEle22WP75GsfDetaFilter + process.hltSingleEle22WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltSingleEle22WP75GsfTrackIsoFilter ) +process.HLTSingleEle22erWP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleIsoEG20erFilter + process.hltSingleEG22EtFilter + process.hltEgammaClusterShape + process.hltSingleEle22WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltSingleEle22WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltSingleEle22WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltSingleEle22WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltSingleEle22WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + process.hltSingleEle22WP75GsfChi2Filter + process.hltSingleEle22WP75GsfDetaFilter + process.hltSingleEle22WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltSingleEle22WP75GsfTrackIsoFilter ) process.HLTEle22WP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGRegionalL1IsoEG20erTauJet20er + process.hltEG22L1sIsoEG20erTauJet20erEtFilter + process.hltEgammaClusterShape + process.hltEle22WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEle22WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltEle22WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltEle22WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltEle22WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltEle22WP75GsfOneOESuperMinusOneOPFilter + process.hltEle22WP75GsfChi2Filter + process.hltEle22WP75GsfDetaFilter + process.hltEle22WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltEle22WP75GsfTrackIsoFilter ) process.HLTParticleFlowSequenceForTaus = cms.Sequence( process.HLTPreshowerSequence + process.hltParticleFlowRecHitECALUnseeded + process.hltParticleFlowRecHitHCAL + process.hltParticleFlowRecHitPSUnseeded + process.hltParticleFlowClusterECALUncorrectedUnseeded + process.hltParticleFlowClusterPSUnseeded + process.hltParticleFlowClusterECALUnseeded + process.hltParticleFlowClusterHCAL + process.hltParticleFlowClusterHFEM + process.hltParticleFlowClusterHFHAD + process.hltLightPFTracks + process.hltParticleFlowBlockForTaus + process.hltParticleFlowForTaus ) process.HLTPFTriggerSequenceForTaus = cms.Sequence( process.HLTL2muonrecoSequence + process.HLTL3muonrecoSequence + process.HLTTrackReconstructionForPF + process.HLTParticleFlowSequenceForTaus + process.hltAK4PFJetsForTaus ) @@ -44440,7 +44440,7 @@ process.HLT_Dimuon6_Jpsi_NoVertexing_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMu0 + process.hltPreDimuon6JpsiNoVertexing + process.hltL1fL1DoubleMu0L1Filtered0 + process.HLTL2muonrecoSequence + process.hltL2fDoubleMu2L2PreFiltered2 + process.HLTL3muonrecoSequence + process.hltDimuon6JpsiL3Filtered + process.HLTEndSequence ) process.HLT_DoublePhoton85_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG40ORL1SingleEG35 + process.hltPreDoublePhoton85 + process.HLTDoublePho85Sequence + process.HLTEndSequence ) process.HLT_Ele20WP60_Ele8_Mass55_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG20 + process.hltPreEle20WP60Ele8Mass55 + process.HLTEle20WP60Ele8Mass55Sequence + process.HLTEndSequence ) -process.HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleIsoEG18 + process.hltPreEle22eta2p1WP75Gsf + process.HLTSingleEle22erWP75GsfSequence + process.HLTEndSequence ) +process.HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleIsoEG20er + process.hltPreEle22eta2p1WP75Gsf + process.HLTSingleEle22erWP75GsfSequence + process.HLTEndSequence ) process.HLT_Ele22_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1IsoEG20erTauJet20er + process.hltPreEle22eta2p1WP75GsfLooseIsoPFTau20 + process.HLTEle22WP75GsfSequence + process.HLTRecoJetSequenceAK4PrePF + process.hltTauJet5 + process.hltOverlapFilterIsoEle22WP75GsfCaloJet5 + process.HLTPFTriggerSequenceForTaus + process.HLTIsoEle22WP75GsfLooseIsoPFTau20Sequence + process.HLTEndSequence ) process.HLT_Ele25WP60_SC4_Mass55_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG20 + process.hltPreEle25WP60SC4Mass55 + process.HLTEle25WP60SC4Mass55Sequence + process.HLTEndSequence ) process.HLT_Ele25_eta2p1_WP85_Gsf_PFMET80_boostedW_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG40ORL1SingleIsoEG30erORL1ETM70 + process.hltPreEle25eta2p1WP85GsfPFMET80boostedW + process.HLTEle25WP85GsfSequence + process.HLTAK4PFJetsSequence + process.hltPFMETProducer + process.hltPFMET80Filter + process.HLTEndSequence ) diff --git a/HLTrigger/Configuration/test/OnData_HLT_FULL.py b/HLTrigger/Configuration/test/OnData_HLT_FULL.py index a30e721da6eaa..398371b399ca1 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_FULL.py +++ b/HLTrigger/Configuration/test/OnData_HLT_FULL.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/HLT/V6 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/HLT/V10 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTFULL" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V6') + tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V10') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -383,6 +383,7 @@ ) process.streams = cms.PSet( A = cms.vstring( 'InitialPD', + 'InitialPDForHI', 'Templates' ), ALCAP0 = cms.vstring( 'AlCaP0' ), ALCAPHISYM = cms.vstring( 'AlCaPhiSym' ), @@ -704,6 +705,19 @@ 'HLT_VBF_DisplacedJet40_TightID_DisplacedTrack_v1', 'HLT_VBF_DisplacedJet40_TightID_Hadronic_v1', 'HLT_ZeroBias_v1') ), + InitialPDForHI = cms.vstring( 'HLT_HIL1DoubleMu0_HighQ_v1', + 'HLT_HIL2DoubleMu0_NHitQ_v1', + 'HLT_HIL2DoubleMu0_v1', + 'HLT_HIL2DoubleMu3_v1', + 'HLT_HIL2Mu15_v1', + 'HLT_HIL2Mu3_NHitQ_v1', + 'HLT_HIL2Mu3_v1', + 'HLT_HIL2Mu7_v1', + 'HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1', + 'HLT_HIL3DoubleMuOpen_OS_v1', + 'HLT_HIL3DoubleMuOpen_SS_v1', + 'HLT_HIL3DoubleMuOpen_v1', + 'HLT_HIL3Mu3_v1' ), OfflineMonitor = cms.vstring( ), OfflineMonitorHI = cms.vstring( ), OnlineHltMonitor = cms.vstring( ), @@ -18232,8 +18246,8 @@ reqOppCharge = cms.untracked.bool( False ), nZcandcut = cms.int32( 1 ) ) -process.hltL1sL1SingleIsoEG18 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG18" ), +process.hltL1sL1SingleIsoEG20er = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG20er" ), saveTags = cms.bool( True ), L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), L1UseL1TriggerObjectMaps = cms.bool( True ), @@ -18248,7 +18262,7 @@ L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) -process.hltEGL1SingleIsoEG18erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", +process.hltEGL1SingleIsoEG20erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", doIsolated = cms.bool( False ), endcap_end = cms.double( 2.17 ), saveTags = cms.bool( False ), @@ -18258,7 +18272,7 @@ candIsolatedTag = cms.InputTag( "hltEgammaCandidates" ), region_phi_size = cms.double( 1.044 ), region_eta_size = cms.double( 0.522 ), - L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG18" ), + L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG20er" ), candNonIsolatedTag = cms.InputTag( "" ), l1NonIsolatedTag = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), ncandcut = cms.int32( 1 ) @@ -18268,7 +18282,7 @@ L1NonIsoCand = cms.InputTag( "" ), relaxed = cms.untracked.bool( False ), L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - inputTag = cms.InputTag( "hltEGL1SingleIsoEG18erFilter" ), + inputTag = cms.InputTag( "hltEGL1SingleIsoEG20erFilter" ), etcutEB = cms.double( 22.0 ), etcutEE = cms.double( 22.0 ), ncandcut = cms.int32( 1 ) @@ -41907,7 +41921,7 @@ tanhSO10ForwardThres = cms.double( 1.0 ), L1IsoPixelSeedsTag = cms.InputTag( "hltEgammaElectronPixelSeedsUnseeded" ), L1NonIsoCand = cms.InputTag( "" ), - ncandcut = cms.int32( 1 ), + ncandcut = cms.int32( 2 ), tanhSO10BarrelThres = cms.double( 0.35 ), s_a_rF = cms.double( 0.04 ), L1NonIsoPixelSeedsTag = cms.InputTag( "" ), @@ -45997,6 +46011,1214 @@ L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) +process.hltL1sL1DoubleMuOpenBptxAND = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_DoubleMuOpen_BptxAND" ), + saveTags = cms.bool( True ), + L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), + L1UseL1TriggerObjectMaps = cms.bool( True ), + L1UseAliasesForSeeding = cms.bool( True ), + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + L1CollectionsTag = cms.InputTag( "hltL1extraParticles" ), + L1NrBxInEvent = cms.int32( 3 ), + L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), + L1TechTriggerSeeding = cms.bool( False ) +) +process.hltPreHIL1DoubleMu0HighQ = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltL1fL1DoubleMu0HQL1Filtered0 = cms.EDFilter( "HLTMuonL1Filter", + saveTags = cms.bool( True ), + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1DoubleMuOpenBptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "hltL1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) +) +process.hltL1sL1SingleMu3BptxAND = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleMu3_BptxAND" ), + saveTags = cms.bool( True ), + L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), + L1UseL1TriggerObjectMaps = cms.bool( True ), + L1UseAliasesForSeeding = cms.bool( True ), + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + L1CollectionsTag = cms.InputTag( "hltL1extraParticles" ), + L1NrBxInEvent = cms.int32( 3 ), + L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), + L1TechTriggerSeeding = cms.bool( False ) +) +process.hltPreHIL2Mu3 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIL1SingleMu3Filtered = cms.EDFilter( "HLTMuonL1Filter", + saveTags = cms.bool( False ), + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1SingleMu3BptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 1 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "hltL1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) +) +process.hltHIL2Mu3L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2Mu7 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIL2Mu7L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 7.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2Mu15 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIL2Mu15L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 15.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2Mu3NHitQ = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIL2Mu3N1HitQL2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 1 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2DoubleMu0 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIDoubleMuLevel1PathL1OpenFiltered = cms.EDFilter( "HLTMuonL1Filter", + saveTags = cms.bool( True ), + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1DoubleMuOpenBptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "hltL1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) +) +process.hltHIL2DoubleMu0L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2DoubleMu0NHitQ = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIL2DoubleMu0L2N1HitsFiltered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 1 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2DoubleMu3 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIL2DoubleMu3L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL3Mu3 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHISiPixelClusters = cms.EDProducer( "SiPixelClusterProducer", + src = cms.InputTag( "hltSiPixelDigis" ), + ChannelThreshold = cms.int32( 1000 ), + maxNumberOfClusters = cms.int32( -1 ), + VCaltoElectronGain = cms.int32( 65 ), + MissCalibrate = cms.untracked.bool( True ), + SplitClusters = cms.bool( False ), + VCaltoElectronOffset = cms.int32( -414 ), + payloadType = cms.string( "HLT" ), + SeedThreshold = cms.int32( 1000 ), + ClusterThreshold = cms.double( 4000.0 ) +) +process.hltHISiPixelClustersCache = cms.EDProducer( "SiPixelClusterShapeCacheProducer", + src = cms.InputTag( "hltHISiPixelClusters" ), + onDemand = cms.bool( False ) +) +process.hltHISiPixelRecHits = cms.EDProducer( "SiPixelRecHitConverter", + VerboseLevel = cms.untracked.int32( 0 ), + src = cms.InputTag( "hltHISiPixelClusters" ), + CPE = cms.string( "hltESPPixelCPEGeneric" ) +) +process.hltHISiStripClusters = cms.EDProducer( "MeasurementTrackerEventProducer", + inactivePixelDetectorLabels = cms.VInputTag( ), + stripClusterProducer = cms.string( "hltSiStripRawToClustersFacility" ), + pixelClusterProducer = cms.string( "hltHISiPixelClusters" ), + switchOffPixelsIfEmpty = cms.bool( True ), + inactiveStripDetectorLabels = cms.VInputTag( 'hltSiStripExcludedFEDListProducer' ), + skipClusters = cms.InputTag( "" ), + measurementTracker = cms.string( "hltESPMeasurementTracker" ) +) +process.hltHIL3TrajSeedOIState = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + propagatorCompatibleName = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + option = cms.uint32( 3 ), + maxChi2 = cms.double( 40.0 ), + errorMatrixPset = cms.PSet( + atIP = cms.bool( True ), + action = cms.string( "use" ), + errorMatrixValuesPSet = cms.PSet( + pf3_V12 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V13 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V11 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V14 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V15 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), + pf3_V33 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + zAxis = cms.vdouble( -3.14159, 3.14159 ), + pf3_V44 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), + pf3_V22 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V23 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V45 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V55 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V34 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V35 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V25 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V24 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ) + ) + ), + propagatorName = cms.string( "hltESPSteppingHelixPropagatorAlong" ), + manySeeds = cms.bool( False ), + copyMuonRecHit = cms.bool( False ), + ComponentName = cms.string( "TSGForRoadSearch" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ) + ), + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSteppingHelixPropagatorOpposite', + 'hltESPSteppingHelixPropagatorAlong' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( ), + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( ), + PtCut = cms.double( 1.0 ) +) +process.hltHIL3TrackCandidateFromL2OIState = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedOIState" ), + reverseTrajectories = cms.bool( True ), + TransientInitialStateEstimatorParameters = cms.PSet( + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), + numberMeasurementsForFit = cms.int32( 4 ), + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) + ), + TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + cleanTrajectoryAfterInOut = cms.bool( False ), + useHitsSplitting = cms.bool( False ), + RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), + doSeedingRegionRebuilding = cms.bool( False ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilderSeedHit" ) ), + NavigationSchool = cms.string( "SimpleNavigationSchool" ), + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) +) +process.hltHIL3TkTracksFromL2OIState = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2OIState" ), + SimpleMagneticField = cms.string( "" ), + clusterRemovalInfo = cms.InputTag( "" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), + useHitsSplitting = cms.bool( False ), + MeasurementTracker = cms.string( "" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), + NavigationSchool = cms.string( "" ), + TrajectoryInEvent = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + GeometricInnerState = cms.bool( True ), + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +process.hltHIL3MuonsOIState = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) + ), + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + ), + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) + ), + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) + ), + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2OIState" ), + tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) + ), + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) + ), + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) +) +process.hltHIL3TrajSeedOIHit = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + PSetNames = cms.vstring( 'skipTSG', + 'iterativeTSG' ), + L3TkCollectionA = cms.InputTag( "hltHIL3MuonsOIState" ), + iterativeTSG = cms.PSet( + ErrorRescaling = cms.double( 3.0 ), + beamSpot = cms.InputTag( "unused" ), + MaxChi2 = cms.double( 40.0 ), + errorMatrixPset = cms.PSet( + atIP = cms.bool( True ), + action = cms.string( "use" ), + errorMatrixValuesPSet = cms.PSet( + pf3_V12 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V13 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V11 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V14 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V15 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), + pf3_V33 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + zAxis = cms.vdouble( -3.14159, 3.14159 ), + pf3_V44 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), + pf3_V22 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V23 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V45 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V55 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V34 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V35 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V25 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V24 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ) + ) + ), + UpdateState = cms.bool( True ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + SelectState = cms.bool( False ), + SigmaZ = cms.double( 25.0 ), + ResetMethod = cms.string( "matrix" ), + ComponentName = cms.string( "TSGFromPropagation" ), + UseVertexState = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAnyOpposite" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ) + ), + skipTSG = cms.PSet( ), + ComponentName = cms.string( "DualByL2TSG" ) + ), + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'PropagatorWithMaterial', + 'hltESPSmartPropagatorAnyOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( ), + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( + cleanerFromSharedHits = cms.bool( True ), + ptCleaner = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + directionCleaner = cms.bool( True ) + ), + PtCut = cms.double( 1.0 ) +) +process.hltHIL3TrackCandidateFromL2OIHit = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedOIHit" ), + reverseTrajectories = cms.bool( True ), + TransientInitialStateEstimatorParameters = cms.PSet( + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), + numberMeasurementsForFit = cms.int32( 4 ), + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) + ), + TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + cleanTrajectoryAfterInOut = cms.bool( False ), + useHitsSplitting = cms.bool( False ), + RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), + doSeedingRegionRebuilding = cms.bool( False ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), + NavigationSchool = cms.string( "SimpleNavigationSchool" ), + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) +) +process.hltHIL3TkTracksFromL2OIHit = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2OIHit" ), + SimpleMagneticField = cms.string( "" ), + clusterRemovalInfo = cms.InputTag( "" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), + useHitsSplitting = cms.bool( False ), + MeasurementTracker = cms.string( "" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), + NavigationSchool = cms.string( "" ), + TrajectoryInEvent = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + GeometricInnerState = cms.bool( True ), + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +process.hltHIL3MuonsOIHit = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) + ), + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + ), + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) + ), + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) + ), + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2OIHit" ), + tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) + ), + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) + ), + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) +) +process.hltHIL3TkFromL2OICombination = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit' ) +) +process.hltHIL3TrajSeedIOHit = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + PSetNames = cms.vstring( 'skipTSG', + 'skipTSG' ), + L3TkCollectionA = cms.InputTag( "hltHIL3TkFromL2OICombination" ), + iterativeTSG = cms.PSet( + firstTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + ComponentName = cms.string( "StandardHitTripletGenerator" ), + GeneratorPSet = cms.PSet( + useBending = cms.bool( True ), + useFixedPreFiltering = cms.bool( False ), + maxElement = cms.uint32( 0 ), + phiPreFiltering = cms.double( 0.3 ), + extraHitRPhitolerance = cms.double( 0.06 ), + useMultScattering = cms.bool( True ), + ComponentName = cms.string( "PixelTripletHLTGenerator" ), + extraHitRZtolerance = cms.double( 0.06 ), + SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) + ), + SeedingLayers = cms.InputTag( "hltPixelLayerTriplets" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ), + PSetNames = cms.vstring( 'firstTSG', + 'secondTSG' ), + ComponentName = cms.string( "CombinedTSG" ), + thirdTSG = cms.PSet( + PSetNames = cms.vstring( 'endcapTSG', + 'barrelTSG' ), + barrelTSG = cms.PSet( ), + endcapTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + maxElement = cms.uint32( 0 ), + ComponentName = cms.string( "StandardHitPairGenerator" ), + useOnDemandTracker = cms.untracked.int32( 0 ), + SeedingLayers = cms.InputTag( "hltMixedLayerPairs" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ), + etaSeparation = cms.double( 2.0 ), + ComponentName = cms.string( "DualByEtaTSG" ) + ), + secondTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + maxElement = cms.uint32( 0 ), + ComponentName = cms.string( "StandardHitPairGenerator" ), + useOnDemandTracker = cms.untracked.int32( 0 ), + SeedingLayers = cms.InputTag( "hltPixelLayerPairs" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ) + ), + skipTSG = cms.PSet( ), + ComponentName = cms.string( "DualByL2TSG" ) + ), + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'PropagatorWithMaterial' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.1 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.1 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + ), + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( + cleanerFromSharedHits = cms.bool( True ), + ptCleaner = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + directionCleaner = cms.bool( True ) + ), + PtCut = cms.double( 1.0 ) +) +process.hltHIL3TrackCandidateFromL2IOHit = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedIOHit" ), + reverseTrajectories = cms.bool( False ), + TransientInitialStateEstimatorParameters = cms.PSet( + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), + numberMeasurementsForFit = cms.int32( 4 ), + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) + ), + TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + cleanTrajectoryAfterInOut = cms.bool( False ), + useHitsSplitting = cms.bool( False ), + RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), + doSeedingRegionRebuilding = cms.bool( False ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), + NavigationSchool = cms.string( "SimpleNavigationSchool" ), + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) +) +process.hltHIL3TkTracksFromL2IOHit = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2IOHit" ), + SimpleMagneticField = cms.string( "" ), + clusterRemovalInfo = cms.InputTag( "" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), + useHitsSplitting = cms.bool( False ), + MeasurementTracker = cms.string( "" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), + NavigationSchool = cms.string( "" ), + TrajectoryInEvent = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + GeometricInnerState = cms.bool( True ), + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +process.hltHIAllL3MuonsIOHit = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) + ), + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + ), + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) + ), + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) + ), + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2IOHit" ), + tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) + ), + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) + ), + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) +) +process.hltHIL3TrajectorySeed = cms.EDProducer( "L3MuonTrajectorySeedCombiner", + labels = cms.VInputTag( 'hltHIL3TrajSeedIOHit','hltHIL3TrajSeedOIState','hltHIL3TrajSeedOIHit' ) +) +process.hltHIL3TrackCandidateFromL2 = cms.EDProducer( "L3TrackCandCombiner", + labels = cms.VInputTag( 'hltHIL3TrackCandidateFromL2IOHit','hltHIL3TrackCandidateFromL2OIHit','hltHIL3TrackCandidateFromL2OIState' ) +) +process.hltHIL3TkTracksFromL2 = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3TkTracksFromL2IOHit','hltHIL3TkTracksFromL2OIHit','hltHIL3TkTracksFromL2OIState' ) +) +process.hltHIL3MuonsLinksCombination = cms.EDProducer( "L3TrackLinksCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit','hltHIAllL3MuonsIOHit' ) +) +process.hltHIL3Muons = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit','hltHIAllL3MuonsIOHit' ) +) +process.hltHIL3MuonCandidates = cms.EDProducer( "L3MuonCandidateProducer", + InputLinksObjects = cms.InputTag( "hltHIL3MuonsLinksCombination" ), + InputObjects = cms.InputTag( "hltHIL3Muons" ), + MuonPtOption = cms.string( "Global" ) +) +process.hltHISingleMu3L3Filtered = cms.EDFilter( "HLTMuonL3PreFilter", + MaxNormalizedChi2 = cms.double( 20.0 ), + saveTags = cms.bool( True ), + PreviousCandTag = cms.InputTag( "hltHIL2Mu3L2Filtered" ), + MinNmuonHits = cms.int32( 0 ), + MinN = cms.int32( 1 ), + MinTrackPt = cms.double( 0.0 ), + MaxEta = cms.double( 2.5 ), + MaxDXYBeamSpot = cms.double( 0.1 ), + MinNhits = cms.int32( 0 ), + MinDxySig = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MaxDz = cms.double( 9999.0 ), + MaxPtDifference = cms.double( 9999.0 ), + MaxDr = cms.double( 2.0 ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + MinDXYBeamSpot = cms.double( -1.0 ), + MinDr = cms.double( -1.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinPt = cms.double( 3.0 ) +) +process.hltPreHIL3DoubleMuOpen = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIDimuonL2PreFiltered0 = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltHIDimuonL3FilterOpen = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( 0 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +process.hltPreHIL3DoubleMuOpenSS = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIDimuonL3FilterOpenSS = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( 1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +process.hltPreHIL3DoubleMuOpenOS = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIDimuonL3FilterOpenOS = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( -1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +process.hltPreHIL3DoubleMuOpenOSNoCowboy = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIDimuonL3FilterOpenOSNoCowboy = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( -1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( True ), + MinInvMass = cms.vdouble( 0.0 ) +) process.hltFEDSelector = cms.EDProducer( "EvFFEDSelector", inputTag = cms.InputTag( "rawDataCollector" ), fedList = cms.vuint32( 1023 ) @@ -46138,6 +47360,19 @@ 'HLT_Ele35_eta2p1_WP85_Gsf_v1', 'HLT_Ele40_eta2p1_WP85_Gsf_v1', 'HLT_Ele45_CaloIdVT_GsfTrkIdT_PFJet200_PFJet50_v1', + 'HLT_HIL1DoubleMu0_HighQ_v1', + 'HLT_HIL2DoubleMu0_NHitQ_v1', + 'HLT_HIL2DoubleMu0_v1', + 'HLT_HIL2DoubleMu3_v1', + 'HLT_HIL2Mu15_v1', + 'HLT_HIL2Mu3_NHitQ_v1', + 'HLT_HIL2Mu3_v1', + 'HLT_HIL2Mu7_v1', + 'HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1', + 'HLT_HIL3DoubleMuOpen_OS_v1', + 'HLT_HIL3DoubleMuOpen_SS_v1', + 'HLT_HIL3DoubleMuOpen_v1', + 'HLT_HIL3Mu3_v1', 'HLT_HT200_v1', 'HLT_HT250_v1', 'HLT_HT300_v1', @@ -46274,8 +47509,7 @@ 'HLT_PFJet400_v1', 'HLT_PFJet40_v1', 'HLT_PFJet450_v1', - 'HLT_PFJet500_v1', - 'HLT_PFJet60_v1', + 'HLT_PFJet500_v1')+cms.vstring( 'HLT_PFJet60_v1', 'HLT_PFJet80_v1', 'HLT_PFMET100_PFMHT100_IDLoose_v1', 'HLT_PFMET110_PFMHT110_IDLoose_v1', @@ -46287,7 +47521,8 @@ 'HLT_PFchMET90_NoiseCleaned_v1', 'HLT_Photon120_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1', 'HLT_Photon120_R9Id90_HE10_Iso40_EBOnly_VBF_v1', - 'HLT_Photon120_R9Id90_HE10_IsoM_v1')+cms.vstring( 'HLT_Photon120_v1', + 'HLT_Photon120_R9Id90_HE10_IsoM_v1', + 'HLT_Photon120_v1', 'HLT_Photon135_PFMET100_NoiseCleaned_v1', 'HLT_Photon165_HE10_v1', 'HLT_Photon165_R9Id90_HE10_IsoM_v1', @@ -46475,7 +47710,7 @@ process.HLTDoublePho85Sequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleEG40ORL1SingleEG35Filter + process.hltEG85EtFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEG85HEFilter + process.HLTPFClusteringForEgammaUnseeded + process.hltEgammaCandidatesUnseeded + process.hltEgammaCandidatesWrapperUnseeded + process.hltDiEG85EtUnseededFilter + process.hltEgammaHoverEUnseeded + process.hltDiEG85HEUnseededFilter ) process.HLTEle17Ele8GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1DoubleEG1510Filter + process.hltEle17Ele8EtLeg1Filter + process.hltEle17Ele8EtLeg2Filter + process.hltEgammaClusterShape + process.hltEle17Ele8ClusterShapeLeg1Filter + process.hltEle17Ele8ClusterShapeLeg2Filter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEle17Ele8HELeg1Filter + process.hltEle17Ele8HELeg2Filter + process.hltEgammaEcalPFClusterIso + process.hltEle17Ele8EcalIsoLeg1Filter + process.hltEle17Ele8EcalIsoLeg2Filter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltEle17Ele8HcalIsoLeg1Filter + process.hltEle17Ele8HcalIsoLeg2Filter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltEle17Ele8PixelMatchLeg1Filter + process.hltEle17Ele8PixelMatchLeg2Filter + process.HLTGsfElectronSequence + process.hltEle17Ele8GsfDetaLeg1Filter + process.hltEle17Ele8GsfDetaLeg2Filter + process.hltEle17Ele8GsfDphiLeg1Filter + process.hltEle17Ele8GsfDphiLeg2Filter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltEle17Ele8GsfTrackIsoLeg1Filter + process.hltEle17Ele8GsfTrackIsoLeg2Filter ) process.HLTEle20WP60Ele8Mass55Sequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleEG20Filter + process.hltEle20WP60Ele8EtFilter + process.hltEgammaClusterShape + process.hltEle20WP60Ele8ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEle20WP60Ele8HEFilter + process.hltEgammaEcalPFClusterIso + process.hltEle20WP60Ele8EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltEle20WP60Ele8HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltEle20WP60Ele8PixelMatchFilter + process.HLTGsfElectronSequence + process.hltEle20WP60Ele8OneOEMinusOneOPFilter + process.hltEle20WP60Ele8DetaFilter + process.hltEle20WP60Ele8DphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltEle20WP60Ele8TrackIsoFilter + process.HLTPFClusteringForEgammaUnseeded + process.hltEgammaCandidatesUnseeded + process.hltEgammaCandidatesWrapperUnseeded + process.hltEle20WP60Ele8EtUnseededFilter + process.HLTElePixelMatchUnseededSequence + process.hltEle20WP60Ele8PixelMatchUnseededFilter + process.hltEle20WP60Ele8Mass55Filter ) -process.HLTSingleEle22erWP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleIsoEG18erFilter + process.hltSingleEG22EtFilter + process.hltEgammaClusterShape + process.hltSingleEle22WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltSingleEle22WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltSingleEle22WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltSingleEle22WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltSingleEle22WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + process.hltSingleEle22WP75GsfChi2Filter + process.hltSingleEle22WP75GsfDetaFilter + process.hltSingleEle22WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltSingleEle22WP75GsfTrackIsoFilter ) +process.HLTSingleEle22erWP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleIsoEG20erFilter + process.hltSingleEG22EtFilter + process.hltEgammaClusterShape + process.hltSingleEle22WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltSingleEle22WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltSingleEle22WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltSingleEle22WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltSingleEle22WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + process.hltSingleEle22WP75GsfChi2Filter + process.hltSingleEle22WP75GsfDetaFilter + process.hltSingleEle22WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltSingleEle22WP75GsfTrackIsoFilter ) process.HLTEle22WP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGRegionalL1IsoEG20erTauJet20er + process.hltEG22L1sIsoEG20erTauJet20erEtFilter + process.hltEgammaClusterShape + process.hltEle22WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEle22WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltEle22WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltEle22WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltEle22WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltEle22WP75GsfOneOESuperMinusOneOPFilter + process.hltEle22WP75GsfChi2Filter + process.hltEle22WP75GsfDetaFilter + process.hltEle22WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltEle22WP75GsfTrackIsoFilter ) process.HLTLooseIsoPFTauSequence = cms.Sequence( process.hltTauPFJets08Region + process.hltTauPFJetsRecoTauChargedHadrons + process.hltPFTauPiZeros + process.hltPFTausSansRef + process.hltPFTaus + process.hltPFTauTrackFindingDiscriminator + process.hltPFTauLooseAbsoluteIsolationDiscriminator + process.hltPFTauLooseRelativeIsolationDiscriminator + process.hltPFTauLooseAbsOrRelIsolationDiscriminator ) process.HLTIsoEle22WP75GsfLooseIsoPFTau20Sequence = cms.Sequence( process.HLTLooseIsoPFTauSequence + process.hltPFTau20 + process.hltSelectedPFTausTrackFinding + process.hltPFTau20Track + process.hltSelectedPFTausTrackFindingLooseIsolation + process.hltPFTau20TrackLooseIso + process.hltOverlapFilterIsoEle22WP75GsfLooseIsoPFTau20 ) @@ -46665,6 +47900,11 @@ process.HLTMu15IsolationSequence = cms.Sequence( process.HLTL3muonEcalPFisorecoSequenceNoBoolsUnseeded + process.hltL3fL1sMu5L1f0L2f3QL3Filtered15QL3pfecalIsoRhoFilteredEB0p13EE0p10 + process.HLTL3muonHcalPFisorecoSequenceNoBoolsUnseeded + process.hltL3fL1sMu5L1f0L2f3QL3Filtered15QL3pfhcalIsoRhoFiltered0p23 + process.HLTTrackReconstructionForIsoL3MuonIter02 + process.hltMuonTkRelIsolationCut0p09Map ) process.HLTRecopixelvertexingForHighMultSequence = cms.Sequence( process.hltPixelLayerTriplets + process.hltPixelTracksForHighMult + process.hltPixelVerticesForHighMult ) process.HLTBeginSequenceRandom = cms.Sequence( process.hltRandomEventsFilter + process.hltGtDigis ) +process.HLTDoHILocalPixelSequence = cms.Sequence( process.hltSiPixelDigis + process.hltHISiPixelClusters + process.hltHISiPixelClustersCache + process.hltHISiPixelRecHits ) +process.HLTDoHILocalStripSequence = cms.Sequence( process.hltSiStripExcludedFEDListProducer + process.hltSiStripRawToClustersFacility + process.hltHISiStripClusters ) +process.HLTHIL3muonTkCandidateSequence = cms.Sequence( process.HLTDoHILocalPixelSequence + process.HLTDoHILocalStripSequence + process.hltHIL3TrajSeedOIState + process.hltHIL3TrackCandidateFromL2OIState + process.hltHIL3TkTracksFromL2OIState + process.hltHIL3MuonsOIState + process.hltHIL3TrajSeedOIHit + process.hltHIL3TrackCandidateFromL2OIHit + process.hltHIL3TkTracksFromL2OIHit + process.hltHIL3MuonsOIHit + process.hltHIL3TkFromL2OICombination + process.hltHIL3TrajSeedIOHit + process.hltHIL3TrackCandidateFromL2IOHit + process.hltHIL3TkTracksFromL2IOHit + process.hltHIAllL3MuonsIOHit + process.hltHIL3TrajectorySeed + process.hltHIL3TrackCandidateFromL2 ) +process.HLTHIL3muonrecoNocandSequence = cms.Sequence( process.HLTHIL3muonTkCandidateSequence + process.hltHIL3TkTracksFromL2 + process.hltHIL3MuonsLinksCombination + process.hltHIL3Muons ) +process.HLTHIL3muonrecoSequence = cms.Sequence( process.HLTHIL3muonrecoNocandSequence + process.hltHIL3MuonCandidates ) process.HLTriggerFirstPath = cms.Path( process.hltGetConditions + process.hltGetRaw + process.hltBoolFalse ) process.HLT_AK8PFJet360TrimMod_Mass30_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleJet176ORSingleJet200 + process.hltPreAK8PFJet360TrimModMass30 + process.HLTAK8CaloJetsSequence + process.hltAK8SingleCaloJet260 + process.HLTAK8PFJetsSequence + process.hltAK8PFJetsCorrectedMatchedToCaloJets260 + process.hltAK8TrimModJets + process.hltAK8SinglePFJet360TrimModMass30 + process.HLTEndSequence ) @@ -46703,7 +47943,7 @@ process.HLT_DoublePhoton85_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG40ORL1SingleEG35 + process.hltPreDoublePhoton85 + process.HLTDoublePho85Sequence + process.HLTEndSequence ) process.HLT_Ele17_Ele8_Gsf_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleEG1510 + process.hltPreEle17Ele8Gsf + process.HLTEle17Ele8GsfSequence + process.HLTEndSequence ) process.HLT_Ele20WP60_Ele8_Mass55_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG20 + process.hltPreEle20WP60Ele8Mass55 + process.HLTEle20WP60Ele8Mass55Sequence + process.HLTEndSequence ) -process.HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleIsoEG18 + process.hltPreEle22eta2p1WP75Gsf + process.HLTSingleEle22erWP75GsfSequence + process.HLTEndSequence ) +process.HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleIsoEG20er + process.hltPreEle22eta2p1WP75Gsf + process.HLTSingleEle22erWP75GsfSequence + process.HLTEndSequence ) process.HLT_Ele22_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1IsoEG20erTauJet20er + process.hltPreEle22eta2p1WP75GsfLooseIsoPFTau20 + process.HLTEle22WP75GsfSequence + process.HLTRecoJetSequenceAK4PrePF + process.hltTauJet5 + process.hltOverlapFilterIsoEle22WP75GsfCaloJet5 + process.HLTPFTriggerSequenceForTaus + process.HLTIsoEle22WP75GsfLooseIsoPFTau20Sequence + process.HLTEndSequence ) process.HLT_Ele25WP60_SC4_Mass55_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG20 + process.hltPreEle25WP60SC4Mass55 + process.HLTEle25WP60SC4Mass55Sequence + process.HLTEndSequence ) process.HLT_Ele25_eta2p1_WP85_Gsf_PFMET80_boostedW_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG40ORL1SingleIsoEG30erORL1ETM70 + process.hltPreEle25eta2p1WP85GsfPFMET80boostedW + process.HLTEle25WP85GsfSequence + process.HLTAK4PFJetsSequence + process.hltPFMETProducer + process.hltPFMET80Filter + process.HLTEndSequence ) @@ -46986,6 +48226,19 @@ process.HLT_ReducedIterativeTracking_v1 = cms.Path( process.HLTBeginSequence + process.hltPreReducedIterativeTracking + process.HLTRecoJetSequenceAK4PrePF + process.HLTDoLocalPixelSequence + process.HLTRecopixelvertexingSequence + process.HLTDoLocalStripSequence + process.HLTIterativeTrackingIter02 + process.HLTEndSequence ) process.HLT_Random_v1 = cms.Path( process.HLTBeginSequenceRandom + process.hltPreRandom + process.HLTEndSequence ) process.HLT_ZeroBias_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1ZeroBias + process.hltPreZeroBias + process.HLTEndSequence ) +process.HLT_HIL1DoubleMu0_HighQ_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL1DoubleMu0HighQ + process.hltL1fL1DoubleMu0HQL1Filtered0 + process.HLTEndSequence ) +process.HLT_HIL2Mu3_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL2Mu3 + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu3L2Filtered + process.HLTEndSequence ) +process.HLT_HIL2Mu7_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL2Mu7 + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu7L2Filtered + process.HLTEndSequence ) +process.HLT_HIL2Mu15_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL2Mu15 + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu15L2Filtered + process.HLTEndSequence ) +process.HLT_HIL2Mu3_NHitQ_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL2Mu3NHitQ + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu3N1HitQL2Filtered + process.HLTEndSequence ) +process.HLT_HIL2DoubleMu0_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL2DoubleMu0 + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIL2DoubleMu0L2Filtered + process.HLTEndSequence ) +process.HLT_HIL2DoubleMu0_NHitQ_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL2DoubleMu0NHitQ + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIL2DoubleMu0L2N1HitsFiltered + process.HLTEndSequence ) +process.HLT_HIL2DoubleMu3_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL2DoubleMu3 + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIL2DoubleMu3L2Filtered + process.HLTEndSequence ) +process.HLT_HIL3Mu3_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL3Mu3 + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu3L2Filtered + process.HLTHIL3muonrecoSequence + process.hltHISingleMu3L3Filtered + process.HLTEndSequence ) +process.HLT_HIL3DoubleMuOpen_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL3DoubleMuOpen + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIDimuonL2PreFiltered0 + process.HLTHIL3muonrecoSequence + process.hltHIDimuonL3FilterOpen + process.HLTEndSequence ) +process.HLT_HIL3DoubleMuOpen_SS_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL3DoubleMuOpenSS + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIDimuonL2PreFiltered0 + process.HLTHIL3muonrecoSequence + process.hltHIDimuonL3FilterOpenSS + process.HLTEndSequence ) +process.HLT_HIL3DoubleMuOpen_OS_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL3DoubleMuOpenOS + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIDimuonL2PreFiltered0 + process.HLTHIL3muonrecoSequence + process.hltHIDimuonL3FilterOpenOS + process.HLTEndSequence ) +process.HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL3DoubleMuOpenOSNoCowboy + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIDimuonL2PreFiltered0 + process.HLTHIL3muonrecoSequence + process.hltHIDimuonL3FilterOpenOSNoCowboy + process.HLTEndSequence ) process.HLTriggerFinalPath = cms.Path( process.hltGtDigis + process.hltScalersRawToDigi + process.hltFEDSelector + process.hltTriggerSummaryAOD + process.hltTriggerSummaryRAW ) process.AOutput = cms.EndPath( process.hltPreAOutput + process.hltOutputA ) diff --git a/HLTrigger/Configuration/test/OnData_HLT_GRun.py b/HLTrigger/Configuration/test/OnData_HLT_GRun.py index 79dea4467e723..6ffd284dc9839 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_GRun.py +++ b/HLTrigger/Configuration/test/OnData_HLT_GRun.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/GRun/V4 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/GRun/V5 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTGRun" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V4') + tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V5') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -16042,8 +16042,8 @@ reqOppCharge = cms.untracked.bool( False ), nZcandcut = cms.int32( 1 ) ) -process.hltL1sL1SingleIsoEG18 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG18" ), +process.hltL1sL1SingleIsoEG20er = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG20er" ), saveTags = cms.bool( True ), L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), L1UseL1TriggerObjectMaps = cms.bool( True ), @@ -16058,7 +16058,7 @@ L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) -process.hltEGL1SingleIsoEG18erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", +process.hltEGL1SingleIsoEG20erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", doIsolated = cms.bool( False ), endcap_end = cms.double( 2.17 ), saveTags = cms.bool( False ), @@ -16068,7 +16068,7 @@ candIsolatedTag = cms.InputTag( "hltEgammaCandidates" ), region_phi_size = cms.double( 1.044 ), region_eta_size = cms.double( 0.522 ), - L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG18" ), + L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG20er" ), candNonIsolatedTag = cms.InputTag( "" ), l1NonIsolatedTag = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), ncandcut = cms.int32( 1 ) @@ -16078,7 +16078,7 @@ L1NonIsoCand = cms.InputTag( "" ), relaxed = cms.untracked.bool( False ), L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - inputTag = cms.InputTag( "hltEGL1SingleIsoEG18erFilter" ), + inputTag = cms.InputTag( "hltEGL1SingleIsoEG20erFilter" ), etcutEB = cms.double( 22.0 ), etcutEE = cms.double( 22.0 ), ncandcut = cms.int32( 1 ) @@ -39701,7 +39701,7 @@ tanhSO10ForwardThres = cms.double( 1.0 ), L1IsoPixelSeedsTag = cms.InputTag( "hltEgammaElectronPixelSeedsUnseeded" ), L1NonIsoCand = cms.InputTag( "" ), - ncandcut = cms.int32( 1 ), + ncandcut = cms.int32( 2 ), tanhSO10BarrelThres = cms.double( 0.35 ), s_a_rF = cms.double( 0.04 ), L1NonIsoPixelSeedsTag = cms.InputTag( "" ), @@ -44011,7 +44011,7 @@ process.HLTTrackReconstructionIter02 = cms.Sequence( process.HLTPixelTrackingL3Muon + process.HLTDoLocalStripSequence + process.HLTIterativeTrackingL3MuonIter02 ) process.HLTDoublePho85Sequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleEG40ORL1SingleEG35Filter + process.hltEG85EtFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEG85HEFilter + process.HLTPFClusteringForEgammaUnseeded + process.hltEgammaCandidatesUnseeded + process.hltEgammaCandidatesWrapperUnseeded + process.hltDiEG85EtUnseededFilter + process.hltEgammaHoverEUnseeded + process.hltDiEG85HEUnseededFilter ) process.HLTEle20WP60Ele8Mass55Sequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleEG20Filter + process.hltEle20WP60Ele8EtFilter + process.hltEgammaClusterShape + process.hltEle20WP60Ele8ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEle20WP60Ele8HEFilter + process.hltEgammaEcalPFClusterIso + process.hltEle20WP60Ele8EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltEle20WP60Ele8HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltEle20WP60Ele8PixelMatchFilter + process.HLTGsfElectronSequence + process.hltEle20WP60Ele8OneOEMinusOneOPFilter + process.hltEle20WP60Ele8DetaFilter + process.hltEle20WP60Ele8DphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltEle20WP60Ele8TrackIsoFilter + process.HLTPFClusteringForEgammaUnseeded + process.hltEgammaCandidatesUnseeded + process.hltEgammaCandidatesWrapperUnseeded + process.hltEle20WP60Ele8EtUnseededFilter + process.HLTElePixelMatchUnseededSequence + process.hltEle20WP60Ele8PixelMatchUnseededFilter + process.hltEle20WP60Ele8Mass55Filter ) -process.HLTSingleEle22erWP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleIsoEG18erFilter + process.hltSingleEG22EtFilter + process.hltEgammaClusterShape + process.hltSingleEle22WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltSingleEle22WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltSingleEle22WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltSingleEle22WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltSingleEle22WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + process.hltSingleEle22WP75GsfChi2Filter + process.hltSingleEle22WP75GsfDetaFilter + process.hltSingleEle22WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltSingleEle22WP75GsfTrackIsoFilter ) +process.HLTSingleEle22erWP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleIsoEG20erFilter + process.hltSingleEG22EtFilter + process.hltEgammaClusterShape + process.hltSingleEle22WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltSingleEle22WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltSingleEle22WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltSingleEle22WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltSingleEle22WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + process.hltSingleEle22WP75GsfChi2Filter + process.hltSingleEle22WP75GsfDetaFilter + process.hltSingleEle22WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltSingleEle22WP75GsfTrackIsoFilter ) process.HLTEle22WP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGRegionalL1IsoEG20erTauJet20er + process.hltEG22L1sIsoEG20erTauJet20erEtFilter + process.hltEgammaClusterShape + process.hltEle22WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEle22WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltEle22WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltEle22WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltEle22WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltEle22WP75GsfOneOESuperMinusOneOPFilter + process.hltEle22WP75GsfChi2Filter + process.hltEle22WP75GsfDetaFilter + process.hltEle22WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltEle22WP75GsfTrackIsoFilter ) process.HLTParticleFlowSequenceForTaus = cms.Sequence( process.HLTPreshowerSequence + process.hltParticleFlowRecHitECALUnseeded + process.hltParticleFlowRecHitHCAL + process.hltParticleFlowRecHitPSUnseeded + process.hltParticleFlowClusterECALUncorrectedUnseeded + process.hltParticleFlowClusterPSUnseeded + process.hltParticleFlowClusterECALUnseeded + process.hltParticleFlowClusterHCAL + process.hltParticleFlowClusterHFEM + process.hltParticleFlowClusterHFHAD + process.hltLightPFTracks + process.hltParticleFlowBlockForTaus + process.hltParticleFlowForTaus ) process.HLTPFTriggerSequenceForTaus = cms.Sequence( process.HLTL2muonrecoSequence + process.HLTL3muonrecoSequence + process.HLTTrackReconstructionForPF + process.HLTParticleFlowSequenceForTaus + process.hltAK4PFJetsForTaus ) @@ -44239,7 +44239,7 @@ process.HLT_Dimuon6_Jpsi_NoVertexing_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMu0 + process.hltPreDimuon6JpsiNoVertexing + process.hltL1fL1DoubleMu0L1Filtered0 + process.HLTL2muonrecoSequence + process.hltL2fDoubleMu2L2PreFiltered2 + process.HLTL3muonrecoSequence + process.hltDimuon6JpsiL3Filtered + process.HLTEndSequence ) process.HLT_DoublePhoton85_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG40ORL1SingleEG35 + process.hltPreDoublePhoton85 + process.HLTDoublePho85Sequence + process.HLTEndSequence ) process.HLT_Ele20WP60_Ele8_Mass55_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG20 + process.hltPreEle20WP60Ele8Mass55 + process.HLTEle20WP60Ele8Mass55Sequence + process.HLTEndSequence ) -process.HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleIsoEG18 + process.hltPreEle22eta2p1WP75Gsf + process.HLTSingleEle22erWP75GsfSequence + process.HLTEndSequence ) +process.HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleIsoEG20er + process.hltPreEle22eta2p1WP75Gsf + process.HLTSingleEle22erWP75GsfSequence + process.HLTEndSequence ) process.HLT_Ele22_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1IsoEG20erTauJet20er + process.hltPreEle22eta2p1WP75GsfLooseIsoPFTau20 + process.HLTEle22WP75GsfSequence + process.HLTRecoJetSequenceAK4PrePF + process.hltTauJet5 + process.hltOverlapFilterIsoEle22WP75GsfCaloJet5 + process.HLTPFTriggerSequenceForTaus + process.HLTIsoEle22WP75GsfLooseIsoPFTau20Sequence + process.HLTEndSequence ) process.HLT_Ele25WP60_SC4_Mass55_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG20 + process.hltPreEle25WP60SC4Mass55 + process.HLTEle25WP60SC4Mass55Sequence + process.HLTEndSequence ) process.HLT_Ele25_eta2p1_WP85_Gsf_PFMET80_boostedW_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG40ORL1SingleIsoEG30erORL1ETM70 + process.hltPreEle25eta2p1WP85GsfPFMET80boostedW + process.HLTEle25WP85GsfSequence + process.HLTAK4PFJetsSequence + process.hltPFMETProducer + process.hltPFMET80Filter + process.HLTEndSequence ) diff --git a/HLTrigger/Configuration/test/OnData_HLT_HIon.py b/HLTrigger/Configuration/test/OnData_HLT_HIon.py index 07380627b58e8..a36a22dc9c24e 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_HIon.py +++ b/HLTrigger/Configuration/test/OnData_HLT_HIon.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/HIon/V4 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/HIon/V5 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTHIon" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HIon/V4') + tableName = cms.string('/dev/CMSSW_7_4_0/HIon/V5') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -382,14 +382,22 @@ track_prob_min = cms.double( -1.0 ) ) process.streams = cms.PSet( A = cms.vstring( 'InitialPD', - 'Templates' ) ) + 'InitialPDForHI' ) ) process.datasets = cms.PSet( - InitialPD = cms.vstring( 'HLT_Ele27_eta2p1_WP75_Gsf_v1', - 'HLT_Mu50_v1', - 'HLT_PFJet260_v1', - 'HLT_Physics_v1' ), - Templates = cms.vstring( 'HLT_CaloJet260_v1', - 'HLT_Photon20_CaloIdVL_IsoL_v1' ) + InitialPD = cms.vstring( 'HLT_Physics_v1' ), + InitialPDForHI = cms.vstring( 'HLT_HIL1DoubleMu0_HighQ_v1', + 'HLT_HIL2DoubleMu0_NHitQ_v1', + 'HLT_HIL2DoubleMu0_v1', + 'HLT_HIL2DoubleMu3_v1', + 'HLT_HIL2Mu15_v1', + 'HLT_HIL2Mu3_NHitQ_v1', + 'HLT_HIL2Mu3_v1', + 'HLT_HIL2Mu7_v1', + 'HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1', + 'HLT_HIL3DoubleMuOpen_OS_v1', + 'HLT_HIL3DoubleMuOpen_SS_v1', + 'HLT_HIL3DoubleMuOpen_v1', + 'HLT_HIL3Mu3_v1' ) ) process.magfield = cms.ESSource( "XMLIdealGeometryESSource", @@ -2087,8 +2095,15 @@ setSigmaZ = cms.double( 0.0 ), maxRadius = cms.double( 2.0 ) ) -process.hltL1sL1SingleJet200 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleJet200" ), +process.hltPrePhysics = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltBoolEnd = cms.EDFilter( "HLTBool", + result = cms.bool( True ) +) +process.hltL1sL1DoubleMuOpenBptxAND = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_DoubleMuOpen_BptxAND" ), saveTags = cms.bool( True ), L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), L1UseL1TriggerObjectMaps = cms.bool( True ), @@ -2099,635 +2114,23 @@ L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), L1TechTriggerSeeding = cms.bool( False ) ) -process.hltPreCaloJet260 = cms.EDFilter( "HLTPrescaler", +process.hltPreHIL1DoubleMu0HighQ = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) -process.hltEcalDigis = cms.EDProducer( "EcalRawToDigi", - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), - FedLabel = cms.InputTag( "listfeds" ), - eventPut = cms.bool( True ), - srpUnpacking = cms.bool( True ), - syncCheck = cms.bool( True ), - headerUnpacking = cms.bool( True ), - feUnpacking = cms.bool( True ), - orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), - tccUnpacking = cms.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), - InputLabel = cms.InputTag( "rawDataRepacker" ), - numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), - FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), - silentMode = cms.untracked.bool( True ), - DoRegional = cms.bool( False ), - forceToKeepFRData = cms.bool( False ), - memUnpacking = cms.bool( True ) -) -process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", - EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), - EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - algo = cms.string( "EcalUncalibRecHitWorkerMultiFit" ), - algoPSet = cms.PSet( - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( False ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( False ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 100.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( True ), - doPrefitEB = cms.bool( True ) - ) -) -process.hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", - ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), - ebDetIdToBeRecovered = cms.string( "ebDetId" ), - integrityTTIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityTTIdErrors' ), - eeIntegrityGainErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityGainErrors' ), - ebFEToBeRecovered = cms.string( "ebFE" ), - ebIntegrityGainErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityGainErrors' ), - eeDetIdToBeRecovered = cms.string( "eeDetId" ), - eeIntegrityGainSwitchErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityGainSwitchErrors' ), - eeIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), - ebIntegrityGainSwitchErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityGainSwitchErrors' ), - ebSrFlagCollection = cms.InputTag( "hltEcalDigis" ), - eeSrFlagCollection = cms.InputTag( "hltEcalDigis" ), - integrityBlockSizeErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityBlockSizeErrors' ), - eeFEToBeRecovered = cms.string( "eeFE" ) -) -process.hltEcalRecHit = cms.EDProducer( "EcalRecHitProducer", - recoverEEVFE = cms.bool( False ), - EErechitCollection = cms.string( "EcalRecHitsEE" ), - recoverEBIsolatedChannels = cms.bool( False ), - recoverEBVFE = cms.bool( False ), - laserCorrection = cms.bool( True ), - EBLaserMIN = cms.double( 0.5 ), - killDeadChannels = cms.bool( True ), - dbStatusToBeExcludedEB = cms.vint32( 14, 78, 142 ), - EEuncalibRecHitCollection = cms.InputTag( 'hltEcalUncalibRecHit','EcalUncalibRecHitsEE' ), - EBLaserMAX = cms.double( 3.0 ), - EELaserMIN = cms.double( 0.5 ), - ebFEToBeRecovered = cms.InputTag( 'hltEcalDetIdToBeRecovered','ebFE' ), - EELaserMAX = cms.double( 8.0 ), - recoverEEIsolatedChannels = cms.bool( False ), - eeDetIdToBeRecovered = cms.InputTag( 'hltEcalDetIdToBeRecovered','eeDetId' ), - recoverEBFE = cms.bool( True ), - algo = cms.string( "EcalRecHitWorkerSimple" ), - ebDetIdToBeRecovered = cms.InputTag( 'hltEcalDetIdToBeRecovered','ebDetId' ), - singleChannelRecoveryThreshold = cms.double( 8.0 ), - ChannelStatusToBeExcluded = cms.vstring( ), - EBrechitCollection = cms.string( "EcalRecHitsEB" ), - singleChannelRecoveryMethod = cms.string( "NeuralNetworks" ), - recoverEEFE = cms.bool( True ), - triggerPrimitiveDigiCollection = cms.InputTag( 'hltEcalDigis','EcalTriggerPrimitives' ), - dbStatusToBeExcludedEE = cms.vint32( 14, 78, 142 ), - flagsMapDBReco = cms.PSet( - kGood = cms.vstring( 'kOk', - 'kDAC', - 'kNoLaser', - 'kNoisy' ), - kNeighboursRecovered = cms.vstring( 'kFixedG0', - 'kNonRespondingIsolated', - 'kDeadVFE' ), - kDead = cms.vstring( 'kNoDataNoTP' ), - kNoisy = cms.vstring( 'kNNoisy', - 'kFixedG6', - 'kFixedG1' ), - kTowerRecovered = cms.vstring( 'kDeadFE' ) - ), - EBuncalibRecHitCollection = cms.InputTag( 'hltEcalUncalibRecHit','EcalUncalibRecHitsEB' ), - algoRecover = cms.string( "EcalRecHitWorkerRecover" ), - eeFEToBeRecovered = cms.InputTag( 'hltEcalDetIdToBeRecovered','eeFE' ), - cleaningConfig = cms.PSet( - e6e2thresh = cms.double( 0.04 ), - tightenCrack_e6e2_double = cms.double( 3.0 ), - e4e1Threshold_endcap = cms.double( 0.3 ), - tightenCrack_e4e1_single = cms.double( 3.0 ), - tightenCrack_e1_double = cms.double( 2.0 ), - cThreshold_barrel = cms.double( 4.0 ), - e4e1Threshold_barrel = cms.double( 0.08 ), - tightenCrack_e1_single = cms.double( 2.0 ), - e4e1_b_barrel = cms.double( -0.024 ), - e4e1_a_barrel = cms.double( 0.04 ), - ignoreOutOfTimeThresh = cms.double( 1.0E9 ), - cThreshold_endcap = cms.double( 15.0 ), - e4e1_b_endcap = cms.double( -0.0125 ), - e4e1_a_endcap = cms.double( 0.02 ), - cThreshold_double = cms.double( 10.0 ) - ), - logWarningEtThreshold_EB_FE = cms.double( 50.0 ), - logWarningEtThreshold_EE_FE = cms.double( 50.0 ) -) -process.hltHcalDigis = cms.EDProducer( "HcalRawToDigi", - ExpectedOrbitMessageTime = cms.untracked.int32( -1 ), - FilterDataQuality = cms.bool( True ), - silent = cms.untracked.bool( True ), - HcalFirstFED = cms.untracked.int32( 700 ), - InputLabel = cms.InputTag( "rawDataRepacker" ), - ComplainEmptyData = cms.untracked.bool( False ), - UnpackCalib = cms.untracked.bool( True ), - FEDs = cms.untracked.vint32( ), - UnpackerMode = cms.untracked.int32( 0 ), - UnpackTTP = cms.untracked.bool( False ), - lastSample = cms.int32( 9 ), - UnpackZDC = cms.untracked.bool( True ), - firstSample = cms.int32( 0 ) -) -process.hltHbhereco = cms.EDProducer( "HcalHitReconstructor", - digiTimeFromDB = cms.bool( True ), - mcOOTCorrectionName = cms.string( "" ), - S9S1stat = cms.PSet( ), - saturationParameters = cms.PSet( maxADCvalue = cms.int32( 127 ) ), - tsFromDB = cms.bool( True ), - samplesToAdd = cms.int32( 4 ), - mcOOTCorrectionCategory = cms.string( "MC" ), - dataOOTCorrectionName = cms.string( "" ), - puCorrMethod = cms.int32( 0 ), - correctionPhaseNS = cms.double( 13.0 ), - HFInWindowStat = cms.PSet( ), - digiLabel = cms.InputTag( "hltHcalDigis" ), - setHSCPFlags = cms.bool( False ), - firstAuxTS = cms.int32( 4 ), - digistat = cms.PSet( ), - hfTimingTrustParameters = cms.PSet( ), - PETstat = cms.PSet( ), - setSaturationFlags = cms.bool( False ), - setNegativeFlags = cms.bool( False ), - useLeakCorrection = cms.bool( False ), - setTimingTrustFlags = cms.bool( False ), - S8S1stat = cms.PSet( ), - correctForPhaseContainment = cms.bool( True ), - correctForTimeslew = cms.bool( True ), - setNoiseFlags = cms.bool( False ), - correctTiming = cms.bool( False ), - setPulseShapeFlags = cms.bool( False ), - Subdetector = cms.string( "HBHE" ), - dataOOTCorrectionCategory = cms.string( "Data" ), - dropZSmarkedPassed = cms.bool( True ), - recoParamsFromDB = cms.bool( True ), - firstSample = cms.int32( 4 ), - setTimingShapedCutsFlags = cms.bool( False ), - pulseJitter = cms.double( 1.0 ), - chargeMax = cms.double( 6.0 ), - negativeParameters = cms.PSet( - TS4TS5ChargeThreshold = cms.double( 70.0 ), - Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), - Last = cms.int32( 6 ), - MinimumChargeThreshold = cms.double( 20.0 ), - Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), - First = cms.int32( 4 ) - ), - timeMin = cms.double( -15.0 ), - ts4chi2 = cms.double( 15.0 ), - ts345chi2 = cms.double( 100.0 ), - applyTimeSlew = cms.bool( True ), - applyTimeConstraint = cms.bool( True ), - applyPulseJitter = cms.bool( False ), - timingshapedcutsParameters = cms.PSet( - ignorelowest = cms.bool( True ), - win_offset = cms.double( 0.0 ), - ignorehighest = cms.bool( False ), - win_gain = cms.double( 1.0 ), - tfilterEnvelope = cms.vdouble( 4.0, 12.04, 13.0, 10.56, 23.5, 8.82, 37.0, 7.38, 56.0, 6.3, 81.0, 5.64, 114.5, 5.44, 175.5, 5.38, 350.5, 5.14 ) - ), - ts3chi2 = cms.double( 5.0 ), - ts4Min = cms.double( 5.0 ), - pulseShapeParameters = cms.PSet( ), - noise = cms.double( 1.0 ), - applyPedConstraint = cms.bool( True ), - applyUnconstrainedFit = cms.bool( False ), - ts4Max = cms.double( 500.0 ), - meanTime = cms.double( -2.5 ), - flagParameters = cms.PSet( - nominalPedestal = cms.double( 3.0 ), - hitMultiplicityThreshold = cms.int32( 17 ), - hitEnergyMinimum = cms.double( 1.0 ), - pulseShapeParameterSets = cms.VPSet( - cms.PSet( pulseShapeParameters = cms.vdouble( 0.0, 100.0, -50.0, 0.0, -15.0, 0.15 ) ), - cms.PSet( pulseShapeParameters = cms.vdouble( 100.0, 2000.0, -50.0, 0.0, -5.0, 0.05 ) ), - cms.PSet( pulseShapeParameters = cms.vdouble( 2000.0, 1000000.0, -50.0, 0.0, 95.0, 0.0 ) ), - cms.PSet( pulseShapeParameters = cms.vdouble( -1000000.0, 1000000.0, 45.0, 0.1, 1000000.0, 0.0 ) ) - ) - ), - fitTimes = cms.int32( 1 ), - timeMax = cms.double( 10.0 ), - timeSigma = cms.double( 5.0 ), - pedSigma = cms.double( 0.5 ), - meanPed = cms.double( 0.0 ), - hscpParameters = cms.PSet( - slopeMax = cms.double( -0.6 ), - r1Max = cms.double( 1.0 ), - r1Min = cms.double( 0.15 ), - TimingEnergyThreshold = cms.double( 30.0 ), - slopeMin = cms.double( -1.5 ), - outerMin = cms.double( 0.0 ), - outerMax = cms.double( 0.1 ), - fracLeaderMin = cms.double( 0.4 ), - r2Min = cms.double( 0.1 ), - r2Max = cms.double( 0.5 ), - fracLeaderMax = cms.double( 0.7 ) - ) -) -process.hltHfreco = cms.EDProducer( "HcalHitReconstructor", - digiTimeFromDB = cms.bool( True ), - mcOOTCorrectionName = cms.string( "" ), - S9S1stat = cms.PSet( - longETParams = cms.vdouble( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ), - shortEnergyParams = cms.vdouble( 35.1773, 35.37, 35.7933, 36.4472, 37.3317, 38.4468, 39.7925, 41.3688, 43.1757, 45.2132, 47.4813, 49.98, 52.7093 ), - flagsToSkip = cms.int32( 24 ), - shortETParams = cms.vdouble( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ), - short_optimumSlope = cms.vdouble( -99999.0, 0.0164905, 0.0238698, 0.0321383, 0.041296, 0.0513428, 0.0622789, 0.0741041, 0.0868186, 0.100422, 0.135313, 0.136289, 0.0589927 ), - longEnergyParams = cms.vdouble( 43.5, 45.7, 48.32, 51.36, 54.82, 58.7, 63.0, 67.72, 72.86, 78.42, 84.4, 90.8, 97.62 ), - long_optimumSlope = cms.vdouble( -99999.0, 0.0164905, 0.0238698, 0.0321383, 0.041296, 0.0513428, 0.0622789, 0.0741041, 0.0868186, 0.100422, 0.135313, 0.136289, 0.0589927 ), - isS8S1 = cms.bool( False ), - HcalAcceptSeverityLevel = cms.int32( 9 ) - ), - saturationParameters = cms.PSet( maxADCvalue = cms.int32( 127 ) ), - tsFromDB = cms.bool( True ), - samplesToAdd = cms.int32( 2 ), - mcOOTCorrectionCategory = cms.string( "MC" ), - dataOOTCorrectionName = cms.string( "" ), - puCorrMethod = cms.int32( 0 ), - correctionPhaseNS = cms.double( 13.0 ), - HFInWindowStat = cms.PSet( - hflongEthresh = cms.double( 40.0 ), - hflongMinWindowTime = cms.vdouble( -10.0 ), - hfshortEthresh = cms.double( 40.0 ), - hflongMaxWindowTime = cms.vdouble( 10.0 ), - hfshortMaxWindowTime = cms.vdouble( 10.0 ), - hfshortMinWindowTime = cms.vdouble( -12.0 ) - ), - digiLabel = cms.InputTag( "hltHcalDigis" ), - setHSCPFlags = cms.bool( False ), - firstAuxTS = cms.int32( 1 ), - digistat = cms.PSet( - HFdigiflagFirstSample = cms.int32( 1 ), - HFdigiflagMinEthreshold = cms.double( 40.0 ), - HFdigiflagSamplesToAdd = cms.int32( 3 ), - HFdigiflagExpectedPeak = cms.int32( 2 ), - HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) - ), - hfTimingTrustParameters = cms.PSet( - hfTimingTrustLevel2 = cms.int32( 4 ), - hfTimingTrustLevel1 = cms.int32( 1 ) - ), - PETstat = cms.PSet( - longETParams = cms.vdouble( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ), - short_R_29 = cms.vdouble( 0.8 ), - shortEnergyParams = cms.vdouble( 35.1773, 35.37, 35.7933, 36.4472, 37.3317, 38.4468, 39.7925, 41.3688, 43.1757, 45.2132, 47.4813, 49.98, 52.7093 ), - flagsToSkip = cms.int32( 0 ), - short_R = cms.vdouble( 0.8 ), - shortETParams = cms.vdouble( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ), - long_R_29 = cms.vdouble( 0.8 ), - longEnergyParams = cms.vdouble( 43.5, 45.7, 48.32, 51.36, 54.82, 58.7, 63.0, 67.72, 72.86, 78.42, 84.4, 90.8, 97.62 ), - long_R = cms.vdouble( 0.98 ), - HcalAcceptSeverityLevel = cms.int32( 9 ) - ), - setSaturationFlags = cms.bool( False ), - setNegativeFlags = cms.bool( False ), - useLeakCorrection = cms.bool( False ), - setTimingTrustFlags = cms.bool( False ), - S8S1stat = cms.PSet( - longETParams = cms.vdouble( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ), - shortEnergyParams = cms.vdouble( 40.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0 ), - flagsToSkip = cms.int32( 16 ), - shortETParams = cms.vdouble( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ), - short_optimumSlope = cms.vdouble( 0.3, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1 ), - longEnergyParams = cms.vdouble( 40.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0 ), - long_optimumSlope = cms.vdouble( 0.3, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1 ), - isS8S1 = cms.bool( True ), - HcalAcceptSeverityLevel = cms.int32( 9 ) - ), - correctForPhaseContainment = cms.bool( False ), - correctForTimeslew = cms.bool( False ), - setNoiseFlags = cms.bool( True ), - correctTiming = cms.bool( False ), - setPulseShapeFlags = cms.bool( False ), - Subdetector = cms.string( "HF" ), - dataOOTCorrectionCategory = cms.string( "Data" ), - dropZSmarkedPassed = cms.bool( True ), - recoParamsFromDB = cms.bool( True ), - firstSample = cms.int32( 2 ), - setTimingShapedCutsFlags = cms.bool( False ), - pulseJitter = cms.double( 1.0 ), - chargeMax = cms.double( 6.0 ), - negativeParameters = cms.PSet( - TS4TS5ChargeThreshold = cms.double( 70.0 ), - Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), - Last = cms.int32( 6 ), - MinimumChargeThreshold = cms.double( 20.0 ), - Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), - First = cms.int32( 4 ) - ), - timeMin = cms.double( -15.0 ), - ts4chi2 = cms.double( 15.0 ), - ts345chi2 = cms.double( 100.0 ), - applyTimeSlew = cms.bool( True ), - applyTimeConstraint = cms.bool( True ), - applyPulseJitter = cms.bool( False ), - timingshapedcutsParameters = cms.PSet( ), - ts3chi2 = cms.double( 5.0 ), - ts4Min = cms.double( 5.0 ), - pulseShapeParameters = cms.PSet( ), - noise = cms.double( 1.0 ), - applyPedConstraint = cms.bool( True ), - applyUnconstrainedFit = cms.bool( False ), - ts4Max = cms.double( 500.0 ), - meanTime = cms.double( -2.5 ), - flagParameters = cms.PSet( ), - fitTimes = cms.int32( 1 ), - timeMax = cms.double( 10.0 ), - timeSigma = cms.double( 5.0 ), - pedSigma = cms.double( 0.5 ), - meanPed = cms.double( 0.0 ), - hscpParameters = cms.PSet( ) -) -process.hltHoreco = cms.EDProducer( "HcalHitReconstructor", - digiTimeFromDB = cms.bool( True ), - mcOOTCorrectionName = cms.string( "" ), - S9S1stat = cms.PSet( ), - saturationParameters = cms.PSet( maxADCvalue = cms.int32( 127 ) ), - tsFromDB = cms.bool( True ), - samplesToAdd = cms.int32( 4 ), - mcOOTCorrectionCategory = cms.string( "MC" ), - dataOOTCorrectionName = cms.string( "" ), - puCorrMethod = cms.int32( 0 ), - correctionPhaseNS = cms.double( 13.0 ), - HFInWindowStat = cms.PSet( ), - digiLabel = cms.InputTag( "hltHcalDigis" ), - setHSCPFlags = cms.bool( False ), - firstAuxTS = cms.int32( 4 ), - digistat = cms.PSet( ), - hfTimingTrustParameters = cms.PSet( ), - PETstat = cms.PSet( ), - setSaturationFlags = cms.bool( False ), - setNegativeFlags = cms.bool( False ), - useLeakCorrection = cms.bool( False ), - setTimingTrustFlags = cms.bool( False ), - S8S1stat = cms.PSet( ), - correctForPhaseContainment = cms.bool( True ), - correctForTimeslew = cms.bool( True ), - setNoiseFlags = cms.bool( False ), - correctTiming = cms.bool( False ), - setPulseShapeFlags = cms.bool( False ), - Subdetector = cms.string( "HO" ), - dataOOTCorrectionCategory = cms.string( "Data" ), - dropZSmarkedPassed = cms.bool( True ), - recoParamsFromDB = cms.bool( True ), - firstSample = cms.int32( 4 ), - setTimingShapedCutsFlags = cms.bool( False ), - pulseJitter = cms.double( 1.0 ), - chargeMax = cms.double( 6.0 ), - negativeParameters = cms.PSet( - TS4TS5ChargeThreshold = cms.double( 70.0 ), - Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), - Last = cms.int32( 6 ), - MinimumChargeThreshold = cms.double( 20.0 ), - Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), - First = cms.int32( 4 ) - ), - timeMin = cms.double( -15.0 ), - ts4chi2 = cms.double( 15.0 ), - ts345chi2 = cms.double( 100.0 ), - applyTimeSlew = cms.bool( True ), - applyTimeConstraint = cms.bool( True ), - applyPulseJitter = cms.bool( False ), - timingshapedcutsParameters = cms.PSet( ), - ts3chi2 = cms.double( 5.0 ), - ts4Min = cms.double( 5.0 ), - pulseShapeParameters = cms.PSet( ), - noise = cms.double( 1.0 ), - applyPedConstraint = cms.bool( True ), - applyUnconstrainedFit = cms.bool( False ), - ts4Max = cms.double( 500.0 ), - meanTime = cms.double( -2.5 ), - flagParameters = cms.PSet( ), - fitTimes = cms.int32( 1 ), - timeMax = cms.double( 10.0 ), - timeSigma = cms.double( 5.0 ), - pedSigma = cms.double( 0.5 ), - meanPed = cms.double( 0.0 ), - hscpParameters = cms.PSet( ) -) -process.hltTowerMakerForAll = cms.EDProducer( "CaloTowersCreator", - EBSumThreshold = cms.double( 0.2 ), - MomHBDepth = cms.double( 0.2 ), - UseEtEBTreshold = cms.bool( False ), - hfInput = cms.InputTag( "hltHfreco" ), - AllowMissingInputs = cms.bool( False ), - MomEEDepth = cms.double( 0.0 ), - EESumThreshold = cms.double( 0.45 ), - HBGrid = cms.vdouble( ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - HBThreshold = cms.double( 0.7 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), - UseEcalRecoveredHits = cms.bool( False ), - MomConstrMethod = cms.int32( 1 ), - MomHEDepth = cms.double( 0.4 ), - HcalThreshold = cms.double( -1000.0 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), - UseSymEBTreshold = cms.bool( False ), - EEWeights = cms.vdouble( ), - EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), - HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HEDGrid = cms.vdouble( ), - EBWeight = cms.double( 1.0 ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), - HOWeight = cms.double( 1.0E-99 ), - HESWeight = cms.double( 1.0 ), - HESThreshold = cms.double( 0.8 ), - hbheInput = cms.InputTag( "hltHbhereco" ), - HF2Weight = cms.double( 1.0 ), - HF2Threshold = cms.double( 0.85 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EEThreshold = cms.double( 0.3 ), - HOThresholdPlus1 = cms.double( 3.5 ), - HOThresholdPlus2 = cms.double( 3.5 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HF1Threshold = cms.double( 0.5 ), - HOThresholdMinus1 = cms.double( 3.5 ), - HESGrid = cms.vdouble( ), - EcutTower = cms.double( -1000.0 ), - UseRejectedRecoveredEcalHits = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - HESWeights = cms.vdouble( ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), - HEDWeight = cms.double( 1.0 ), - UseSymEETreshold = cms.bool( False ), - HEDThreshold = cms.double( 0.8 ), - EBThreshold = cms.double( 0.07 ), - UseRejectedHitsOnly = cms.bool( False ), - UseHcalRecoveredHits = cms.bool( False ), - HOThresholdMinus2 = cms.double( 3.5 ), - HOThreshold0 = cms.double( 3.5 ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), - UseRejectedRecoveredHcalHits = cms.bool( False ), - MomEBDepth = cms.double( 0.3 ), - HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ) -) -process.hltAK4CaloJets = cms.EDProducer( "FastjetJetProducer", - Active_Area_Repeats = cms.int32( 5 ), - doAreaFastjet = cms.bool( False ), - voronoiRfact = cms.double( 0.9 ), - maxBadHcalCells = cms.uint32( 9999999 ), - doAreaDiskApprox = cms.bool( True ), - maxRecoveredEcalCells = cms.uint32( 9999999 ), - jetType = cms.string( "CaloJet" ), - minSeed = cms.uint32( 14327 ), - Ghost_EtaMax = cms.double( 6.0 ), - doRhoFastjet = cms.bool( False ), - jetAlgorithm = cms.string( "AntiKt" ), - nSigmaPU = cms.double( 1.0 ), - GhostArea = cms.double( 0.01 ), - Rho_EtaMax = cms.double( 4.4 ), - maxBadEcalCells = cms.uint32( 9999999 ), - useDeterministicSeed = cms.bool( True ), - doPVCorrection = cms.bool( False ), - maxRecoveredHcalCells = cms.uint32( 9999999 ), - rParam = cms.double( 0.4 ), - maxProblematicHcalCells = cms.uint32( 9999999 ), - doOutputJets = cms.bool( True ), - src = cms.InputTag( "hltTowerMakerForAll" ), - inputEtMin = cms.double( 0.3 ), - puPtMin = cms.double( 10.0 ), - srcPVs = cms.InputTag( "NotUsed" ), - jetPtMin = cms.double( 1.0 ), - radiusPU = cms.double( 0.4 ), - maxProblematicEcalCells = cms.uint32( 9999999 ), - doPUOffsetCorr = cms.bool( False ), - inputEMin = cms.double( 0.0 ), - useMassDropTagger = cms.bool( False ), - muMin = cms.double( -1.0 ), - subtractorName = cms.string( "" ), - muCut = cms.double( -1.0 ), - subjetPtMin = cms.double( -1.0 ), - useTrimming = cms.bool( False ), - muMax = cms.double( -1.0 ), - yMin = cms.double( -1.0 ), - useFiltering = cms.bool( False ), - rFilt = cms.double( -1.0 ), - yMax = cms.double( -1.0 ), - zcut = cms.double( -1.0 ), - MinVtxNdof = cms.int32( 5 ), - MaxVtxZ = cms.double( 15.0 ), - UseOnlyVertexTracks = cms.bool( False ), - dRMin = cms.double( -1.0 ), - nFilt = cms.int32( -1 ), - usePruning = cms.bool( False ), - maxDepth = cms.int32( -1 ), - yCut = cms.double( -1.0 ), - DzTrVtxMax = cms.double( 0.0 ), - UseOnlyOnePV = cms.bool( False ), - rcut_factor = cms.double( -1.0 ), - sumRecHits = cms.bool( False ), - trimPtFracMin = cms.double( -1.0 ), - dRMax = cms.double( -1.0 ), - DxyTrVtxMax = cms.double( 0.0 ), - useCMSBoostedTauSeedingAlgorithm = cms.bool( False ) -) -process.hltAK4CaloJetsIDPassed = cms.EDProducer( "HLTCaloJetIDProducer", - min_N90 = cms.int32( -2 ), - min_N90hits = cms.int32( 2 ), - min_EMF = cms.double( 1.0E-6 ), - jetsInput = cms.InputTag( "hltAK4CaloJets" ), - JetIDParams = cms.PSet( - useRecHits = cms.bool( True ), - hbheRecHitsColl = cms.InputTag( "hltHbhereco" ), - hoRecHitsColl = cms.InputTag( "hltHoreco" ), - hfRecHitsColl = cms.InputTag( "hltHfreco" ), - ebRecHitsColl = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEB' ), - eeRecHitsColl = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEE' ) - ), - max_EMF = cms.double( 999.0 ) -) -process.hltFixedGridRhoFastjetAllCalo = cms.EDProducer( "FixedGridRhoProducerFastjet", - gridSpacing = cms.double( 0.55 ), - maxRapidity = cms.double( 5.0 ), - pfCandidatesTag = cms.InputTag( "hltTowerMakerForAll" ) -) -process.hltAK4CaloJetsCorrected = cms.EDProducer( "CaloJetCorrectionProducer", - src = cms.InputTag( "hltAK4CaloJets" ), - correctors = cms.vstring( 'hltESPAK4CaloCorrection' ) -) -process.hltAK4CaloJetsCorrectedIDPassed = cms.EDProducer( "CaloJetCorrectionProducer", - src = cms.InputTag( "hltAK4CaloJetsIDPassed" ), - correctors = cms.vstring( 'hltESPAK4CaloCorrection' ) -) -process.hltSingleCaloJet260 = cms.EDFilter( "HLT1CaloJet", +process.hltL1fL1DoubleMu0HQL1Filtered0 = cms.EDFilter( "HLTMuonL1Filter", saveTags = cms.bool( True ), - MinPt = cms.double( 260.0 ), - MinN = cms.int32( 1 ), - MaxEta = cms.double( 5.0 ), - MinMass = cms.double( -1.0 ), - inputTag = cms.InputTag( "hltAK4CaloJetsCorrectedIDPassed" ), - MinE = cms.double( -1.0 ), - triggerType = cms.int32( 85 ) -) -process.hltBoolEnd = cms.EDFilter( "HLTBool", - result = cms.bool( True ) + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1DoubleMuOpenBptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "hltL1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) ) -process.hltL1sL1SingleIsoEG22er = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG22er" ), +process.hltL1sL1SingleMu3BptxAND = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleMu3_BptxAND" ), saveTags = cms.bool( True ), L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), L1UseL1TriggerObjectMaps = cms.bool( True ), @@ -2738,5670 +2141,1703 @@ L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), L1TechTriggerSeeding = cms.bool( False ) ) -process.hltPreEle27eta2p1WP75Gsf = cms.EDFilter( "HLTPrescaler", +process.hltPreHIL2Mu3 = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) -process.hltEcalPreshowerDigis = cms.EDProducer( "ESRawToDigi", - sourceTag = cms.InputTag( "rawDataRepacker" ), - debugMode = cms.untracked.bool( False ), - InstanceES = cms.string( "" ), - ESdigiCollection = cms.string( "" ), - LookupTable = cms.FileInPath( "EventFilter/ESDigiToRaw/data/ES_lookup_table.dat" ) -) -process.hltEcalPreshowerRecHit = cms.EDProducer( "ESRecHitProducer", - ESRecoAlgo = cms.int32( 0 ), - ESrechitCollection = cms.string( "EcalRecHitsES" ), - algo = cms.string( "ESRecHitWorker" ), - ESdigiCollection = cms.InputTag( "hltEcalPreshowerDigis" ) -) -process.hltRechitInRegionsECAL = cms.EDProducer( "EgammaHLTRechitInRegionsProducer", - l1LowerThr = cms.double( 5.0 ), - doIsolated = cms.bool( True ), - useUncalib = cms.bool( False ), - regionEtaMargin = cms.double( 0.14 ), - ecalhitLabels = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), - regionPhiMargin = cms.double( 0.4 ), - l1TagNonIsolated = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), - l1UpperThr = cms.double( 999.0 ), - l1LowerThrIgnoreIsolation = cms.double( 0.0 ), - productLabels = cms.vstring( 'EcalRecHitsEB', - 'EcalRecHitsEE' ), - l1TagIsolated = cms.InputTag( 'hltL1extraParticles','Isolated' ) -) -process.hltRechitInRegionsES = cms.EDProducer( "EgammaHLTRechitInRegionsProducer", - l1LowerThr = cms.double( 5.0 ), - doIsolated = cms.bool( True ), - useUncalib = cms.bool( False ), - regionEtaMargin = cms.double( 0.14 ), - ecalhitLabels = cms.VInputTag( 'hltEcalPreshowerRecHit:EcalRecHitsES' ), - regionPhiMargin = cms.double( 0.4 ), - l1TagNonIsolated = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), - l1UpperThr = cms.double( 999.0 ), - l1LowerThrIgnoreIsolation = cms.double( 0.0 ), - productLabels = cms.vstring( 'EcalRecHitsES' ), - l1TagIsolated = cms.InputTag( 'hltL1extraParticles','Isolated' ) -) -process.hltParticleFlowRecHitECALL1Seeded = cms.EDProducer( "PFRecHitProducer", - producers = cms.VPSet( - cms.PSet( src = cms.InputTag( 'hltRechitInRegionsECAL','EcalRecHitsEB' ), - qualityTests = cms.VPSet( - cms.PSet( threshold = cms.double( 0.08 ), - name = cms.string( "PFRecHitQTestThreshold" ) - ), - cms.PSet( timingCleaning = cms.bool( True ), - topologicalCleaning = cms.bool( True ), - cleaningThreshold = cms.double( 2.0 ), - skipTTRecoveredHits = cms.bool( True ), - name = cms.string( "PFRecHitQTestECAL" ) - ) - ), - name = cms.string( "PFEBRecHitCreator" ) - ), - cms.PSet( src = cms.InputTag( 'hltRechitInRegionsECAL','EcalRecHitsEE' ), - qualityTests = cms.VPSet( - cms.PSet( threshold = cms.double( 0.3 ), - name = cms.string( "PFRecHitQTestThreshold" ) - ), - cms.PSet( timingCleaning = cms.bool( True ), - topologicalCleaning = cms.bool( True ), - cleaningThreshold = cms.double( 2.0 ), - skipTTRecoveredHits = cms.bool( True ), - name = cms.string( "PFRecHitQTestECAL" ) - ) - ), - name = cms.string( "PFEERecHitCreator" ) - ) - ), - navigator = cms.PSet( - barrel = cms.PSet( ), - endcap = cms.PSet( ), - name = cms.string( "PFRecHitECALNavigator" ) - ) +process.hltHIL1SingleMu3Filtered = cms.EDFilter( "HLTMuonL1Filter", + saveTags = cms.bool( False ), + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1SingleMu3BptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 1 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "hltL1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) ) -process.hltParticleFlowRecHitPSL1Seeded = cms.EDProducer( "PFRecHitProducer", - producers = cms.VPSet( - cms.PSet( src = cms.InputTag( 'hltRechitInRegionsES','EcalRecHitsES' ), - qualityTests = cms.VPSet( - cms.PSet( threshold = cms.double( 7.0E-6 ), - name = cms.string( "PFRecHitQTestThreshold" ) - ) - ), - name = cms.string( "PFPSRecHitCreator" ) - ) - ), - navigator = cms.PSet( name = cms.string( "PFRecHitPreshowerNavigator" ) ) -) -process.hltParticleFlowClusterPSL1Seeded = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - minFracTot = cms.double( 1.0E-20 ), - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 6.0E-5 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 0.3 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "PS1" ), - recHitEnergyNorm = cms.double( 6.0E-5 ) - ), - cms.PSet( detector = cms.string( "PS2" ), - recHitEnergyNorm = cms.double( 6.0E-5 ) - ) - ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ) - ), - positionReCalc = cms.PSet( ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 6.0E-5 ), - detector = cms.string( "PS1" ), - gatheringThresholdPt = cms.double( 0.0 ) - ), - cms.PSet( gatheringThreshold = cms.double( 6.0E-5 ), - detector = cms.string( "PS2" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) - ), - useCornerCells = cms.bool( False ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 4 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 1.2E-4 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "PS1" ) - ), - cms.PSet( seedingThreshold = cms.double( 1.2E-4 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "PS2" ) - ) - ), - algoName = cms.string( "LocalMaximumSeedFinder" ) - ), - recHitsSource = cms.InputTag( "hltParticleFlowRecHitPSL1Seeded" ) -) -process.hltParticleFlowClusterECALUncorrectedL1Seeded = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.08 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( 9 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - minFracTot = cms.double( 1.0E-20 ), - positionCalcForConvergence = cms.PSet( - minFractionInCalc = cms.double( 0.0 ), - W0 = cms.double( 4.2 ), - minAllowedNormalization = cms.double( 0.0 ), - T0_EB = cms.double( 7.4 ), - X0 = cms.double( 0.89 ), - T0_ES = cms.double( 1.2 ), - T0_EE = cms.double( 3.1 ), - algoName = cms.string( "ECAL2DPositionCalcWithDepthCorr" ) - ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 1.5 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "ECAL_BARREL" ), - recHitEnergyNorm = cms.double( 0.08 ) - ), - cms.PSet( detector = cms.string( "ECAL_ENDCAP" ), - recHitEnergyNorm = cms.double( 0.3 ) - ) - ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ), - allCellsPositionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.08 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ) - ), - positionReCalc = cms.PSet( - minFractionInCalc = cms.double( 0.0 ), - W0 = cms.double( 4.2 ), - minAllowedNormalization = cms.double( 0.0 ), - T0_EB = cms.double( 7.4 ), - X0 = cms.double( 0.89 ), - T0_ES = cms.double( 1.2 ), - T0_EE = cms.double( 3.1 ), - algoName = cms.string( "ECAL2DPositionCalcWithDepthCorr" ) - ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 0.08 ), - detector = cms.string( "ECAL_BARREL" ), - gatheringThresholdPt = cms.double( 0.0 ) - ), - cms.PSet( gatheringThreshold = cms.double( 0.3 ), - detector = cms.string( "ECAL_ENDCAP" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) - ), - useCornerCells = cms.bool( True ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - cms.PSet( cleaningByDetector = cms.VPSet( - cms.PSet( doubleSpikeS6S2 = cms.double( 0.04 ), - fractionThresholdModifier = cms.double( 3.0 ), - doubleSpikeThresh = cms.double( 10.0 ), - minS4S1_b = cms.double( -0.024 ), - singleSpikeThresh = cms.double( 4.0 ), - detector = cms.string( "ECAL_BARREL" ), - minS4S1_a = cms.double( 0.04 ), - energyThresholdModifier = cms.double( 2.0 ) - ), - cms.PSet( doubleSpikeS6S2 = cms.double( -1.0 ), - fractionThresholdModifier = cms.double( 3.0 ), - doubleSpikeThresh = cms.double( 1.0E9 ), - minS4S1_b = cms.double( -0.0125 ), - singleSpikeThresh = cms.double( 15.0 ), - detector = cms.string( "ECAL_ENDCAP" ), - minS4S1_a = cms.double( 0.02 ), - energyThresholdModifier = cms.double( 2.0 ) - ) -), - algoName = cms.string( "SpikeAndDoubleSpikeCleaner" ) - ) - ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 8 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 0.6 ), - seedingThresholdPt = cms.double( 0.15 ), - detector = cms.string( "ECAL_ENDCAP" ) - ), - cms.PSet( seedingThreshold = cms.double( 0.23 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "ECAL_BARREL" ) - ) +process.hltMuonDTDigis = cms.EDProducer( "DTUnpackingModule", + useStandardFEDid = cms.bool( True ), + maxFEDid = cms.untracked.int32( 779 ), + inputLabel = cms.InputTag( "rawDataRepacker" ), + minFEDid = cms.untracked.int32( 770 ), + dataType = cms.string( "DDU" ), + readOutParameters = cms.PSet( + debug = cms.untracked.bool( False ), + rosParameters = cms.PSet( + writeSC = cms.untracked.bool( True ), + readingDDU = cms.untracked.bool( True ), + performDataIntegrityMonitor = cms.untracked.bool( False ), + readDDUIDfromDDU = cms.untracked.bool( True ), + debug = cms.untracked.bool( False ), + localDAQ = cms.untracked.bool( False ) ), - algoName = cms.string( "LocalMaximumSeedFinder" ) - ), - recHitsSource = cms.InputTag( "hltParticleFlowRecHitECALL1Seeded" ) -) -process.hltParticleFlowClusterECALL1Seeded = cms.EDProducer( "CorrectedECALPFClusterProducer", - inputPS = cms.InputTag( "hltParticleFlowClusterPSL1Seeded" ), - minimumPSEnergy = cms.double( 0.0 ), - energyCorrector = cms.PSet( - applyCrackCorrections = cms.bool( False ), - algoName = cms.string( "PFClusterEMEnergyCorrector" ) - ), - inputECAL = cms.InputTag( "hltParticleFlowClusterECALUncorrectedL1Seeded" ) -) -process.hltParticleFlowSuperClusterECALL1Seeded = cms.EDProducer( "PFECALSuperClusterProducer", - PFSuperClusterCollectionEndcap = cms.string( "hltParticleFlowSuperClusterECALEndcap" ), - doSatelliteClusterMerge = cms.bool( False ), - BeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - PFBasicClusterCollectionBarrel = cms.string( "hltParticleFlowBasicClusterECALBarrel" ), - useRegression = cms.bool( False ), - satelliteMajorityFraction = cms.double( 0.5 ), - thresh_PFClusterEndcap = cms.double( 4.0 ), - ESAssociation = cms.InputTag( "hltParticleFlowClusterECALL1Seeded" ), - PFBasicClusterCollectionPreshower = cms.string( "hltParticleFlowBasicClusterECALPreshower" ), - use_preshower = cms.bool( True ), - thresh_PFClusterBarrel = cms.double( 4.0 ), - thresh_SCEt = cms.double( 4.0 ), - etawidth_SuperClusterEndcap = cms.double( 0.04 ), - phiwidth_SuperClusterEndcap = cms.double( 0.6 ), - verbose = cms.untracked.bool( False ), - useDynamicDPhiWindow = cms.bool( True ), - PFSuperClusterCollectionBarrel = cms.string( "hltParticleFlowSuperClusterECALBarrel" ), - regressionConfig = cms.PSet( - regressionKeyEE = cms.string( "pfscecal_EECorrection_offline" ), - ecalRecHitsEE = cms.InputTag( 'hltRechitInRegionsECAL','EcalRecHitsEE' ), - ecalRecHitsEB = cms.InputTag( 'hltRechitInRegionsECAL','EcalRecHitsEB' ), - regressionKeyEB = cms.string( "pfscecal_EBCorrection_offline" ), - vertexCollection = cms.InputTag( "offlinePrimaryVertices" ) + localDAQ = cms.untracked.bool( False ), + performDataIntegrityMonitor = cms.untracked.bool( False ) ), - applyCrackCorrections = cms.bool( False ), - satelliteClusterSeedThreshold = cms.double( 50.0 ), - etawidth_SuperClusterBarrel = cms.double( 0.04 ), - PFBasicClusterCollectionEndcap = cms.string( "hltParticleFlowBasicClusterECALEndcap" ), - PFClusters = cms.InputTag( "hltParticleFlowClusterECALL1Seeded" ), - thresh_PFClusterSeedBarrel = cms.double( 4.0 ), - ClusteringType = cms.string( "Mustache" ), - EnergyWeight = cms.string( "Raw" ), - thresh_PFClusterSeedEndcap = cms.double( 4.0 ), - phiwidth_SuperClusterBarrel = cms.double( 0.6 ), - thresh_PFClusterES = cms.double( 5.0 ), - seedThresholdIsET = cms.bool( True ), - PFSuperClusterCollectionEndcapWithPreshower = cms.string( "hltParticleFlowSuperClusterECALEndcapWithPreshower" ) -) -process.hltEgammaCandidates = cms.EDProducer( "EgammaHLTRecoEcalCandidateProducers", - scIslandEndcapProducer = cms.InputTag( 'hltParticleFlowSuperClusterECALL1Seeded','hltParticleFlowSuperClusterECALEndcapWithPreshower' ), - scHybridBarrelProducer = cms.InputTag( 'hltParticleFlowSuperClusterECALL1Seeded','hltParticleFlowSuperClusterECALBarrel' ), - recoEcalCandidateCollection = cms.string( "" ) -) -process.hltEGL1SingleIsoEG22erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", - doIsolated = cms.bool( False ), - endcap_end = cms.double( 2.65 ), - saveTags = cms.bool( False ), - region_eta_size_ecap = cms.double( 1.0 ), - barrel_end = cms.double( 1.4791 ), - l1IsolatedTag = cms.InputTag( 'hltL1extraParticles','Isolated' ), - candIsolatedTag = cms.InputTag( "hltEgammaCandidates" ), - region_phi_size = cms.double( 1.044 ), - region_eta_size = cms.double( 0.522 ), - L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG22er" ), - candNonIsolatedTag = cms.InputTag( "" ), - l1NonIsolatedTag = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), - ncandcut = cms.int32( 1 ) -) -process.hltEG27EtL1IsoEG22erFilter = cms.EDFilter( "HLTEgammaEtFilter", - saveTags = cms.bool( False ), - L1NonIsoCand = cms.InputTag( "" ), - relaxed = cms.untracked.bool( False ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - inputTag = cms.InputTag( "hltEGL1SingleIsoEG22erFilter" ), - etcutEB = cms.double( 27.0 ), - etcutEE = cms.double( 27.0 ), - ncandcut = cms.int32( 1 ) -) -process.hltEgammaClusterShape = cms.EDProducer( "EgammaHLTClusterShapeProducer", - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - ecalRechitEB = cms.InputTag( 'hltRechitInRegionsECAL','EcalRecHitsEB' ), - ecalRechitEE = cms.InputTag( 'hltRechitInRegionsECAL','EcalRecHitsEE' ), - isIeta = cms.bool( True ) -) -process.hltEle27WP75ClusterShapeFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( 0.031 ), - thrOverEEE = cms.double( -1.0 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( -1.0 ), - thrRegularEB = cms.double( 0.011 ), - lessThan = cms.bool( True ), - useEt = cms.bool( False ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( 'hltEgammaClusterShape','sigmaIEtaIEta5x5' ), - candTag = cms.InputTag( "hltEG27EtL1IsoEG22erFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltFixedGridRhoFastjetAllCaloForMuons = cms.EDProducer( "FixedGridRhoProducerFastjet", - gridSpacing = cms.double( 0.55 ), - maxRapidity = cms.double( 2.5 ), - pfCandidatesTag = cms.InputTag( "hltTowerMakerForAll" ) -) -process.hltEgammaHoverE = cms.EDProducer( "EgammaHLTBcHcalIsolationProducersRegional", - caloTowerProducer = cms.InputTag( "hltTowerMakerForAll" ), - effectiveAreaBarrel = cms.double( 0.105 ), - outerCone = cms.double( 0.14 ), - innerCone = cms.double( 0.0 ), - useSingleTower = cms.bool( False ), - rhoProducer = cms.InputTag( "hltFixedGridRhoFastjetAllCaloForMuons" ), - depth = cms.int32( -1 ), - doRhoCorrection = cms.bool( False ), - effectiveAreaEndcap = cms.double( 0.17 ), - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - rhoMax = cms.double( 9.9999999E7 ), - etMin = cms.double( 0.0 ), - rhoScale = cms.double( 1.0 ), - doEtSum = cms.bool( False ) -) -process.hltEle27WP75HcEFilter = cms.EDFilter( "HLTEgammaGenericQuadraticFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( 0.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( 0.0 ), - thrRegularEE = cms.double( 13.0 ), - thrOverEEE = cms.double( 0.01 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.01 ), - thrRegularEB = cms.double( 4.0 ), - lessThan = cms.bool( True ), - useEt = cms.bool( False ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaHoverE" ), - candTag = cms.InputTag( "hltEle27WP75ClusterShapeFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltEgammaEcalPFClusterIso = cms.EDProducer( "EgammaHLTEcalPFClusterIsolationProducer", - energyEndcap = cms.double( 0.0 ), - effectiveAreaBarrel = cms.double( 0.149 ), - etaStripBarrel = cms.double( 0.0 ), - rhoProducer = cms.InputTag( "hltFixedGridRhoFastjetAllCaloForMuons" ), - pfClusterProducer = cms.InputTag( "hltParticleFlowClusterECALL1Seeded" ), - etaStripEndcap = cms.double( 0.0 ), - drVetoBarrel = cms.double( 0.0 ), - drMax = cms.double( 0.3 ), - doRhoCorrection = cms.bool( True ), - energyBarrel = cms.double( 0.0 ), - effectiveAreaEndcap = cms.double( 0.097 ), - drVetoEndcap = cms.double( 0.0 ), - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - rhoMax = cms.double( 9.9999999E7 ), - rhoScale = cms.double( 1.0 ) -) -process.hltEle27WP75EcalIsoFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( -1.0 ), - thrOverEEE = cms.double( 0.14 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.21 ), - thrRegularEB = cms.double( -1.0 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaEcalPFClusterIso" ), - candTag = cms.InputTag( "hltEle27WP75HcEFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltRegionalTowerForEgamma = cms.EDProducer( "EgammaHLTCaloTowerProducer", - L1NonIsoCand = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), - EMin = cms.double( 0.8 ), - EtMin = cms.double( 0.5 ), - L1IsoCand = cms.InputTag( 'hltL1extraParticles','Isolated' ), - useTowersInCone = cms.double( 0.8 ), - towerCollection = cms.InputTag( "hltTowerMakerForAll" ) -) -process.hltParticleFlowRecHitHCALForEgamma = cms.EDProducer( "PFCTRecHitProducer", - ECAL_Compensate = cms.bool( False ), - ECAL_Dead_Code = cms.uint32( 10 ), - MinLongTiming_Cut = cms.double( -5.0 ), - ECAL_Compensation = cms.double( 0.5 ), - MaxLongTiming_Cut = cms.double( 5.0 ), - weight_HFhad = cms.double( 1.0 ), - ApplyPulseDPG = cms.bool( False ), - navigator = cms.PSet( name = cms.string( "PFRecHitCaloTowerNavigator" ) ), - ECAL_Threshold = cms.double( 10.0 ), - ApplyTimeDPG = cms.bool( False ), - caloTowers = cms.InputTag( "hltRegionalTowerForEgamma" ), - hcalRecHitsHBHE = cms.InputTag( "hltHbhereco" ), - LongFibre_Fraction = cms.double( 0.1 ), - MaxShortTiming_Cut = cms.double( 5.0 ), - HcalMaxAllowedHFLongShortSev = cms.int32( 9 ), - thresh_Barrel = cms.double( 0.4 ), - navigation_HF = cms.bool( True ), - HcalMaxAllowedHFInTimeWindowSev = cms.int32( 9 ), - HF_Calib_29 = cms.double( 1.07 ), - LongFibre_Cut = cms.double( 120.0 ), - EM_Depth = cms.double( 22.0 ), - weight_HFem = cms.double( 1.0 ), - LongShortFibre_Cut = cms.double( 1.0E9 ), - MinShortTiming_Cut = cms.double( -5.0 ), - HCAL_Calib = cms.bool( True ), - thresh_HF = cms.double( 0.4 ), - HcalMaxAllowedHFDigiTimeSev = cms.int32( 9 ), - thresh_Endcap = cms.double( 0.4 ), - HcalMaxAllowedChannelStatusSev = cms.int32( 9 ), - hcalRecHitsHF = cms.InputTag( "hltHfreco" ), - ShortFibre_Cut = cms.double( 60.0 ), - ApplyLongShortDPG = cms.bool( True ), - HF_Calib = cms.bool( True ), - HAD_Depth = cms.double( 47.0 ), - ShortFibre_Fraction = cms.double( 0.01 ), - HCAL_Calib_29 = cms.double( 1.35 ) -) -process.hltParticleFlowClusterHCALForEgamma = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( 5 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - minFracTot = cms.double( 1.0E-20 ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 10.0 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "HCAL_BARREL1" ), - recHitEnergyNorm = cms.double( 0.8 ) - ), - cms.PSet( detector = cms.string( "HCAL_ENDCAP" ), - recHitEnergyNorm = cms.double( 0.8 ) - ) + dqmOnly = cms.bool( False ) +) +process.hltDt1DRecHits = cms.EDProducer( "DTRecHitProducer", + debug = cms.untracked.bool( False ), + recAlgoConfig = cms.PSet( + tTrigMode = cms.string( "DTTTrigSyncFromDB" ), + minTime = cms.double( -3.0 ), + stepTwoFromDigi = cms.bool( False ), + doVdriftCorr = cms.bool( True ), + debug = cms.untracked.bool( False ), + maxTime = cms.double( 420.0 ), + tTrigModeConfig = cms.PSet( + vPropWire = cms.double( 24.4 ), + doTOFCorrection = cms.bool( True ), + tofCorrType = cms.int32( 0 ), + wirePropCorrType = cms.int32( 0 ), + tTrigLabel = cms.string( "" ), + doWirePropCorrection = cms.bool( True ), + doT0Correction = cms.bool( True ), + debug = cms.untracked.bool( False ) ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ), - allCellsPositionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ) + useUncertDB = cms.bool( True ) ), - positionReCalc = cms.PSet( ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 0.8 ), - detector = cms.string( "HCAL_BARREL1" ), - gatheringThresholdPt = cms.double( 0.0 ) + dtDigiLabel = cms.InputTag( "hltMuonDTDigis" ), + recAlgo = cms.string( "DTLinearDriftFromDBAlgo" ) +) +process.hltDt4DSegments = cms.EDProducer( "DTRecSegment4DProducer", + debug = cms.untracked.bool( False ), + Reco4DAlgoName = cms.string( "DTCombinatorialPatternReco4D" ), + recHits2DLabel = cms.InputTag( "dt2DSegments" ), + recHits1DLabel = cms.InputTag( "hltDt1DRecHits" ), + Reco4DAlgoConfig = cms.PSet( + segmCleanerMode = cms.int32( 2 ), + Reco2DAlgoName = cms.string( "DTCombinatorialPatternReco" ), + recAlgoConfig = cms.PSet( + tTrigMode = cms.string( "DTTTrigSyncFromDB" ), + minTime = cms.double( -3.0 ), + stepTwoFromDigi = cms.bool( False ), + doVdriftCorr = cms.bool( True ), + debug = cms.untracked.bool( False ), + maxTime = cms.double( 420.0 ), + tTrigModeConfig = cms.PSet( + vPropWire = cms.double( 24.4 ), + doTOFCorrection = cms.bool( True ), + tofCorrType = cms.int32( 0 ), + wirePropCorrType = cms.int32( 0 ), + tTrigLabel = cms.string( "" ), + doWirePropCorrection = cms.bool( True ), + doT0Correction = cms.bool( True ), + debug = cms.untracked.bool( False ) ), - cms.PSet( gatheringThreshold = cms.double( 0.8 ), - detector = cms.string( "HCAL_ENDCAP" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) + useUncertDB = cms.bool( True ) ), - useCornerCells = cms.bool( True ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - cms.PSet( algoName = cms.string( "RBXAndHPDCleaner" ) ) - ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 4 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 0.8 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "HCAL_BARREL1" ) + nSharedHitsMax = cms.int32( 2 ), + hit_afterT0_resolution = cms.double( 0.03 ), + Reco2DAlgoConfig = cms.PSet( + segmCleanerMode = cms.int32( 2 ), + recAlgoConfig = cms.PSet( + tTrigMode = cms.string( "DTTTrigSyncFromDB" ), + minTime = cms.double( -3.0 ), + stepTwoFromDigi = cms.bool( False ), + doVdriftCorr = cms.bool( True ), + debug = cms.untracked.bool( False ), + maxTime = cms.double( 420.0 ), + tTrigModeConfig = cms.PSet( + vPropWire = cms.double( 24.4 ), + doTOFCorrection = cms.bool( True ), + tofCorrType = cms.int32( 0 ), + wirePropCorrType = cms.int32( 0 ), + tTrigLabel = cms.string( "" ), + doWirePropCorrection = cms.bool( True ), + doT0Correction = cms.bool( True ), + debug = cms.untracked.bool( False ) + ), + useUncertDB = cms.bool( True ) ), - cms.PSet( seedingThreshold = cms.double( 1.1 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "HCAL_ENDCAP" ) - ) + nSharedHitsMax = cms.int32( 2 ), + AlphaMaxPhi = cms.double( 1.0 ), + hit_afterT0_resolution = cms.double( 0.03 ), + MaxAllowedHits = cms.uint32( 50 ), + performT0_vdriftSegCorrection = cms.bool( False ), + AlphaMaxTheta = cms.double( 0.9 ), + debug = cms.untracked.bool( False ), + recAlgo = cms.string( "DTLinearDriftFromDBAlgo" ), + nUnSharedHitsMin = cms.int32( 2 ), + performT0SegCorrection = cms.bool( False ), + perform_delta_rejecting = cms.bool( False ) ), - algoName = cms.string( "LocalMaximumSeedFinder" ) - ), - recHitsSource = cms.InputTag( "hltParticleFlowRecHitHCALForEgamma" ) -) -process.hltEgammaHcalPFClusterIso = cms.EDProducer( "EgammaHLTHcalPFClusterIsolationProducer", - energyEndcap = cms.double( 0.0 ), - useHF = cms.bool( False ), - effectiveAreaBarrel = cms.double( 0.06 ), - etaStripBarrel = cms.double( 0.0 ), - pfClusterProducerHFHAD = cms.InputTag( "hltParticleFlowClusterHFHADForEgamma" ), - rhoProducer = cms.InputTag( "hltFixedGridRhoFastjetAllCaloForMuons" ), - etaStripEndcap = cms.double( 0.0 ), - drVetoBarrel = cms.double( 0.0 ), - pfClusterProducerHCAL = cms.InputTag( "hltParticleFlowClusterHCALForEgamma" ), - drMax = cms.double( 0.3 ), - doRhoCorrection = cms.bool( True ), - energyBarrel = cms.double( 0.0 ), - effectiveAreaEndcap = cms.double( 0.089 ), - drVetoEndcap = cms.double( 0.0 ), - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - rhoMax = cms.double( 9.9999999E7 ), - pfClusterProducerHFEM = cms.InputTag( "hltParticleFlowClusterHFEMForEgamma" ), - rhoScale = cms.double( 1.0 ) -) -process.hltEle27WP75HcalIsoFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( -1.0 ), - thrOverEEE = cms.double( 0.21 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.11 ), - thrRegularEB = cms.double( -1.0 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaHcalPFClusterIso" ), - candTag = cms.InputTag( "hltEle27WP75EcalIsoFilter" ), - nonIsoTag = cms.InputTag( "" ) + performT0_vdriftSegCorrection = cms.bool( False ), + debug = cms.untracked.bool( False ), + recAlgo = cms.string( "DTLinearDriftFromDBAlgo" ), + nUnSharedHitsMin = cms.int32( 2 ), + AllDTRecHits = cms.bool( True ), + performT0SegCorrection = cms.bool( False ), + perform_delta_rejecting = cms.bool( False ) + ) ) -process.hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", - UseQualityInfo = cms.bool( False ), - UsePilotBlade = cms.bool( False ), - UsePhase1 = cms.bool( False ), - InputLabel = cms.InputTag( "rawDataRepacker" ), - IncludeErrors = cms.bool( False ), - ErrorList = cms.vint32( ), - Regions = cms.PSet( ), - Timing = cms.untracked.bool( False ), - UserErrorList = cms.vint32( ) +process.hltMuonCSCDigis = cms.EDProducer( "CSCDCCUnpacker", + PrintEventNumber = cms.untracked.bool( False ), + SuppressZeroLCT = cms.untracked.bool( True ), + UseExaminer = cms.bool( True ), + Debug = cms.untracked.bool( False ), + ErrorMask = cms.uint32( 0x0 ), + InputObjects = cms.InputTag( "rawDataRepacker" ), + ExaminerMask = cms.uint32( 0x1febf3f6 ), + runDQM = cms.untracked.bool( False ), + UnpackStatusDigis = cms.bool( False ), + VisualFEDInspect = cms.untracked.bool( False ), + FormatedEventDump = cms.untracked.bool( False ), + UseFormatStatus = cms.bool( True ), + UseSelectiveUnpacking = cms.bool( True ), + VisualFEDShort = cms.untracked.bool( False ) ) -process.hltSiPixelClusters = cms.EDProducer( "SiPixelClusterProducer", - src = cms.InputTag( "hltSiPixelDigis" ), - ChannelThreshold = cms.int32( 1000 ), - maxNumberOfClusters = cms.int32( 20000 ), - VCaltoElectronGain = cms.int32( 65 ), - MissCalibrate = cms.untracked.bool( True ), - SplitClusters = cms.bool( False ), - VCaltoElectronOffset = cms.int32( -414 ), - payloadType = cms.string( "HLT" ), - SeedThreshold = cms.int32( 1000 ), - ClusterThreshold = cms.double( 4000.0 ) -) -process.hltSiPixelClustersCache = cms.EDProducer( "SiPixelClusterShapeCacheProducer", - src = cms.InputTag( "hltSiPixelClusters" ), - onDemand = cms.bool( False ) -) -process.hltSiPixelRecHits = cms.EDProducer( "SiPixelRecHitConverter", - VerboseLevel = cms.untracked.int32( 0 ), - src = cms.InputTag( "hltSiPixelClusters" ), - CPE = cms.string( "hltESPPixelCPEGeneric" ) -) -process.hltSiStripExcludedFEDListProducer = cms.EDProducer( "SiStripExcludedFEDListProducer", - ProductLabel = cms.InputTag( "rawDataRepacker" ) -) -process.hltSiStripRawToClustersFacility = cms.EDProducer( "SiStripClusterizerFromRaw", - ProductLabel = cms.InputTag( "rawDataRepacker" ), - DoAPVEmulatorCheck = cms.bool( False ), - Algorithms = cms.PSet( - SiStripFedZeroSuppressionMode = cms.uint32( 4 ), - CommonModeNoiseSubtractionMode = cms.string( "Median" ), - PedestalSubtractionFedMode = cms.bool( True ), - TruncateInSuppressor = cms.bool( True ), - doAPVRestore = cms.bool( False ), - useCMMeanMap = cms.bool( False ) - ), - Clusterizer = cms.PSet( - ChannelThreshold = cms.double( 2.0 ), - MaxSequentialBad = cms.uint32( 1 ), - MaxSequentialHoles = cms.uint32( 0 ), - Algorithm = cms.string( "ThreeThresholdAlgorithm" ), - MaxAdjacentBad = cms.uint32( 0 ), - QualityLabel = cms.string( "" ), - SeedThreshold = cms.double( 3.0 ), - ClusterThreshold = cms.double( 5.0 ), - setDetId = cms.bool( True ), - RemoveApvShots = cms.bool( True ) - ), - onDemand = cms.bool( True ) -) -process.hltSiStripClusters = cms.EDProducer( "MeasurementTrackerEventProducer", - inactivePixelDetectorLabels = cms.VInputTag( ), - stripClusterProducer = cms.string( "hltSiStripRawToClustersFacility" ), - pixelClusterProducer = cms.string( "hltSiPixelClusters" ), - switchOffPixelsIfEmpty = cms.bool( True ), - inactiveStripDetectorLabels = cms.VInputTag( 'hltSiStripExcludedFEDListProducer' ), - skipClusters = cms.InputTag( "" ), - measurementTracker = cms.string( "hltESPMeasurementTracker" ) -) -process.hltMixedLayerPairs = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2', - 'BPix1+BPix3', - 'BPix2+BPix3', - 'BPix1+FPix1_pos', - 'BPix1+FPix1_neg', - 'BPix1+FPix2_pos', - 'BPix1+FPix2_neg', - 'BPix2+FPix1_pos', - 'BPix2+FPix1_neg', - 'BPix2+FPix2_pos', - 'BPix2+FPix2_neg', - 'FPix1_pos+FPix2_pos', - 'FPix1_neg+FPix2_neg', - 'FPix2_pos+TEC1_pos', - 'FPix2_pos+TEC2_pos', - 'TEC1_pos+TEC2_pos', - 'TEC2_pos+TEC3_pos', - 'FPix2_neg+TEC1_neg', - 'FPix2_neg+TEC2_neg', - 'TEC1_neg+TEC2_neg', - 'TEC2_neg+TEC3_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( - useRingSlector = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - minRing = cms.int32( 1 ), - maxRing = cms.int32( 1 ) - ), - MTID = cms.PSet( ), - FPix = cms.PSet( - useErrorsFromParam = cms.bool( True ), - hitErrorRPhi = cms.double( 0.0051 ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - useErrorsFromParam = cms.bool( True ), - hitErrorRPhi = cms.double( 0.0027 ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ) - ), - TIB = cms.PSet( ) -) -process.hltEgammaElectronPixelSeeds = cms.EDProducer( "ElectronSeedProducer", - endcapSuperClusters = cms.InputTag( 'hltParticleFlowSuperClusterECALL1Seeded','hltParticleFlowSuperClusterECALEndcapWithPreshower' ), - SeedConfiguration = cms.PSet( - searchInTIDTEC = cms.bool( True ), - HighPtThreshold = cms.double( 35.0 ), - r2MinF = cms.double( -0.15 ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitPairGenerator" ), - useOnDemandTracker = cms.untracked.int32( 0 ), - SeedingLayers = cms.InputTag( "hltMixedLayerPairs" ) - ), - DeltaPhi1Low = cms.double( 0.23 ), - DeltaPhi1High = cms.double( 0.08 ), - ePhiMin1 = cms.double( -0.08 ), - LowPtThreshold = cms.double( 3.0 ), - RegionPSet = cms.PSet( - deltaPhiRegion = cms.double( 0.4 ), - originHalfLength = cms.double( 15.0 ), - useZInVertex = cms.bool( True ), - deltaEtaRegion = cms.double( 0.1 ), - ptMin = cms.double( 1.5 ), - originRadius = cms.double( 0.2 ), - VertexProducer = cms.InputTag( "dummyVertices" ) - ), - dynamicPhiRoad = cms.bool( False ), - ePhiMax1 = cms.double( 0.04 ), - measurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - SizeWindowENeg = cms.double( 0.675 ), - nSigmasDeltaZ1 = cms.double( 5.0 ), - rMaxI = cms.double( 0.2 ), - preFilteredSeeds = cms.bool( True ), - r2MaxF = cms.double( 0.15 ), - pPhiMin1 = cms.double( -0.04 ), - initialSeeds = cms.InputTag( "noSeedsHere" ), - pPhiMax1 = cms.double( 0.08 ), - SCEtCut = cms.double( 3.0 ), - z2MaxB = cms.double( 0.09 ), - fromTrackerSeeds = cms.bool( True ), - hcalRecHits = cms.InputTag( "hltHbhereco" ), - z2MinB = cms.double( -0.09 ), - rMinI = cms.double( -0.2 ), - hOverEConeSize = cms.double( 0.0 ), - hOverEHBMinE = cms.double( 999999.0 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - applyHOverECut = cms.bool( False ), - hOverEHFMinE = cms.double( 999999.0 ), - measurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - PhiMin2B = cms.double( -0.004 ), - PhiMin2F = cms.double( -0.004 ), - PhiMax2B = cms.double( 0.004 ), - PhiMax2F = cms.double( 0.004 ), - DeltaPhi2B = cms.double( 0.004 ), - DeltaPhi2F = cms.double( 0.004 ) - ), - barrelSuperClusters = cms.InputTag( 'hltParticleFlowSuperClusterECALL1Seeded','hltParticleFlowSuperClusterECALBarrel' ) -) -process.hltEle27WP75PixelMatchFilter = cms.EDFilter( "HLTElectronPixelMatchFilter", - saveTags = cms.bool( False ), - s2_threshold = cms.double( 0.4 ), - npixelmatchcut = cms.double( 1.0 ), - tanhSO10InterThres = cms.double( 1.0 ), - pixelVeto = cms.bool( False ), - doIsolated = cms.bool( True ), - s_a_phi1B = cms.double( 0.0069 ), - s_a_phi1F = cms.double( 0.0076 ), - s_a_phi1I = cms.double( 0.0088 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - candTag = cms.InputTag( "hltEle27WP75HcalIsoFilter" ), - tanhSO10ForwardThres = cms.double( 1.0 ), - L1IsoPixelSeedsTag = cms.InputTag( "hltEgammaElectronPixelSeeds" ), - L1NonIsoCand = cms.InputTag( "" ), - ncandcut = cms.int32( 1 ), - tanhSO10BarrelThres = cms.double( 0.35 ), - s_a_rF = cms.double( 0.04 ), - L1NonIsoPixelSeedsTag = cms.InputTag( "" ), - s_a_rI = cms.double( 0.027 ), - s_a_phi2I = cms.double( 7.0E-4 ), - useS = cms.bool( False ), - s_a_phi2B = cms.double( 3.7E-4 ), - s_a_zB = cms.double( 0.012 ), - s_a_phi2F = cms.double( 0.00906 ) -) -process.hltEgammaCkfTrackCandidatesForGSF = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltEgammaElectronPixelSeeds" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - cleanTrajectoryAfterInOut = cms.bool( True ), - useHitsSplitting = cms.bool( True ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( True ), - maxNSeeds = cms.uint32( 1000000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetTrajectoryBuilderForElectrons" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) -) -process.hltEgammaGsfTracks = cms.EDProducer( "GsfTrackProducer", - src = cms.InputTag( "hltEgammaCkfTrackCandidatesForGSF" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - producer = cms.string( "" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPGsfElectronFittingSmoother" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "hltESPMeasurementTracker" ), - GeometricInnerState = cms.bool( True ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - AlgorithmName = cms.string( "gsf" ), - Propagator = cms.string( "hltESPFwdElectronPropagator" ) -) -process.hltEgammaGsfElectrons = cms.EDProducer( "EgammaHLTPixelMatchElectronProducers", - BSProducer = cms.InputTag( "hltOnlineBeamSpot" ), - UseGsfTracks = cms.bool( True ), - TrackProducer = cms.InputTag( "" ), - GsfTrackProducer = cms.InputTag( "hltEgammaGsfTracks" ) -) -process.hltEgammaGsfTrackVars = cms.EDProducer( "EgammaHLTGsfTrackVarProducer", - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - beamSpotProducer = cms.InputTag( "hltOnlineBeamSpot" ), - upperTrackNrToRemoveCut = cms.int32( 9999 ), - lowerTrackNrToRemoveCut = cms.int32( -1 ), - inputCollection = cms.InputTag( "hltEgammaGsfTracks" ) -) -process.hltEle27WP75GsfOneOEMinusOneOPFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( 0.032 ), - thrOverEEE = cms.double( -1.0 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( -1.0 ), - thrRegularEB = cms.double( 0.032 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( 'hltEgammaGsfTrackVars','OneOESuperMinusOneOP' ), - candTag = cms.InputTag( "hltEle27WP75PixelMatchFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltEle27WP75GsfChi2Filter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( 2.8 ), - thrOverEEE = cms.double( -1.0 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( -1.0 ), - thrRegularEB = cms.double( 3.0 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( 'hltEgammaGsfTrackVars','Chi2' ), - candTag = cms.InputTag( "hltEle27WP75GsfOneOEMinusOneOPFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltEle27WP75GsfDetaFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( 0.0065 ), - thrOverEEE = cms.double( -1.0 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( -1.0 ), - thrRegularEB = cms.double( 0.0035 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( 'hltEgammaGsfTrackVars','Deta' ), - candTag = cms.InputTag( "hltEle27WP75GsfChi2Filter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltEle27WP75GsfDphiFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( 0.035 ), - thrOverEEE = cms.double( -1.0 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( -1.0 ), - thrRegularEB = cms.double( 0.021 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( 'hltEgammaGsfTrackVars','Dphi' ), - candTag = cms.InputTag( "hltEle27WP75GsfDetaFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltElectronsVertex = cms.EDProducer( "VertexFromTrackProducer", - verbose = cms.untracked.bool( False ), - useTriggerFilterElectrons = cms.bool( False ), - beamSpotLabel = cms.InputTag( "hltOnlineBeamSpot" ), - isRecoCandidate = cms.bool( True ), - trackLabel = cms.InputTag( "hltEgammaGsfElectrons" ), - useTriggerFilterMuons = cms.bool( False ), - useBeamSpot = cms.bool( True ), - vertexLabel = cms.InputTag( "None" ), - triggerFilterElectronsSrc = cms.InputTag( "None" ), - triggerFilterMuonsSrc = cms.InputTag( "None" ), - useVertex = cms.bool( False ) -) -process.hltPixelLayerTriplets = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2+BPix3', - 'BPix1+BPix2+FPix1_pos', - 'BPix1+BPix2+FPix1_neg', - 'BPix1+FPix1_pos+FPix2_pos', - 'BPix1+FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - useErrorsFromParam = cms.bool( True ), - hitErrorRPhi = cms.double( 0.0051 ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - useErrorsFromParam = cms.bool( True ), - hitErrorRPhi = cms.double( 0.0027 ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ) - ), - TIB = cms.PSet( ) -) -process.hltPixelTracksElectrons = cms.EDProducer( "PixelTrackProducer", - useFilterWithES = cms.bool( False ), - FilterPSet = cms.PSet( - chi2 = cms.double( 1000.0 ), - nSigmaTipMaxTolerance = cms.double( 0.0 ), - ComponentName = cms.string( "PixelTrackFilterByKinematics" ), - nSigmaInvPtTolerance = cms.double( 0.0 ), - ptMin = cms.double( 0.1 ), - tipMax = cms.double( 1.0 ) - ), - passLabel = cms.string( "Pixel triplet primary tracks with vertex constraint" ), - FitterPSet = cms.PSet( - ComponentName = cms.string( "PixelFitterByHelixProjections" ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - fixImpactParameter = cms.double( 0.0 ) - ), - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "GlobalTrackingRegionWithVerticesProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.2 ), - ptMin = cms.double( 0.9 ), - originHalfLength = cms.double( 0.3 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - useFixedError = cms.bool( True ), - sigmaZVertex = cms.double( 3.0 ), - fixedError = cms.double( 0.2 ), - VertexCollection = cms.InputTag( "hltElectronsVertex" ), - useFoundVertices = cms.bool( True ), - nSigmaZ = cms.double( 4.0 ), - useFakeVertices = cms.bool( True ) - ) - ), - CleanerPSet = cms.PSet( ComponentName = cms.string( "PixelTrackCleanerBySharedHits" ) ), - OrderedHitsFactoryPSet = cms.PSet( - ComponentName = cms.string( "StandardHitTripletGenerator" ), - GeneratorPSet = cms.PSet( - useBending = cms.bool( True ), - useFixedPreFiltering = cms.bool( False ), - maxElement = cms.uint32( 100000 ), - phiPreFiltering = cms.double( 0.3 ), - extraHitRPhitolerance = cms.double( 0.06 ), - useMultScattering = cms.bool( True ), - SeedComparitorPSet = cms.PSet( - ComponentName = cms.string( "LowPtClusterShapeSeedComparitor" ), - clusterShapeCacheSrc = cms.InputTag( "hltSiPixelClustersCache" ) - ), - extraHitRZtolerance = cms.double( 0.06 ), - ComponentName = cms.string( "PixelTripletHLTGenerator" ) - ), - SeedingLayers = cms.InputTag( "hltPixelLayerTriplets" ) - ) -) -process.hltPixelVerticesElectrons = cms.EDProducer( "PixelVertexProducer", - WtAverage = cms.bool( True ), - Method2 = cms.bool( True ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - PVcomparer = cms.PSet( refToPSet_ = cms.string( "HLTPSetPvClusterComparer" ) ), - Verbosity = cms.int32( 0 ), - UseError = cms.bool( True ), - TrackCollection = cms.InputTag( "hltPixelTracksElectrons" ), - PtMin = cms.double( 1.0 ), - NTrkMin = cms.int32( 2 ), - ZOffset = cms.double( 5.0 ), - Finder = cms.string( "DivisiveVertexFinder" ), - ZSeparation = cms.double( 0.05 ) -) -process.hltIter0ElectronsPixelSeedsFromPixelTracks = cms.EDProducer( "SeedGeneratorFromProtoTracksEDProducer", - useEventsWithNoVertex = cms.bool( True ), - originHalfLength = cms.double( 0.3 ), - useProtoTrackKinematics = cms.bool( False ), - usePV = cms.bool( True ), - InputVertexCollection = cms.InputTag( "hltPixelVerticesElectrons" ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - InputCollection = cms.InputTag( "hltPixelTracksElectrons" ), - originRadius = cms.double( 0.1 ) -) -process.hltIter0ElectronsCkfTrackCandidates = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter0ElectronsPixelSeedsFromPixelTracks" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter0PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) -) -process.hltIter0ElectronsCtfWithMaterialTracks = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter0ElectronsCkfTrackCandidates" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -process.hltIter0ElectronsTrackSelectionHighPurity = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.4, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.35, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter0ElectronsCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesElectrons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.4, 4.0 ), - d0_par1 = cms.vdouble( 0.3, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter1ElectronsClustersRefRemoval = cms.EDProducer( "TrackClusterRemover", - minNumberOfLayersWithMeasBeforeFiltering = cms.int32( 0 ), - maxChi2 = cms.double( 9.0 ), - trajectories = cms.InputTag( "hltIter0ElectronsTrackSelectionHighPurity" ), - oldClusterRemovalInfo = cms.InputTag( "" ), - stripClusters = cms.InputTag( "hltSiStripRawToClustersFacility" ), - overrideTrkQuals = cms.InputTag( "" ), - pixelClusters = cms.InputTag( "hltSiPixelClusters" ), - TrackQuality = cms.string( "highPurity" ) -) -process.hltIter1ElectronsMaskedMeasurementTrackerEvent = cms.EDProducer( "MaskedMeasurementTrackerEventProducer", - clustersToSkip = cms.InputTag( "hltIter1ElectronsClustersRefRemoval" ), - OnDemand = cms.bool( False ), - src = cms.InputTag( "hltSiStripClusters" ) -) -process.hltIter1ElectronsPixelLayerTriplets = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2+BPix3', - 'BPix1+BPix2+FPix1_pos', - 'BPix1+BPix2+FPix1_neg', - 'BPix1+FPix1_pos+FPix2_pos', - 'BPix1+FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter1ElectronsClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0051 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter1ElectronsClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0027 ) - ), - TIB = cms.PSet( ) -) -process.hltIter1ElectronsPixelSeeds = cms.EDProducer( "SeedGeneratorFromRegionHitsEDProducer", - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "CandidateSeededTrackingRegionsProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.05 ), - ptMin = cms.double( 0.5 ), - input = cms.InputTag( "hltEgammaCandidates" ), - maxNRegions = cms.int32( 10 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - vertexCollection = cms.InputTag( "hltPixelVerticesElectrons" ), - zErrorBeamSpot = cms.double( 24.2 ), - deltaEta = cms.double( 0.5 ), - deltaPhi = cms.double( 0.5 ), - nSigmaZVertex = cms.double( 3.0 ), - nSigmaZBeamSpot = cms.double( 4.0 ), - mode = cms.string( "VerticesFixed" ), - maxNVertices = cms.int32( 3 ), - zErrorVetex = cms.double( 0.2 ) - ) - ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ), - ClusterCheckPSet = cms.PSet( - PixelClusterCollectionLabel = cms.InputTag( "hltSiPixelClusters" ), - MaxNumberOfCosmicClusters = cms.uint32( 50000 ), - doClusterCheck = cms.bool( False ), - ClusterCollectionLabel = cms.InputTag( "hltSiStripClusters" ), - MaxNumberOfPixelClusters = cms.uint32( 10000 ) - ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitTripletGenerator" ), - GeneratorPSet = cms.PSet( - useBending = cms.bool( True ), - useFixedPreFiltering = cms.bool( False ), - maxElement = cms.uint32( 100000 ), - phiPreFiltering = cms.double( 0.3 ), - extraHitRPhitolerance = cms.double( 0.032 ), - useMultScattering = cms.bool( True ), - ComponentName = cms.string( "PixelTripletHLTGenerator" ), - extraHitRZtolerance = cms.double( 0.037 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) - ), - SeedingLayers = cms.InputTag( "hltIter1ElectronsPixelLayerTriplets" ) - ), - SeedCreatorPSet = cms.PSet( - ComponentName = cms.string( "SeedFromConsecutiveHitsTripletOnlyCreator" ), - propagator = cms.string( "PropagatorWithMaterialParabolicMf" ), - SeedMomentumForBOFF = cms.double( 5.0 ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - TTRHBuilder = cms.string( "(unused)" ) -) -process.hltIter1ElectronsCkfTrackCandidates = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter1ElectronsPixelSeeds" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter1ElectronsMaskedMeasurementTrackerEvent" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter1PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) -) -process.hltIter1ElectronsCtfWithMaterialTracks = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter1ElectronsCkfTrackCandidates" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter1ElectronsMaskedMeasurementTrackerEvent" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -process.hltIter1ElectronsTrackSelectionHighPurityLoose = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.9, 3.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.8, 3.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter1ElectronsCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesElectrons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.9, 3.0 ), - d0_par1 = cms.vdouble( 0.85, 3.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter1ElectronsTrackSelectionHighPurityTight = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 5 ), - chi2n_par = cms.double( 0.4 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 1.0, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 1.0, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter1ElectronsCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesElectrons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 1.0, 4.0 ), - d0_par1 = cms.vdouble( 1.0, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter1ElectronsTrackSelectionHighPurity = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter1ElectronsTrackSelectionHighPurityLoose','hltIter1ElectronsTrackSelectionHighPurityTight' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter1ElectronsTrackSelectionHighPurityLoose','hltIter1ElectronsTrackSelectionHighPurityTight' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltIter1MergedForElectrons = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter0ElectronsTrackSelectionHighPurity','hltIter1ElectronsTrackSelectionHighPurity' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter0ElectronsTrackSelectionHighPurity','hltIter1ElectronsTrackSelectionHighPurity' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltIter2ElectronsClustersRefRemoval = cms.EDProducer( "TrackClusterRemover", - minNumberOfLayersWithMeasBeforeFiltering = cms.int32( 0 ), - maxChi2 = cms.double( 16.0 ), - trajectories = cms.InputTag( "hltIter1ElectronsTrackSelectionHighPurity" ), - oldClusterRemovalInfo = cms.InputTag( "hltIter1ElectronsClustersRefRemoval" ), - stripClusters = cms.InputTag( "hltSiStripRawToClustersFacility" ), - overrideTrkQuals = cms.InputTag( "" ), - pixelClusters = cms.InputTag( "hltSiPixelClusters" ), - TrackQuality = cms.string( "highPurity" ) -) -process.hltIter2ElectronsMaskedMeasurementTrackerEvent = cms.EDProducer( "MaskedMeasurementTrackerEventProducer", - clustersToSkip = cms.InputTag( "hltIter2ElectronsClustersRefRemoval" ), - OnDemand = cms.bool( False ), - src = cms.InputTag( "hltSiStripClusters" ) -) -process.hltIter2ElectronsPixelLayerPairs = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2', - 'BPix1+BPix3', - 'BPix2+BPix3', - 'BPix1+FPix1_pos', - 'BPix1+FPix1_neg', - 'BPix1+FPix2_pos', - 'BPix1+FPix2_neg', - 'BPix2+FPix1_pos', - 'BPix2+FPix1_neg', - 'BPix2+FPix2_pos', - 'BPix2+FPix2_neg', - 'FPix1_pos+FPix2_pos', - 'FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter2ElectronsClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0051 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter2ElectronsClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0027 ) - ), - TIB = cms.PSet( ) -) -process.hltIter2ElectronsPixelSeeds = cms.EDProducer( "SeedGeneratorFromRegionHitsEDProducer", - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "CandidateSeededTrackingRegionsProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.05 ), - ptMin = cms.double( 1.2 ), - deltaEta = cms.double( 0.5 ), - deltaPhi = cms.double( 0.5 ), - vertexCollection = cms.InputTag( "hltPixelVerticesElectrons" ), - input = cms.InputTag( "hltEgammaCandidates" ), - mode = cms.string( "VerticesFixed" ), - maxNRegions = cms.int32( 10 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - maxNVertices = cms.int32( 3 ), - zErrorBeamSpot = cms.double( 24.2 ), - nSigmaZVertex = cms.double( 3.0 ), - nSigmaZBeamSpot = cms.double( 4.0 ), - zErrorVetex = cms.double( 0.2 ) - ) - ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ), - ClusterCheckPSet = cms.PSet( - PixelClusterCollectionLabel = cms.InputTag( "hltSiPixelClusters" ), - MaxNumberOfCosmicClusters = cms.uint32( 50000 ), - doClusterCheck = cms.bool( False ), - ClusterCollectionLabel = cms.InputTag( "hltSiStripClusters" ), - MaxNumberOfPixelClusters = cms.uint32( 10000 ) - ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitPairGenerator" ), - GeneratorPSet = cms.PSet( - maxElement = cms.uint32( 100000 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) - ), - SeedingLayers = cms.InputTag( "hltIter2ElectronsPixelLayerPairs" ) - ), - SeedCreatorPSet = cms.PSet( - ComponentName = cms.string( "SeedFromConsecutiveHitsCreator" ), - propagator = cms.string( "PropagatorWithMaterialParabolicMf" ), - SeedMomentumForBOFF = cms.double( 5.0 ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - TTRHBuilder = cms.string( "(unused)" ) -) -process.hltIter2ElectronsCkfTrackCandidates = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter2ElectronsPixelSeeds" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter2ElectronsMaskedMeasurementTrackerEvent" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter2PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) -) -process.hltIter2ElectronsCtfWithMaterialTracks = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter2ElectronsCkfTrackCandidates" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter2ElectronsMaskedMeasurementTrackerEvent" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -process.hltIter2ElectronsTrackSelectionHighPurity = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.4, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.35, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter2ElectronsCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesElectrons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.4, 4.0 ), - d0_par1 = cms.vdouble( 0.3, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter2MergedForElectrons = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter1MergedForElectrons','hltIter2ElectronsTrackSelectionHighPurity' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter1MergedForElectrons','hltIter2ElectronsTrackSelectionHighPurity' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltEgammaEleGsfTrackIso = cms.EDProducer( "EgammaHLTElectronTrackIsolationProducers", - egTrkIsoStripEndcap = cms.double( 0.03 ), - egTrkIsoVetoConeSizeBarrel = cms.double( 0.03 ), - useGsfTrack = cms.bool( True ), - useSCRefs = cms.bool( True ), - trackProducer = cms.InputTag( "hltIter2MergedForElectrons" ), - egTrkIsoStripBarrel = cms.double( 0.03 ), - electronProducer = cms.InputTag( "hltEgammaGsfElectrons" ), - egTrkIsoConeSize = cms.double( 0.3 ), - egTrkIsoRSpan = cms.double( 999999.0 ), - egTrkIsoVetoConeSizeEndcap = cms.double( 0.03 ), - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - beamSpotProducer = cms.InputTag( "hltOnlineBeamSpot" ), - egTrkIsoPtMin = cms.double( 1.0 ), - egTrkIsoZSpan = cms.double( 0.15 ) -) -process.hltEle27WP75GsfTrackIsoFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( True ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( -1.0 ), - thrOverEEE = cms.double( 0.05 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.05 ), - thrRegularEB = cms.double( -1.0 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaEleGsfTrackIso" ), - candTag = cms.InputTag( "hltEle27WP75GsfDphiFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltL1sL1SingleMu16ORSingleMu25 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleMu16 OR L1_SingleMu25" ), - saveTags = cms.bool( True ), - L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), - L1UseL1TriggerObjectMaps = cms.bool( True ), - L1UseAliasesForSeeding = cms.bool( True ), - L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), - L1CollectionsTag = cms.InputTag( "hltL1extraParticles" ), - L1NrBxInEvent = cms.int32( 3 ), - L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), - L1TechTriggerSeeding = cms.bool( False ) -) -process.hltPreMu50 = cms.EDFilter( "HLTPrescaler", - L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), - offset = cms.uint32( 0 ) -) -process.hltL1fL1sMu16orMu25L1Filtered0 = cms.EDFilter( "HLTMuonL1Filter", - saveTags = cms.bool( False ), - CSCTFtag = cms.InputTag( "unused" ), - PreviousCandTag = cms.InputTag( "hltL1sL1SingleMu16ORSingleMu25" ), - MinPt = cms.double( 0.0 ), - MinN = cms.int32( 1 ), - MaxEta = cms.double( 2.5 ), - SelectQualities = cms.vint32( ), - CandTag = cms.InputTag( "hltL1extraParticles" ), - ExcludeSingleSegmentCSC = cms.bool( False ) -) -process.hltMuonDTDigis = cms.EDProducer( "DTUnpackingModule", - useStandardFEDid = cms.bool( True ), - maxFEDid = cms.untracked.int32( 779 ), - inputLabel = cms.InputTag( "rawDataRepacker" ), - minFEDid = cms.untracked.int32( 770 ), - dataType = cms.string( "DDU" ), - readOutParameters = cms.PSet( - debug = cms.untracked.bool( False ), - rosParameters = cms.PSet( - writeSC = cms.untracked.bool( True ), - readingDDU = cms.untracked.bool( True ), - performDataIntegrityMonitor = cms.untracked.bool( False ), - readDDUIDfromDDU = cms.untracked.bool( True ), - debug = cms.untracked.bool( False ), - localDAQ = cms.untracked.bool( False ) - ), - localDAQ = cms.untracked.bool( False ), - performDataIntegrityMonitor = cms.untracked.bool( False ) - ), - dqmOnly = cms.bool( False ) -) -process.hltDt1DRecHits = cms.EDProducer( "DTRecHitProducer", - debug = cms.untracked.bool( False ), - recAlgoConfig = cms.PSet( - tTrigMode = cms.string( "DTTTrigSyncFromDB" ), - minTime = cms.double( -3.0 ), - stepTwoFromDigi = cms.bool( False ), - doVdriftCorr = cms.bool( True ), - debug = cms.untracked.bool( False ), - maxTime = cms.double( 420.0 ), - tTrigModeConfig = cms.PSet( - vPropWire = cms.double( 24.4 ), - doTOFCorrection = cms.bool( True ), - tofCorrType = cms.int32( 0 ), - wirePropCorrType = cms.int32( 0 ), - tTrigLabel = cms.string( "" ), - doWirePropCorrection = cms.bool( True ), - doT0Correction = cms.bool( True ), - debug = cms.untracked.bool( False ) - ), - useUncertDB = cms.bool( True ) - ), - dtDigiLabel = cms.InputTag( "hltMuonDTDigis" ), - recAlgo = cms.string( "DTLinearDriftFromDBAlgo" ) -) -process.hltDt4DSegments = cms.EDProducer( "DTRecSegment4DProducer", - debug = cms.untracked.bool( False ), - Reco4DAlgoName = cms.string( "DTCombinatorialPatternReco4D" ), - recHits2DLabel = cms.InputTag( "dt2DSegments" ), - recHits1DLabel = cms.InputTag( "hltDt1DRecHits" ), - Reco4DAlgoConfig = cms.PSet( - segmCleanerMode = cms.int32( 2 ), - Reco2DAlgoName = cms.string( "DTCombinatorialPatternReco" ), - recAlgoConfig = cms.PSet( - tTrigMode = cms.string( "DTTTrigSyncFromDB" ), - minTime = cms.double( -3.0 ), - stepTwoFromDigi = cms.bool( False ), - doVdriftCorr = cms.bool( True ), - debug = cms.untracked.bool( False ), - maxTime = cms.double( 420.0 ), - tTrigModeConfig = cms.PSet( - vPropWire = cms.double( 24.4 ), - doTOFCorrection = cms.bool( True ), - tofCorrType = cms.int32( 0 ), - wirePropCorrType = cms.int32( 0 ), - tTrigLabel = cms.string( "" ), - doWirePropCorrection = cms.bool( True ), - doT0Correction = cms.bool( True ), - debug = cms.untracked.bool( False ) - ), - useUncertDB = cms.bool( True ) - ), - nSharedHitsMax = cms.int32( 2 ), - hit_afterT0_resolution = cms.double( 0.03 ), - Reco2DAlgoConfig = cms.PSet( - segmCleanerMode = cms.int32( 2 ), - recAlgoConfig = cms.PSet( - tTrigMode = cms.string( "DTTTrigSyncFromDB" ), - minTime = cms.double( -3.0 ), - stepTwoFromDigi = cms.bool( False ), - doVdriftCorr = cms.bool( True ), - debug = cms.untracked.bool( False ), - maxTime = cms.double( 420.0 ), - tTrigModeConfig = cms.PSet( - vPropWire = cms.double( 24.4 ), - doTOFCorrection = cms.bool( True ), - tofCorrType = cms.int32( 0 ), - wirePropCorrType = cms.int32( 0 ), - tTrigLabel = cms.string( "" ), - doWirePropCorrection = cms.bool( True ), - doT0Correction = cms.bool( True ), - debug = cms.untracked.bool( False ) - ), - useUncertDB = cms.bool( True ) - ), - nSharedHitsMax = cms.int32( 2 ), - AlphaMaxPhi = cms.double( 1.0 ), - hit_afterT0_resolution = cms.double( 0.03 ), - MaxAllowedHits = cms.uint32( 50 ), - performT0_vdriftSegCorrection = cms.bool( False ), - AlphaMaxTheta = cms.double( 0.9 ), - debug = cms.untracked.bool( False ), - recAlgo = cms.string( "DTLinearDriftFromDBAlgo" ), - nUnSharedHitsMin = cms.int32( 2 ), - performT0SegCorrection = cms.bool( False ), - perform_delta_rejecting = cms.bool( False ) - ), - performT0_vdriftSegCorrection = cms.bool( False ), - debug = cms.untracked.bool( False ), - recAlgo = cms.string( "DTLinearDriftFromDBAlgo" ), - nUnSharedHitsMin = cms.int32( 2 ), - AllDTRecHits = cms.bool( True ), - performT0SegCorrection = cms.bool( False ), - perform_delta_rejecting = cms.bool( False ) - ) -) -process.hltMuonCSCDigis = cms.EDProducer( "CSCDCCUnpacker", - PrintEventNumber = cms.untracked.bool( False ), - SuppressZeroLCT = cms.untracked.bool( True ), - UseExaminer = cms.bool( True ), - Debug = cms.untracked.bool( False ), - ErrorMask = cms.uint32( 0x0 ), - InputObjects = cms.InputTag( "rawDataRepacker" ), - ExaminerMask = cms.uint32( 0x1febf3f6 ), - runDQM = cms.untracked.bool( False ), - UnpackStatusDigis = cms.bool( False ), - VisualFEDInspect = cms.untracked.bool( False ), - FormatedEventDump = cms.untracked.bool( False ), - UseFormatStatus = cms.bool( True ), - UseSelectiveUnpacking = cms.bool( True ), - VisualFEDShort = cms.untracked.bool( False ) -) -process.hltCsc2DRecHits = cms.EDProducer( "CSCRecHitDProducer", - XTasymmetry_ME1b = cms.double( 0.0 ), - XTasymmetry_ME1a = cms.double( 0.0 ), - ConstSyst_ME1a = cms.double( 0.022 ), - ConstSyst_ME1b = cms.double( 0.007 ), - XTasymmetry_ME41 = cms.double( 0.0 ), - CSCStripxtalksOffset = cms.double( 0.03 ), - CSCUseCalibrations = cms.bool( True ), - CSCUseTimingCorrections = cms.bool( True ), - CSCNoOfTimeBinsForDynamicPedestal = cms.int32( 2 ), - XTasymmetry_ME22 = cms.double( 0.0 ), - UseFivePoleFit = cms.bool( True ), - XTasymmetry_ME21 = cms.double( 0.0 ), - ConstSyst_ME21 = cms.double( 0.0 ), - CSCDebug = cms.untracked.bool( False ), - ConstSyst_ME22 = cms.double( 0.0 ), - CSCUseGasGainCorrections = cms.bool( False ), - XTasymmetry_ME31 = cms.double( 0.0 ), - readBadChambers = cms.bool( True ), - NoiseLevel_ME13 = cms.double( 8.0 ), - NoiseLevel_ME12 = cms.double( 9.0 ), - NoiseLevel_ME32 = cms.double( 9.0 ), - NoiseLevel_ME31 = cms.double( 9.0 ), - XTasymmetry_ME32 = cms.double( 0.0 ), - ConstSyst_ME41 = cms.double( 0.0 ), - CSCStripClusterSize = cms.untracked.int32( 3 ), - CSCStripClusterChargeCut = cms.double( 25.0 ), - CSCStripPeakThreshold = cms.double( 10.0 ), - readBadChannels = cms.bool( False ), - UseParabolaFit = cms.bool( False ), - XTasymmetry_ME13 = cms.double( 0.0 ), - XTasymmetry_ME12 = cms.double( 0.0 ), - wireDigiTag = cms.InputTag( 'hltMuonCSCDigis','MuonCSCWireDigi' ), - ConstSyst_ME12 = cms.double( 0.0 ), - ConstSyst_ME13 = cms.double( 0.0 ), - ConstSyst_ME32 = cms.double( 0.0 ), - ConstSyst_ME31 = cms.double( 0.0 ), - UseAverageTime = cms.bool( False ), - NoiseLevel_ME1a = cms.double( 7.0 ), - NoiseLevel_ME1b = cms.double( 8.0 ), - CSCWireClusterDeltaT = cms.int32( 1 ), - CSCUseStaticPedestals = cms.bool( False ), - stripDigiTag = cms.InputTag( 'hltMuonCSCDigis','MuonCSCStripDigi' ), - CSCstripWireDeltaTime = cms.int32( 8 ), - NoiseLevel_ME21 = cms.double( 9.0 ), - NoiseLevel_ME22 = cms.double( 9.0 ), - NoiseLevel_ME41 = cms.double( 9.0 ) -) -process.hltCscSegments = cms.EDProducer( "CSCSegmentProducer", - inputObjects = cms.InputTag( "hltCsc2DRecHits" ), - algo_psets = cms.VPSet( - cms.PSet( chamber_types = cms.vstring( 'ME1/a', - 'ME1/b', - 'ME1/2', - 'ME1/3', - 'ME2/1', - 'ME2/2', - 'ME3/1', - 'ME3/2', - 'ME4/1', - 'ME4/2' ), - algo_name = cms.string( "CSCSegAlgoST" ), - parameters_per_chamber_type = cms.vint32( 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 ), - algo_psets = cms.VPSet( - cms.PSet( maxRatioResidualPrune = cms.double( 3.0 ), - yweightPenalty = cms.double( 1.5 ), - maxRecHitsInCluster = cms.int32( 20 ), - dPhiFineMax = cms.double( 0.025 ), - preClusteringUseChaining = cms.bool( True ), - ForceCovariance = cms.bool( False ), - hitDropLimit6Hits = cms.double( 0.3333 ), - NormChi2Cut2D = cms.double( 20.0 ), - BPMinImprovement = cms.double( 10000.0 ), - Covariance = cms.double( 0.0 ), - tanPhiMax = cms.double( 0.5 ), - SeedBig = cms.double( 0.0015 ), - onlyBestSegment = cms.bool( False ), - dRPhiFineMax = cms.double( 8.0 ), - SeedSmall = cms.double( 2.0E-4 ), - curvePenalty = cms.double( 2.0 ), - dXclusBoxMax = cms.double( 4.0 ), - BrutePruning = cms.bool( True ), - curvePenaltyThreshold = cms.double( 0.85 ), - CorrectTheErrors = cms.bool( True ), - hitDropLimit4Hits = cms.double( 0.6 ), - useShowering = cms.bool( False ), - CSCDebug = cms.untracked.bool( False ), - tanThetaMax = cms.double( 1.2 ), - NormChi2Cut3D = cms.double( 10.0 ), - minHitsPerSegment = cms.int32( 3 ), - ForceCovarianceAll = cms.bool( False ), - yweightPenaltyThreshold = cms.double( 1.0 ), - prePrunLimit = cms.double( 3.17 ), - hitDropLimit5Hits = cms.double( 0.8 ), - preClustering = cms.bool( True ), - prePrun = cms.bool( True ), - maxDPhi = cms.double( 999.0 ), - maxDTheta = cms.double( 999.0 ), - Pruning = cms.bool( True ), - dYclusBoxMax = cms.double( 8.0 ) - ), - cms.PSet( maxRatioResidualPrune = cms.double( 3.0 ), - yweightPenalty = cms.double( 1.5 ), - maxRecHitsInCluster = cms.int32( 24 ), - dPhiFineMax = cms.double( 0.025 ), - preClusteringUseChaining = cms.bool( True ), - ForceCovariance = cms.bool( False ), - hitDropLimit6Hits = cms.double( 0.3333 ), - NormChi2Cut2D = cms.double( 20.0 ), - BPMinImprovement = cms.double( 10000.0 ), - Covariance = cms.double( 0.0 ), - tanPhiMax = cms.double( 0.5 ), - SeedBig = cms.double( 0.0015 ), - onlyBestSegment = cms.bool( False ), - dRPhiFineMax = cms.double( 8.0 ), - SeedSmall = cms.double( 2.0E-4 ), - curvePenalty = cms.double( 2.0 ), - dXclusBoxMax = cms.double( 4.0 ), - BrutePruning = cms.bool( True ), - curvePenaltyThreshold = cms.double( 0.85 ), - CorrectTheErrors = cms.bool( True ), - hitDropLimit4Hits = cms.double( 0.6 ), - useShowering = cms.bool( False ), - CSCDebug = cms.untracked.bool( False ), - tanThetaMax = cms.double( 1.2 ), - NormChi2Cut3D = cms.double( 10.0 ), - minHitsPerSegment = cms.int32( 3 ), - ForceCovarianceAll = cms.bool( False ), - yweightPenaltyThreshold = cms.double( 1.0 ), - prePrunLimit = cms.double( 3.17 ), - hitDropLimit5Hits = cms.double( 0.8 ), - preClustering = cms.bool( True ), - prePrun = cms.bool( True ), - maxDPhi = cms.double( 999.0 ), - maxDTheta = cms.double( 999.0 ), - Pruning = cms.bool( True ), - dYclusBoxMax = cms.double( 8.0 ) - ) - ) - ) - ), - algo_type = cms.int32( 1 ) -) -process.hltMuonRPCDigis = cms.EDProducer( "RPCUnpackingModule", - InputLabel = cms.InputTag( "rawDataRepacker" ), - doSynchro = cms.bool( False ) -) -process.hltRpcRecHits = cms.EDProducer( "RPCRecHitProducer", - recAlgoConfig = cms.PSet( ), - deadvecfile = cms.FileInPath( "RecoLocalMuon/RPCRecHit/data/RPCDeadVec.dat" ), - rpcDigiLabel = cms.InputTag( "hltMuonRPCDigis" ), - maskvecfile = cms.FileInPath( "RecoLocalMuon/RPCRecHit/data/RPCMaskVec.dat" ), - recAlgo = cms.string( "RPCRecHitStandardAlgo" ), - deadSource = cms.string( "File" ), - maskSource = cms.string( "File" ) -) -process.hltL2OfflineMuonSeeds = cms.EDProducer( "MuonSeedGenerator", - SMB_21 = cms.vdouble( 1.043, -0.124, 0.0, 0.183, 0.0, 0.0 ), - SMB_20 = cms.vdouble( 1.011, -0.052, 0.0, 0.188, 0.0, 0.0 ), - SMB_22 = cms.vdouble( 1.474, -0.758, 0.0, 0.185, 0.0, 0.0 ), - OL_2213 = cms.vdouble( 0.117, 0.0, 0.0, 0.044, 0.0, 0.0 ), - SME_11 = cms.vdouble( 3.295, -1.527, 0.112, 0.378, 0.02, 0.0 ), - SME_13 = cms.vdouble( -1.286, 1.711, 0.0, 0.356, 0.0, 0.0 ), - SME_12 = cms.vdouble( 0.102, 0.599, 0.0, 0.38, 0.0, 0.0 ), - DT_34_2_scale = cms.vdouble( -11.901897, 0.0 ), - OL_1213_0_scale = cms.vdouble( -4.488158, 0.0 ), - OL_1222_0_scale = cms.vdouble( -5.810449, 0.0 ), - DT_13 = cms.vdouble( 0.315, 0.068, -0.127, 0.051, -0.002, 0.0 ), - DT_12 = cms.vdouble( 0.183, 0.054, -0.087, 0.028, 0.002, 0.0 ), - DT_14 = cms.vdouble( 0.359, 0.052, -0.107, 0.072, -0.004, 0.0 ), - CSC_13_3_scale = cms.vdouble( -1.701268, 0.0 ), - DT_24_2_scale = cms.vdouble( -6.63094, 0.0 ), - CSC_23 = cms.vdouble( -0.081, 0.113, -0.029, 0.015, 0.008, 0.0 ), - CSC_24 = cms.vdouble( 0.004, 0.021, -0.002, 0.053, 0.0, 0.0 ), - OL_2222 = cms.vdouble( 0.107, 0.0, 0.0, 0.04, 0.0, 0.0 ), - DT_14_2_scale = cms.vdouble( -4.808546, 0.0 ), - SMB_10 = cms.vdouble( 1.387, -0.038, 0.0, 0.19, 0.0, 0.0 ), - SMB_11 = cms.vdouble( 1.247, 0.72, -0.802, 0.229, -0.075, 0.0 ), - SMB_12 = cms.vdouble( 2.128, -0.956, 0.0, 0.199, 0.0, 0.0 ), - SME_21 = cms.vdouble( -0.529, 1.194, -0.358, 0.472, 0.086, 0.0 ), - SME_22 = cms.vdouble( -1.207, 1.491, -0.251, 0.189, 0.243, 0.0 ), - DT_13_2_scale = cms.vdouble( -4.257687, 0.0 ), - CSC_34 = cms.vdouble( 0.062, -0.067, 0.019, 0.021, 0.003, 0.0 ), - SME_22_0_scale = cms.vdouble( -3.457901, 0.0 ), - DT_24_1_scale = cms.vdouble( -7.490909, 0.0 ), - OL_1232_0_scale = cms.vdouble( -5.964634, 0.0 ), - DT_23_1_scale = cms.vdouble( -5.320346, 0.0 ), - SME_13_0_scale = cms.vdouble( 0.104905, 0.0 ), - SMB_22_0_scale = cms.vdouble( 1.346681, 0.0 ), - CSC_12_1_scale = cms.vdouble( -6.434242, 0.0 ), - DT_34 = cms.vdouble( 0.044, 0.004, -0.013, 0.029, 0.003, 0.0 ), - SME_32 = cms.vdouble( -0.901, 1.333, -0.47, 0.41, 0.073, 0.0 ), - SME_31 = cms.vdouble( -1.594, 1.482, -0.317, 0.487, 0.097, 0.0 ), - CSC_13_2_scale = cms.vdouble( -6.077936, 0.0 ), - crackEtas = cms.vdouble( 0.2, 1.6, 1.7 ), - SME_11_0_scale = cms.vdouble( 1.325085, 0.0 ), - SMB_20_0_scale = cms.vdouble( 1.486168, 0.0 ), - DT_13_1_scale = cms.vdouble( -4.520923, 0.0 ), - CSC_24_1_scale = cms.vdouble( -6.055701, 0.0 ), - CSC_01_1_scale = cms.vdouble( -1.915329, 0.0 ), - DT_23 = cms.vdouble( 0.13, 0.023, -0.057, 0.028, 0.004, 0.0 ), - DT_24 = cms.vdouble( 0.176, 0.014, -0.051, 0.051, 0.003, 0.0 ), - SMB_12_0_scale = cms.vdouble( 2.283221, 0.0 ), - deltaPhiSearchWindow = cms.double( 0.25 ), - SMB_30_0_scale = cms.vdouble( -3.629838, 0.0 ), - SME_42 = cms.vdouble( -0.003, 0.005, 0.005, 0.608, 0.076, 0.0 ), - SME_41 = cms.vdouble( -0.003, 0.005, 0.005, 0.608, 0.076, 0.0 ), - deltaEtaSearchWindow = cms.double( 0.2 ), - CSC_12_2_scale = cms.vdouble( -1.63622, 0.0 ), - DT_34_1_scale = cms.vdouble( -13.783765, 0.0 ), - CSC_34_1_scale = cms.vdouble( -11.520507, 0.0 ), - OL_2213_0_scale = cms.vdouble( -7.239789, 0.0 ), - SMB_32_0_scale = cms.vdouble( -3.054156, 0.0 ), - CSC_12_3_scale = cms.vdouble( -1.63622, 0.0 ), - deltaEtaCrackSearchWindow = cms.double( 0.25 ), - SME_21_0_scale = cms.vdouble( -0.040862, 0.0 ), - OL_1232 = cms.vdouble( 0.184, 0.0, 0.0, 0.066, 0.0, 0.0 ), - DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), - SMB_10_0_scale = cms.vdouble( 2.448566, 0.0 ), - EnableDTMeasurement = cms.bool( True ), - CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), - CSC_23_2_scale = cms.vdouble( -6.079917, 0.0 ), - scaleDT = cms.bool( True ), - DT_12_2_scale = cms.vdouble( -3.518165, 0.0 ), - OL_1222 = cms.vdouble( 0.848, -0.591, 0.0, 0.062, 0.0, 0.0 ), - CSC_23_1_scale = cms.vdouble( -19.084285, 0.0 ), - OL_1213 = cms.vdouble( 0.96, -0.737, 0.0, 0.052, 0.0, 0.0 ), - CSC_02 = cms.vdouble( 0.612, -0.207, 0.0, 0.067, -0.001, 0.0 ), - CSC_03 = cms.vdouble( 0.787, -0.338, 0.029, 0.101, -0.008, 0.0 ), - CSC_01 = cms.vdouble( 0.166, 0.0, 0.0, 0.031, 0.0, 0.0 ), - SMB_32 = cms.vdouble( 0.67, -0.327, 0.0, 0.22, 0.0, 0.0 ), - SMB_30 = cms.vdouble( 0.505, -0.022, 0.0, 0.215, 0.0, 0.0 ), - SMB_31 = cms.vdouble( 0.549, -0.145, 0.0, 0.207, 0.0, 0.0 ), - crackWindow = cms.double( 0.04 ), - CSC_14_3_scale = cms.vdouble( -1.969563, 0.0 ), - SMB_31_0_scale = cms.vdouble( -3.323768, 0.0 ), - DT_12_1_scale = cms.vdouble( -3.692398, 0.0 ), - SMB_21_0_scale = cms.vdouble( 1.58384, 0.0 ), - DT_23_2_scale = cms.vdouble( -5.117625, 0.0 ), - SME_12_0_scale = cms.vdouble( 2.279181, 0.0 ), - DT_14_1_scale = cms.vdouble( -5.644816, 0.0 ), - beamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), - SMB_11_0_scale = cms.vdouble( 2.56363, 0.0 ), - EnableCSCMeasurement = cms.bool( True ), - CSC_14 = cms.vdouble( 0.606, -0.181, -0.002, 0.111, -0.003, 0.0 ), - OL_2222_0_scale = cms.vdouble( -7.667231, 0.0 ), - CSC_13 = cms.vdouble( 0.901, -1.302, 0.533, 0.045, 0.005, 0.0 ), - CSC_12 = cms.vdouble( -0.161, 0.254, -0.047, 0.042, -0.007, 0.0 ) -) -process.hltL2MuonSeeds = cms.EDProducer( "L2MuonSeedGenerator", - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'SteppingHelixPropagatorAny' ), - RPCLayers = cms.bool( True ), - UseMuonNavigation = cms.untracked.bool( True ) - ), - InputObjects = cms.InputTag( "hltL1extraParticles" ), - L1MaxEta = cms.double( 2.5 ), - OfflineSeedLabel = cms.untracked.InputTag( "hltL2OfflineMuonSeeds" ), - L1MinPt = cms.double( 0.0 ), - L1MinQuality = cms.uint32( 1 ), - GMTReadoutCollection = cms.InputTag( "hltGtDigis" ), - UseUnassociatedL1 = cms.bool( False ), - UseOfflineSeed = cms.untracked.bool( True ), - Propagator = cms.string( "SteppingHelixPropagatorAny" ) -) -process.hltL2Muons = cms.EDProducer( "L2MuonProducer", - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPFastSteppingHelixPropagatorAny', - 'hltESPFastSteppingHelixPropagatorOpposite' ), - RPCLayers = cms.bool( True ), - UseMuonNavigation = cms.untracked.bool( True ) - ), - InputObjects = cms.InputTag( "hltL2MuonSeeds" ), - SeedTransformerParameters = cms.PSet( - Fitter = cms.string( "hltESPKFFittingSmootherForL2Muon" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - NMinRecHits = cms.uint32( 2 ), - UseSubRecHits = cms.bool( False ), - Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - RescaleError = cms.double( 100.0 ) - ), - L2TrajBuilderParameters = cms.PSet( - DoRefit = cms.bool( False ), - SeedPropagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - FilterParameters = cms.PSet( - NumberOfSigma = cms.double( 3.0 ), - FitDirection = cms.string( "insideOut" ), - DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), - MaxChi2 = cms.double( 1000.0 ), - MuonTrajectoryUpdatorParameters = cms.PSet( - MaxChi2 = cms.double( 25.0 ), - RescaleErrorFactor = cms.double( 100.0 ), - Granularity = cms.int32( 0 ), - ExcludeRPCFromFit = cms.bool( False ), - UseInvalidHits = cms.bool( True ), - RescaleError = cms.bool( False ) - ), - EnableRPCMeasurement = cms.bool( True ), - CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), - EnableDTMeasurement = cms.bool( True ), - RPCRecSegmentLabel = cms.InputTag( "hltRpcRecHits" ), - Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - EnableCSCMeasurement = cms.bool( True ) - ), - NavigationType = cms.string( "Standard" ), - SeedTransformerParameters = cms.PSet( - Fitter = cms.string( "hltESPKFFittingSmootherForL2Muon" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - NMinRecHits = cms.uint32( 2 ), - UseSubRecHits = cms.bool( False ), - Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - RescaleError = cms.double( 100.0 ) - ), - DoBackwardFilter = cms.bool( True ), - SeedPosition = cms.string( "in" ), - BWFilterParameters = cms.PSet( - NumberOfSigma = cms.double( 3.0 ), - CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), - FitDirection = cms.string( "outsideIn" ), - DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), - MaxChi2 = cms.double( 100.0 ), - MuonTrajectoryUpdatorParameters = cms.PSet( - MaxChi2 = cms.double( 25.0 ), - RescaleErrorFactor = cms.double( 100.0 ), - Granularity = cms.int32( 0 ), - ExcludeRPCFromFit = cms.bool( False ), - UseInvalidHits = cms.bool( True ), - RescaleError = cms.bool( False ) - ), - EnableRPCMeasurement = cms.bool( True ), - BWSeedType = cms.string( "fromGenerator" ), - EnableDTMeasurement = cms.bool( True ), - RPCRecSegmentLabel = cms.InputTag( "hltRpcRecHits" ), - Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - EnableCSCMeasurement = cms.bool( True ) - ), - DoSeedRefit = cms.bool( False ) - ), - DoSeedRefit = cms.bool( False ), - TrackLoaderParameters = cms.PSet( - Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), - DoSmoothing = cms.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MuonUpdatorAtVertexParameters = cms.PSet( - MaxChi2 = cms.double( 1000000.0 ), - BeamSpotPosition = cms.vdouble( 0.0, 0.0, 0.0 ), - Propagator = cms.string( "hltESPFastSteppingHelixPropagatorOpposite" ), - BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) - ), - VertexConstraint = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - MuonTrajectoryBuilder = cms.string( "Exhaustive" ) -) -process.hltL2MuonCandidates = cms.EDProducer( "L2MuonCandidateProducer", - InputObjects = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) -) -process.hltL2fL1sMu16orMu25L1f0L2Filtered16Q = cms.EDFilter( "HLTMuonL2PreFilter", - saveTags = cms.bool( True ), - MaxDr = cms.double( 9999.0 ), - CutOnChambers = cms.bool( False ), - PreviousCandTag = cms.InputTag( "hltL1fL1sMu16orMu25L1Filtered0" ), - MinPt = cms.double( 16.0 ), - MinN = cms.int32( 1 ), - SeedMapTag = cms.InputTag( "hltL2Muons" ), - MaxEta = cms.double( 2.5 ), - MinNhits = cms.vint32( 0, 1, 0, 1 ), - MinDxySig = cms.double( -1.0 ), - MinNchambers = cms.vint32( 0 ), - AbsEtaBins = cms.vdouble( 0.9, 1.5, 2.1, 5.0 ), - MaxDz = cms.double( 9999.0 ), - CandTag = cms.InputTag( "hltL2MuonCandidates" ), - BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), - MinDr = cms.double( -1.0 ), - NSigmaPt = cms.double( 0.0 ), - MinNstations = cms.vint32( 0, 2, 0, 2 ) -) -process.hltL3TrajSeedOIState = cms.EDProducer( "TSGFromL2Muon", - TkSeedGenerator = cms.PSet( - propagatorCompatibleName = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), - option = cms.uint32( 3 ), - maxChi2 = cms.double( 40.0 ), - errorMatrixPset = cms.PSet( - atIP = cms.bool( True ), - action = cms.string( "use" ), - errorMatrixValuesPSet = cms.PSet( - pf3_V12 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V13 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V11 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - pf3_V14 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V15 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), - pf3_V33 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - zAxis = cms.vdouble( -3.14159, 3.14159 ), - pf3_V44 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), - pf3_V22 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - pf3_V23 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V45 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V55 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - pf3_V34 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V35 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V25 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V24 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ) - ) - ), - propagatorName = cms.string( "hltESPSteppingHelixPropagatorAlong" ), - manySeeds = cms.bool( False ), - copyMuonRecHit = cms.bool( False ), - ComponentName = cms.string( "TSGForRoadSearch" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ) - ), - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPSteppingHelixPropagatorOpposite', - 'hltESPSteppingHelixPropagatorAlong' ), - RPCLayers = cms.bool( True ), - UseMuonNavigation = cms.untracked.bool( True ) - ), - MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), - MuonTrackingRegionBuilder = cms.PSet( ), - PCut = cms.double( 2.5 ), - TrackerSeedCleaner = cms.PSet( ), - PtCut = cms.double( 1.0 ) -) -process.hltL3TrackCandidateFromL2OIState = cms.EDProducer( "CkfTrajectoryMaker", - src = cms.InputTag( "hltL3TrajSeedOIState" ), - reverseTrajectories = cms.bool( True ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - trackCandidateAlso = cms.bool( True ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilderSeedHit" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "hltESPMuonCkfTrajectoryBuilderSeedHit" ), - maxNSeeds = cms.uint32( 100000 ) -) -process.hltL3TkTracksFromL2OIState = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltL3TrackCandidateFromL2OIState" ), - SimpleMagneticField = cms.string( "" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPKFFittingSmoother" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( False ), - Propagator = cms.string( "PropagatorWithMaterial" ) -) -process.hltL3MuonsOIState = cms.EDProducer( "L3MuonProducer", - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', - 'SteppingHelixPropagatorAny', - 'hltESPSmartPropagator', - 'hltESPSteppingHelixPropagatorOpposite' ), - RPCLayers = cms.bool( True ), - UseMuonNavigation = cms.untracked.bool( True ) - ), - L3TrajBuilderParameters = cms.PSet( - ScaleTECyFactor = cms.double( -1.0 ), - GlbRefitterParameters = cms.PSet( - TrackerSkipSection = cms.int32( -1 ), - DoPredictionsOnly = cms.bool( False ), - PropDirForCosmics = cms.bool( False ), - HitThreshold = cms.int32( 1 ), - MuonHitsOption = cms.int32( 1 ), - Chi2CutRPC = cms.double( 1.0 ), - Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), - DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - RefitDirection = cms.string( "insideOut" ), - CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), - Chi2CutCSC = cms.double( 150.0 ), - Chi2CutDT = cms.double( 10.0 ), - RefitRPCHits = cms.bool( True ), - SkipStation = cms.int32( -1 ), - Propagator = cms.string( "hltESPSmartPropagatorAny" ), - TrackerSkipSystem = cms.int32( -1 ), - DYTthrs = cms.vint32( 30, 15 ) - ), - ScaleTECxFactor = cms.double( -1.0 ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - MuonTrackingRegionBuilder = cms.PSet( - EtaR_UpperLimit_Par1 = cms.double( 0.25 ), - EtaR_UpperLimit_Par2 = cms.double( 0.15 ), - OnDemand = cms.double( -1.0 ), - Rescale_Dz = cms.double( 3.0 ), - vertexCollection = cms.InputTag( "pixelVertices" ), - Rescale_phi = cms.double( 3.0 ), - Eta_fixed = cms.double( 0.2 ), - DeltaZ_Region = cms.double( 15.9 ), - MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - PhiR_UpperLimit_Par2 = cms.double( 0.2 ), - Eta_min = cms.double( 0.05 ), - Phi_fixed = cms.double( 0.2 ), - DeltaR = cms.double( 0.2 ), - EscapePt = cms.double( 1.5 ), - UseFixedRegion = cms.bool( False ), - PhiR_UpperLimit_Par1 = cms.double( 0.6 ), - Rescale_eta = cms.double( 3.0 ), - Phi_min = cms.double( 0.05 ), - UseVertex = cms.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) - ), - RefitRPCHits = cms.bool( True ), - PCut = cms.double( 2.5 ), - TrackTransformer = cms.PSet( - DoPredictionsOnly = cms.bool( False ), - Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - RefitDirection = cms.string( "insideOut" ), - RefitRPCHits = cms.bool( True ), - Propagator = cms.string( "hltESPSmartPropagatorAny" ) - ), - GlobalMuonTrackMatcher = cms.PSet( - Pt_threshold1 = cms.double( 0.0 ), - DeltaDCut_3 = cms.double( 15.0 ), - MinP = cms.double( 2.5 ), - MinPt = cms.double( 1.0 ), - Chi2Cut_1 = cms.double( 50.0 ), - Pt_threshold2 = cms.double( 9.99999999E8 ), - LocChi2Cut = cms.double( 0.001 ), - Eta_threshold = cms.double( 1.2 ), - Quality_3 = cms.double( 7.0 ), - Quality_2 = cms.double( 15.0 ), - Chi2Cut_2 = cms.double( 50.0 ), - Chi2Cut_3 = cms.double( 200.0 ), - DeltaDCut_1 = cms.double( 40.0 ), - DeltaRCut_2 = cms.double( 0.2 ), - DeltaRCut_3 = cms.double( 1.0 ), - DeltaDCut_2 = cms.double( 10.0 ), - DeltaRCut_1 = cms.double( 0.1 ), - Propagator = cms.string( "hltESPSmartPropagator" ), - Quality_1 = cms.double( 20.0 ) - ), - PtCut = cms.double( 1.0 ), - TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), - tkTrajLabel = cms.InputTag( "hltL3TkTracksFromL2OIState" ), - tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - tkTrajMaxChi2 = cms.double( 9999.0 ), - tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), - tkTrajVertex = cms.InputTag( "pixelVertices" ), - tkTrajUseVertex = cms.bool( False ) - ), - TrackLoaderParameters = cms.PSet( - PutTkTrackIntoEvent = cms.untracked.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - SmoothTkTrack = cms.untracked.bool( False ), - MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), - Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), - MuonUpdatorAtVertexParameters = cms.PSet( - MaxChi2 = cms.double( 1000000.0 ), - Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), - BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) - ), - VertexConstraint = cms.bool( False ), - DoSmoothing = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) -) -process.hltL3TrajSeedOIHit = cms.EDProducer( "TSGFromL2Muon", - TkSeedGenerator = cms.PSet( - PSetNames = cms.vstring( 'skipTSG', - 'iterativeTSG' ), - L3TkCollectionA = cms.InputTag( "hltL3MuonsOIState" ), - iterativeTSG = cms.PSet( - ErrorRescaling = cms.double( 3.0 ), - beamSpot = cms.InputTag( "unused" ), - MaxChi2 = cms.double( 40.0 ), - errorMatrixPset = cms.PSet( - atIP = cms.bool( True ), - action = cms.string( "use" ), - errorMatrixValuesPSet = cms.PSet( - pf3_V12 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V13 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V11 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - pf3_V14 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V15 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), - pf3_V33 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - zAxis = cms.vdouble( -3.14159, 3.14159 ), - pf3_V44 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), - pf3_V22 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - pf3_V23 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V45 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V55 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - pf3_V34 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V35 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V25 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V24 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ) - ) - ), - UpdateState = cms.bool( True ), - MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - SelectState = cms.bool( False ), - SigmaZ = cms.double( 25.0 ), - ResetMethod = cms.string( "matrix" ), - ComponentName = cms.string( "TSGFromPropagation" ), - UseVertexState = cms.bool( True ), - Propagator = cms.string( "hltESPSmartPropagatorAnyOpposite" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ) - ), - skipTSG = cms.PSet( ), - ComponentName = cms.string( "DualByL2TSG" ) - ), - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'PropagatorWithMaterial', - 'hltESPSmartPropagatorAnyOpposite' ), - RPCLayers = cms.bool( True ), - UseMuonNavigation = cms.untracked.bool( True ) - ), - MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), - MuonTrackingRegionBuilder = cms.PSet( ), - PCut = cms.double( 2.5 ), - TrackerSeedCleaner = cms.PSet( - cleanerFromSharedHits = cms.bool( True ), - ptCleaner = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - directionCleaner = cms.bool( True ) - ), - PtCut = cms.double( 1.0 ) -) -process.hltL3TrackCandidateFromL2OIHit = cms.EDProducer( "CkfTrajectoryMaker", - src = cms.InputTag( "hltL3TrajSeedOIHit" ), - reverseTrajectories = cms.bool( True ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - trackCandidateAlso = cms.bool( True ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "hltESPMuonCkfTrajectoryBuilder" ), - maxNSeeds = cms.uint32( 100000 ) -) -process.hltL3TkTracksFromL2OIHit = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltL3TrackCandidateFromL2OIHit" ), - SimpleMagneticField = cms.string( "" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPKFFittingSmoother" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( False ), - Propagator = cms.string( "PropagatorWithMaterial" ) -) -process.hltL3MuonsOIHit = cms.EDProducer( "L3MuonProducer", - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', - 'SteppingHelixPropagatorAny', - 'hltESPSmartPropagator', - 'hltESPSteppingHelixPropagatorOpposite' ), - RPCLayers = cms.bool( True ), - UseMuonNavigation = cms.untracked.bool( True ) - ), - L3TrajBuilderParameters = cms.PSet( - ScaleTECyFactor = cms.double( -1.0 ), - GlbRefitterParameters = cms.PSet( - TrackerSkipSection = cms.int32( -1 ), - DoPredictionsOnly = cms.bool( False ), - PropDirForCosmics = cms.bool( False ), - HitThreshold = cms.int32( 1 ), - MuonHitsOption = cms.int32( 1 ), - Chi2CutRPC = cms.double( 1.0 ), - Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), - DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - RefitDirection = cms.string( "insideOut" ), - CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), - Chi2CutCSC = cms.double( 150.0 ), - Chi2CutDT = cms.double( 10.0 ), - RefitRPCHits = cms.bool( True ), - SkipStation = cms.int32( -1 ), - Propagator = cms.string( "hltESPSmartPropagatorAny" ), - TrackerSkipSystem = cms.int32( -1 ), - DYTthrs = cms.vint32( 30, 15 ) - ), - ScaleTECxFactor = cms.double( -1.0 ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - MuonTrackingRegionBuilder = cms.PSet( - EtaR_UpperLimit_Par1 = cms.double( 0.25 ), - EtaR_UpperLimit_Par2 = cms.double( 0.15 ), - OnDemand = cms.double( -1.0 ), - Rescale_Dz = cms.double( 3.0 ), - vertexCollection = cms.InputTag( "pixelVertices" ), - Rescale_phi = cms.double( 3.0 ), - Eta_fixed = cms.double( 0.2 ), - DeltaZ_Region = cms.double( 15.9 ), - MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - PhiR_UpperLimit_Par2 = cms.double( 0.2 ), - Eta_min = cms.double( 0.05 ), - Phi_fixed = cms.double( 0.2 ), - DeltaR = cms.double( 0.2 ), - EscapePt = cms.double( 1.5 ), - UseFixedRegion = cms.bool( False ), - PhiR_UpperLimit_Par1 = cms.double( 0.6 ), - Rescale_eta = cms.double( 3.0 ), - Phi_min = cms.double( 0.05 ), - UseVertex = cms.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) - ), - RefitRPCHits = cms.bool( True ), - PCut = cms.double( 2.5 ), - TrackTransformer = cms.PSet( - DoPredictionsOnly = cms.bool( False ), - Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - RefitDirection = cms.string( "insideOut" ), - RefitRPCHits = cms.bool( True ), - Propagator = cms.string( "hltESPSmartPropagatorAny" ) - ), - GlobalMuonTrackMatcher = cms.PSet( - Pt_threshold1 = cms.double( 0.0 ), - DeltaDCut_3 = cms.double( 15.0 ), - MinP = cms.double( 2.5 ), - MinPt = cms.double( 1.0 ), - Chi2Cut_1 = cms.double( 50.0 ), - Pt_threshold2 = cms.double( 9.99999999E8 ), - LocChi2Cut = cms.double( 0.001 ), - Eta_threshold = cms.double( 1.2 ), - Quality_3 = cms.double( 7.0 ), - Quality_2 = cms.double( 15.0 ), - Chi2Cut_2 = cms.double( 50.0 ), - Chi2Cut_3 = cms.double( 200.0 ), - DeltaDCut_1 = cms.double( 40.0 ), - DeltaRCut_2 = cms.double( 0.2 ), - DeltaRCut_3 = cms.double( 1.0 ), - DeltaDCut_2 = cms.double( 10.0 ), - DeltaRCut_1 = cms.double( 0.1 ), - Propagator = cms.string( "hltESPSmartPropagator" ), - Quality_1 = cms.double( 20.0 ) - ), - PtCut = cms.double( 1.0 ), - TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), - tkTrajLabel = cms.InputTag( "hltL3TkTracksFromL2OIHit" ), - tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - tkTrajMaxChi2 = cms.double( 9999.0 ), - tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), - tkTrajVertex = cms.InputTag( "pixelVertices" ), - tkTrajUseVertex = cms.bool( False ) - ), - TrackLoaderParameters = cms.PSet( - PutTkTrackIntoEvent = cms.untracked.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - SmoothTkTrack = cms.untracked.bool( False ), - MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), - Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), - MuonUpdatorAtVertexParameters = cms.PSet( - MaxChi2 = cms.double( 1000000.0 ), - Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), - BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) - ), - VertexConstraint = cms.bool( False ), - DoSmoothing = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) -) -process.hltL3TkFromL2OICombination = cms.EDProducer( "L3TrackCombiner", - labels = cms.VInputTag( 'hltL3MuonsOIState','hltL3MuonsOIHit' ) -) -process.hltPixelLayerPairs = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2', - 'BPix1+BPix3', - 'BPix2+BPix3', - 'BPix1+FPix1_pos', - 'BPix1+FPix1_neg', - 'BPix1+FPix2_pos', - 'BPix1+FPix2_neg', - 'BPix2+FPix1_pos', - 'BPix2+FPix1_neg', - 'BPix2+FPix2_pos', - 'BPix2+FPix2_neg', - 'FPix1_pos+FPix2_pos', - 'FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - useErrorsFromParam = cms.bool( True ), - hitErrorRPhi = cms.double( 0.0051 ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - useErrorsFromParam = cms.bool( True ), - hitErrorRPhi = cms.double( 0.0027 ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ) - ), - TIB = cms.PSet( ) +process.hltCsc2DRecHits = cms.EDProducer( "CSCRecHitDProducer", + XTasymmetry_ME1b = cms.double( 0.0 ), + XTasymmetry_ME1a = cms.double( 0.0 ), + ConstSyst_ME1a = cms.double( 0.022 ), + ConstSyst_ME1b = cms.double( 0.007 ), + XTasymmetry_ME41 = cms.double( 0.0 ), + CSCStripxtalksOffset = cms.double( 0.03 ), + CSCUseCalibrations = cms.bool( True ), + CSCUseTimingCorrections = cms.bool( True ), + CSCNoOfTimeBinsForDynamicPedestal = cms.int32( 2 ), + XTasymmetry_ME22 = cms.double( 0.0 ), + UseFivePoleFit = cms.bool( True ), + XTasymmetry_ME21 = cms.double( 0.0 ), + ConstSyst_ME21 = cms.double( 0.0 ), + CSCDebug = cms.untracked.bool( False ), + ConstSyst_ME22 = cms.double( 0.0 ), + CSCUseGasGainCorrections = cms.bool( False ), + XTasymmetry_ME31 = cms.double( 0.0 ), + readBadChambers = cms.bool( True ), + NoiseLevel_ME13 = cms.double( 8.0 ), + NoiseLevel_ME12 = cms.double( 9.0 ), + NoiseLevel_ME32 = cms.double( 9.0 ), + NoiseLevel_ME31 = cms.double( 9.0 ), + XTasymmetry_ME32 = cms.double( 0.0 ), + ConstSyst_ME41 = cms.double( 0.0 ), + CSCStripClusterSize = cms.untracked.int32( 3 ), + CSCStripClusterChargeCut = cms.double( 25.0 ), + CSCStripPeakThreshold = cms.double( 10.0 ), + readBadChannels = cms.bool( False ), + UseParabolaFit = cms.bool( False ), + XTasymmetry_ME13 = cms.double( 0.0 ), + XTasymmetry_ME12 = cms.double( 0.0 ), + wireDigiTag = cms.InputTag( 'hltMuonCSCDigis','MuonCSCWireDigi' ), + ConstSyst_ME12 = cms.double( 0.0 ), + ConstSyst_ME13 = cms.double( 0.0 ), + ConstSyst_ME32 = cms.double( 0.0 ), + ConstSyst_ME31 = cms.double( 0.0 ), + UseAverageTime = cms.bool( False ), + NoiseLevel_ME1a = cms.double( 7.0 ), + NoiseLevel_ME1b = cms.double( 8.0 ), + CSCWireClusterDeltaT = cms.int32( 1 ), + CSCUseStaticPedestals = cms.bool( False ), + stripDigiTag = cms.InputTag( 'hltMuonCSCDigis','MuonCSCStripDigi' ), + CSCstripWireDeltaTime = cms.int32( 8 ), + NoiseLevel_ME21 = cms.double( 9.0 ), + NoiseLevel_ME22 = cms.double( 9.0 ), + NoiseLevel_ME41 = cms.double( 9.0 ) ) -process.hltL3TrajSeedIOHit = cms.EDProducer( "TSGFromL2Muon", - TkSeedGenerator = cms.PSet( - PSetNames = cms.vstring( 'skipTSG', - 'iterativeTSG' ), - L3TkCollectionA = cms.InputTag( "hltL3TkFromL2OICombination" ), - iterativeTSG = cms.PSet( - firstTSG = cms.PSet( - ComponentName = cms.string( "TSGFromOrderedHits" ), - OrderedHitsFactoryPSet = cms.PSet( - ComponentName = cms.string( "StandardHitTripletGenerator" ), - GeneratorPSet = cms.PSet( - useBending = cms.bool( True ), - useFixedPreFiltering = cms.bool( False ), - maxElement = cms.uint32( 0 ), - phiPreFiltering = cms.double( 0.3 ), - extraHitRPhitolerance = cms.double( 0.06 ), - useMultScattering = cms.bool( True ), - ComponentName = cms.string( "PixelTripletHLTGenerator" ), - extraHitRZtolerance = cms.double( 0.06 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) - ), - SeedingLayers = cms.InputTag( "hltPixelLayerTriplets" ) - ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - PSetNames = cms.vstring( 'firstTSG', - 'secondTSG' ), - ComponentName = cms.string( "CombinedTSG" ), - thirdTSG = cms.PSet( - PSetNames = cms.vstring( 'endcapTSG', - 'barrelTSG' ), - barrelTSG = cms.PSet( ), - endcapTSG = cms.PSet( - ComponentName = cms.string( "TSGFromOrderedHits" ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitPairGenerator" ), - useOnDemandTracker = cms.untracked.int32( 0 ), - SeedingLayers = cms.InputTag( "hltMixedLayerPairs" ) - ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - etaSeparation = cms.double( 2.0 ), - ComponentName = cms.string( "DualByEtaTSG" ) - ), - secondTSG = cms.PSet( - ComponentName = cms.string( "TSGFromOrderedHits" ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitPairGenerator" ), - useOnDemandTracker = cms.untracked.int32( 0 ), - SeedingLayers = cms.InputTag( "hltPixelLayerPairs" ) +process.hltCscSegments = cms.EDProducer( "CSCSegmentProducer", + inputObjects = cms.InputTag( "hltCsc2DRecHits" ), + algo_psets = cms.VPSet( + cms.PSet( chamber_types = cms.vstring( 'ME1/a', + 'ME1/b', + 'ME1/2', + 'ME1/3', + 'ME2/1', + 'ME2/2', + 'ME3/1', + 'ME3/2', + 'ME4/1', + 'ME4/2' ), + algo_name = cms.string( "CSCSegAlgoST" ), + parameters_per_chamber_type = cms.vint32( 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 ), + algo_psets = cms.VPSet( + cms.PSet( maxRatioResidualPrune = cms.double( 3.0 ), + yweightPenalty = cms.double( 1.5 ), + maxRecHitsInCluster = cms.int32( 20 ), + dPhiFineMax = cms.double( 0.025 ), + preClusteringUseChaining = cms.bool( True ), + ForceCovariance = cms.bool( False ), + hitDropLimit6Hits = cms.double( 0.3333 ), + NormChi2Cut2D = cms.double( 20.0 ), + BPMinImprovement = cms.double( 10000.0 ), + Covariance = cms.double( 0.0 ), + tanPhiMax = cms.double( 0.5 ), + SeedBig = cms.double( 0.0015 ), + onlyBestSegment = cms.bool( False ), + dRPhiFineMax = cms.double( 8.0 ), + SeedSmall = cms.double( 2.0E-4 ), + curvePenalty = cms.double( 2.0 ), + dXclusBoxMax = cms.double( 4.0 ), + BrutePruning = cms.bool( True ), + curvePenaltyThreshold = cms.double( 0.85 ), + CorrectTheErrors = cms.bool( True ), + hitDropLimit4Hits = cms.double( 0.6 ), + useShowering = cms.bool( False ), + CSCDebug = cms.untracked.bool( False ), + tanThetaMax = cms.double( 1.2 ), + NormChi2Cut3D = cms.double( 10.0 ), + minHitsPerSegment = cms.int32( 3 ), + ForceCovarianceAll = cms.bool( False ), + yweightPenaltyThreshold = cms.double( 1.0 ), + prePrunLimit = cms.double( 3.17 ), + hitDropLimit5Hits = cms.double( 0.8 ), + preClustering = cms.bool( True ), + prePrun = cms.bool( True ), + maxDPhi = cms.double( 999.0 ), + maxDTheta = cms.double( 999.0 ), + Pruning = cms.bool( True ), + dYclusBoxMax = cms.double( 8.0 ) ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + cms.PSet( maxRatioResidualPrune = cms.double( 3.0 ), + yweightPenalty = cms.double( 1.5 ), + maxRecHitsInCluster = cms.int32( 24 ), + dPhiFineMax = cms.double( 0.025 ), + preClusteringUseChaining = cms.bool( True ), + ForceCovariance = cms.bool( False ), + hitDropLimit6Hits = cms.double( 0.3333 ), + NormChi2Cut2D = cms.double( 20.0 ), + BPMinImprovement = cms.double( 10000.0 ), + Covariance = cms.double( 0.0 ), + tanPhiMax = cms.double( 0.5 ), + SeedBig = cms.double( 0.0015 ), + onlyBestSegment = cms.bool( False ), + dRPhiFineMax = cms.double( 8.0 ), + SeedSmall = cms.double( 2.0E-4 ), + curvePenalty = cms.double( 2.0 ), + dXclusBoxMax = cms.double( 4.0 ), + BrutePruning = cms.bool( True ), + curvePenaltyThreshold = cms.double( 0.85 ), + CorrectTheErrors = cms.bool( True ), + hitDropLimit4Hits = cms.double( 0.6 ), + useShowering = cms.bool( False ), + CSCDebug = cms.untracked.bool( False ), + tanThetaMax = cms.double( 1.2 ), + NormChi2Cut3D = cms.double( 10.0 ), + minHitsPerSegment = cms.int32( 3 ), + ForceCovarianceAll = cms.bool( False ), + yweightPenaltyThreshold = cms.double( 1.0 ), + prePrunLimit = cms.double( 3.17 ), + hitDropLimit5Hits = cms.double( 0.8 ), + preClustering = cms.bool( True ), + prePrun = cms.bool( True ), + maxDPhi = cms.double( 999.0 ), + maxDTheta = cms.double( 999.0 ), + Pruning = cms.bool( True ), + dYclusBoxMax = cms.double( 8.0 ) + ) ) - ), - skipTSG = cms.PSet( ), - ComponentName = cms.string( "DualByL2TSG" ) + ) ), + algo_type = cms.int32( 1 ) +) +process.hltMuonRPCDigis = cms.EDProducer( "RPCUnpackingModule", + InputLabel = cms.InputTag( "rawDataRepacker" ), + doSynchro = cms.bool( False ) +) +process.hltRpcRecHits = cms.EDProducer( "RPCRecHitProducer", + recAlgoConfig = cms.PSet( ), + deadvecfile = cms.FileInPath( "RecoLocalMuon/RPCRecHit/data/RPCDeadVec.dat" ), + rpcDigiLabel = cms.InputTag( "hltMuonRPCDigis" ), + maskvecfile = cms.FileInPath( "RecoLocalMuon/RPCRecHit/data/RPCMaskVec.dat" ), + recAlgo = cms.string( "RPCRecHitStandardAlgo" ), + deadSource = cms.string( "File" ), + maskSource = cms.string( "File" ) +) +process.hltL2OfflineMuonSeeds = cms.EDProducer( "MuonSeedGenerator", + SMB_21 = cms.vdouble( 1.043, -0.124, 0.0, 0.183, 0.0, 0.0 ), + SMB_20 = cms.vdouble( 1.011, -0.052, 0.0, 0.188, 0.0, 0.0 ), + SMB_22 = cms.vdouble( 1.474, -0.758, 0.0, 0.185, 0.0, 0.0 ), + OL_2213 = cms.vdouble( 0.117, 0.0, 0.0, 0.044, 0.0, 0.0 ), + SME_11 = cms.vdouble( 3.295, -1.527, 0.112, 0.378, 0.02, 0.0 ), + SME_13 = cms.vdouble( -1.286, 1.711, 0.0, 0.356, 0.0, 0.0 ), + SME_12 = cms.vdouble( 0.102, 0.599, 0.0, 0.38, 0.0, 0.0 ), + DT_34_2_scale = cms.vdouble( -11.901897, 0.0 ), + OL_1213_0_scale = cms.vdouble( -4.488158, 0.0 ), + OL_1222_0_scale = cms.vdouble( -5.810449, 0.0 ), + DT_13 = cms.vdouble( 0.315, 0.068, -0.127, 0.051, -0.002, 0.0 ), + DT_12 = cms.vdouble( 0.183, 0.054, -0.087, 0.028, 0.002, 0.0 ), + DT_14 = cms.vdouble( 0.359, 0.052, -0.107, 0.072, -0.004, 0.0 ), + CSC_13_3_scale = cms.vdouble( -1.701268, 0.0 ), + DT_24_2_scale = cms.vdouble( -6.63094, 0.0 ), + CSC_23 = cms.vdouble( -0.081, 0.113, -0.029, 0.015, 0.008, 0.0 ), + CSC_24 = cms.vdouble( 0.004, 0.021, -0.002, 0.053, 0.0, 0.0 ), + OL_2222 = cms.vdouble( 0.107, 0.0, 0.0, 0.04, 0.0, 0.0 ), + DT_14_2_scale = cms.vdouble( -4.808546, 0.0 ), + SMB_10 = cms.vdouble( 1.387, -0.038, 0.0, 0.19, 0.0, 0.0 ), + SMB_11 = cms.vdouble( 1.247, 0.72, -0.802, 0.229, -0.075, 0.0 ), + SMB_12 = cms.vdouble( 2.128, -0.956, 0.0, 0.199, 0.0, 0.0 ), + SME_21 = cms.vdouble( -0.529, 1.194, -0.358, 0.472, 0.086, 0.0 ), + SME_22 = cms.vdouble( -1.207, 1.491, -0.251, 0.189, 0.243, 0.0 ), + DT_13_2_scale = cms.vdouble( -4.257687, 0.0 ), + CSC_34 = cms.vdouble( 0.062, -0.067, 0.019, 0.021, 0.003, 0.0 ), + SME_22_0_scale = cms.vdouble( -3.457901, 0.0 ), + DT_24_1_scale = cms.vdouble( -7.490909, 0.0 ), + OL_1232_0_scale = cms.vdouble( -5.964634, 0.0 ), + DT_23_1_scale = cms.vdouble( -5.320346, 0.0 ), + SME_13_0_scale = cms.vdouble( 0.104905, 0.0 ), + SMB_22_0_scale = cms.vdouble( 1.346681, 0.0 ), + CSC_12_1_scale = cms.vdouble( -6.434242, 0.0 ), + DT_34 = cms.vdouble( 0.044, 0.004, -0.013, 0.029, 0.003, 0.0 ), + SME_32 = cms.vdouble( -0.901, 1.333, -0.47, 0.41, 0.073, 0.0 ), + SME_31 = cms.vdouble( -1.594, 1.482, -0.317, 0.487, 0.097, 0.0 ), + CSC_13_2_scale = cms.vdouble( -6.077936, 0.0 ), + crackEtas = cms.vdouble( 0.2, 1.6, 1.7 ), + SME_11_0_scale = cms.vdouble( 1.325085, 0.0 ), + SMB_20_0_scale = cms.vdouble( 1.486168, 0.0 ), + DT_13_1_scale = cms.vdouble( -4.520923, 0.0 ), + CSC_24_1_scale = cms.vdouble( -6.055701, 0.0 ), + CSC_01_1_scale = cms.vdouble( -1.915329, 0.0 ), + DT_23 = cms.vdouble( 0.13, 0.023, -0.057, 0.028, 0.004, 0.0 ), + DT_24 = cms.vdouble( 0.176, 0.014, -0.051, 0.051, 0.003, 0.0 ), + SMB_12_0_scale = cms.vdouble( 2.283221, 0.0 ), + deltaPhiSearchWindow = cms.double( 0.25 ), + SMB_30_0_scale = cms.vdouble( -3.629838, 0.0 ), + SME_42 = cms.vdouble( -0.003, 0.005, 0.005, 0.608, 0.076, 0.0 ), + SME_41 = cms.vdouble( -0.003, 0.005, 0.005, 0.608, 0.076, 0.0 ), + deltaEtaSearchWindow = cms.double( 0.2 ), + CSC_12_2_scale = cms.vdouble( -1.63622, 0.0 ), + DT_34_1_scale = cms.vdouble( -13.783765, 0.0 ), + CSC_34_1_scale = cms.vdouble( -11.520507, 0.0 ), + OL_2213_0_scale = cms.vdouble( -7.239789, 0.0 ), + SMB_32_0_scale = cms.vdouble( -3.054156, 0.0 ), + CSC_12_3_scale = cms.vdouble( -1.63622, 0.0 ), + deltaEtaCrackSearchWindow = cms.double( 0.25 ), + SME_21_0_scale = cms.vdouble( -0.040862, 0.0 ), + OL_1232 = cms.vdouble( 0.184, 0.0, 0.0, 0.066, 0.0, 0.0 ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + SMB_10_0_scale = cms.vdouble( 2.448566, 0.0 ), + EnableDTMeasurement = cms.bool( True ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + CSC_23_2_scale = cms.vdouble( -6.079917, 0.0 ), + scaleDT = cms.bool( True ), + DT_12_2_scale = cms.vdouble( -3.518165, 0.0 ), + OL_1222 = cms.vdouble( 0.848, -0.591, 0.0, 0.062, 0.0, 0.0 ), + CSC_23_1_scale = cms.vdouble( -19.084285, 0.0 ), + OL_1213 = cms.vdouble( 0.96, -0.737, 0.0, 0.052, 0.0, 0.0 ), + CSC_02 = cms.vdouble( 0.612, -0.207, 0.0, 0.067, -0.001, 0.0 ), + CSC_03 = cms.vdouble( 0.787, -0.338, 0.029, 0.101, -0.008, 0.0 ), + CSC_01 = cms.vdouble( 0.166, 0.0, 0.0, 0.031, 0.0, 0.0 ), + SMB_32 = cms.vdouble( 0.67, -0.327, 0.0, 0.22, 0.0, 0.0 ), + SMB_30 = cms.vdouble( 0.505, -0.022, 0.0, 0.215, 0.0, 0.0 ), + SMB_31 = cms.vdouble( 0.549, -0.145, 0.0, 0.207, 0.0, 0.0 ), + crackWindow = cms.double( 0.04 ), + CSC_14_3_scale = cms.vdouble( -1.969563, 0.0 ), + SMB_31_0_scale = cms.vdouble( -3.323768, 0.0 ), + DT_12_1_scale = cms.vdouble( -3.692398, 0.0 ), + SMB_21_0_scale = cms.vdouble( 1.58384, 0.0 ), + DT_23_2_scale = cms.vdouble( -5.117625, 0.0 ), + SME_12_0_scale = cms.vdouble( 2.279181, 0.0 ), + DT_14_1_scale = cms.vdouble( -5.644816, 0.0 ), + beamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + SMB_11_0_scale = cms.vdouble( 2.56363, 0.0 ), + EnableCSCMeasurement = cms.bool( True ), + CSC_14 = cms.vdouble( 0.606, -0.181, -0.002, 0.111, -0.003, 0.0 ), + OL_2222_0_scale = cms.vdouble( -7.667231, 0.0 ), + CSC_13 = cms.vdouble( 0.901, -1.302, 0.533, 0.045, 0.005, 0.0 ), + CSC_12 = cms.vdouble( -0.161, 0.254, -0.047, 0.042, -0.007, 0.0 ) +) +process.hltL2MuonSeeds = cms.EDProducer( "L2MuonSeedGenerator", ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'PropagatorWithMaterial' ), + Propagators = cms.untracked.vstring( 'SteppingHelixPropagatorAny' ), RPCLayers = cms.bool( True ), UseMuonNavigation = cms.untracked.bool( True ) ), - MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), - MuonTrackingRegionBuilder = cms.PSet( - EtaR_UpperLimit_Par1 = cms.double( 0.25 ), - EtaR_UpperLimit_Par2 = cms.double( 0.15 ), - OnDemand = cms.double( -1.0 ), - Rescale_Dz = cms.double( 3.0 ), - vertexCollection = cms.InputTag( "pixelVertices" ), - Rescale_phi = cms.double( 3.0 ), - Eta_fixed = cms.double( 0.2 ), - DeltaZ_Region = cms.double( 15.9 ), - MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - PhiR_UpperLimit_Par2 = cms.double( 0.2 ), - Eta_min = cms.double( 0.1 ), - Phi_fixed = cms.double( 0.2 ), - DeltaR = cms.double( 0.2 ), - EscapePt = cms.double( 1.5 ), - UseFixedRegion = cms.bool( False ), - PhiR_UpperLimit_Par1 = cms.double( 0.6 ), - Rescale_eta = cms.double( 3.0 ), - Phi_min = cms.double( 0.1 ), - UseVertex = cms.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) - ), - PCut = cms.double( 2.5 ), - TrackerSeedCleaner = cms.PSet( - cleanerFromSharedHits = cms.bool( True ), - ptCleaner = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - directionCleaner = cms.bool( True ) - ), - PtCut = cms.double( 1.0 ) -) -process.hltL3TrackCandidateFromL2IOHit = cms.EDProducer( "CkfTrajectoryMaker", - src = cms.InputTag( "hltL3TrajSeedIOHit" ), - reverseTrajectories = cms.bool( False ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - trackCandidateAlso = cms.bool( True ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "hltESPMuonCkfTrajectoryBuilder" ), - maxNSeeds = cms.uint32( 100000 ) -) -process.hltL3TkTracksFromL2IOHit = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltL3TrackCandidateFromL2IOHit" ), - SimpleMagneticField = cms.string( "" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPKFFittingSmoother" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( False ), - Propagator = cms.string( "PropagatorWithMaterial" ) + InputObjects = cms.InputTag( "hltL1extraParticles" ), + L1MaxEta = cms.double( 2.5 ), + OfflineSeedLabel = cms.untracked.InputTag( "hltL2OfflineMuonSeeds" ), + L1MinPt = cms.double( 0.0 ), + L1MinQuality = cms.uint32( 1 ), + GMTReadoutCollection = cms.InputTag( "hltGtDigis" ), + UseUnassociatedL1 = cms.bool( False ), + UseOfflineSeed = cms.untracked.bool( True ), + Propagator = cms.string( "SteppingHelixPropagatorAny" ) ) -process.hltL3MuonsIOHit = cms.EDProducer( "L3MuonProducer", +process.hltL2Muons = cms.EDProducer( "L2MuonProducer", ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', - 'SteppingHelixPropagatorAny', - 'hltESPSmartPropagator', - 'hltESPSteppingHelixPropagatorOpposite' ), + Propagators = cms.untracked.vstring( 'hltESPFastSteppingHelixPropagatorAny', + 'hltESPFastSteppingHelixPropagatorOpposite' ), RPCLayers = cms.bool( True ), UseMuonNavigation = cms.untracked.bool( True ) ), - L3TrajBuilderParameters = cms.PSet( - ScaleTECyFactor = cms.double( -1.0 ), - GlbRefitterParameters = cms.PSet( - TrackerSkipSection = cms.int32( -1 ), - DoPredictionsOnly = cms.bool( False ), - PropDirForCosmics = cms.bool( False ), - HitThreshold = cms.int32( 1 ), - MuonHitsOption = cms.int32( 1 ), - Chi2CutRPC = cms.double( 1.0 ), - Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + InputObjects = cms.InputTag( "hltL2MuonSeeds" ), + SeedTransformerParameters = cms.PSet( + Fitter = cms.string( "hltESPKFFittingSmootherForL2Muon" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + NMinRecHits = cms.uint32( 2 ), + UseSubRecHits = cms.bool( False ), + Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), + RescaleError = cms.double( 100.0 ) + ), + L2TrajBuilderParameters = cms.PSet( + DoRefit = cms.bool( False ), + SeedPropagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), + FilterParameters = cms.PSet( + NumberOfSigma = cms.double( 3.0 ), + FitDirection = cms.string( "insideOut" ), DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - RefitDirection = cms.string( "insideOut" ), + MaxChi2 = cms.double( 1000.0 ), + MuonTrajectoryUpdatorParameters = cms.PSet( + MaxChi2 = cms.double( 25.0 ), + RescaleErrorFactor = cms.double( 100.0 ), + Granularity = cms.int32( 0 ), + ExcludeRPCFromFit = cms.bool( False ), + UseInvalidHits = cms.bool( True ), + RescaleError = cms.bool( False ) + ), + EnableRPCMeasurement = cms.bool( True ), CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), - Chi2CutCSC = cms.double( 150.0 ), - Chi2CutDT = cms.double( 10.0 ), - RefitRPCHits = cms.bool( True ), - SkipStation = cms.int32( -1 ), - Propagator = cms.string( "hltESPSmartPropagatorAny" ), - TrackerSkipSystem = cms.int32( -1 ), - DYTthrs = cms.vint32( 30, 15 ) - ), - ScaleTECxFactor = cms.double( -1.0 ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - MuonTrackingRegionBuilder = cms.PSet( - EtaR_UpperLimit_Par1 = cms.double( 0.25 ), - EtaR_UpperLimit_Par2 = cms.double( 0.15 ), - OnDemand = cms.double( -1.0 ), - Rescale_Dz = cms.double( 3.0 ), - vertexCollection = cms.InputTag( "pixelVertices" ), - Rescale_phi = cms.double( 3.0 ), - Eta_fixed = cms.double( 0.2 ), - DeltaZ_Region = cms.double( 15.9 ), - MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - PhiR_UpperLimit_Par2 = cms.double( 0.2 ), - Eta_min = cms.double( 0.05 ), - Phi_fixed = cms.double( 0.2 ), - DeltaR = cms.double( 0.2 ), - EscapePt = cms.double( 1.5 ), - UseFixedRegion = cms.bool( False ), - PhiR_UpperLimit_Par1 = cms.double( 0.6 ), - Rescale_eta = cms.double( 3.0 ), - Phi_min = cms.double( 0.05 ), - UseVertex = cms.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + EnableDTMeasurement = cms.bool( True ), + RPCRecSegmentLabel = cms.InputTag( "hltRpcRecHits" ), + Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), + EnableCSCMeasurement = cms.bool( True ) ), - RefitRPCHits = cms.bool( True ), - PCut = cms.double( 2.5 ), - TrackTransformer = cms.PSet( - DoPredictionsOnly = cms.bool( False ), - Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + NavigationType = cms.string( "Standard" ), + SeedTransformerParameters = cms.PSet( + Fitter = cms.string( "hltESPKFFittingSmootherForL2Muon" ), MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - RefitDirection = cms.string( "insideOut" ), - RefitRPCHits = cms.bool( True ), - Propagator = cms.string( "hltESPSmartPropagatorAny" ) + NMinRecHits = cms.uint32( 2 ), + UseSubRecHits = cms.bool( False ), + Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), + RescaleError = cms.double( 100.0 ) ), - GlobalMuonTrackMatcher = cms.PSet( - Pt_threshold1 = cms.double( 0.0 ), - DeltaDCut_3 = cms.double( 15.0 ), - MinP = cms.double( 2.5 ), - MinPt = cms.double( 1.0 ), - Chi2Cut_1 = cms.double( 50.0 ), - Pt_threshold2 = cms.double( 9.99999999E8 ), - LocChi2Cut = cms.double( 0.001 ), - Eta_threshold = cms.double( 1.2 ), - Quality_3 = cms.double( 7.0 ), - Quality_2 = cms.double( 15.0 ), - Chi2Cut_2 = cms.double( 50.0 ), - Chi2Cut_3 = cms.double( 200.0 ), - DeltaDCut_1 = cms.double( 40.0 ), - DeltaRCut_2 = cms.double( 0.2 ), - DeltaRCut_3 = cms.double( 1.0 ), - DeltaDCut_2 = cms.double( 10.0 ), - DeltaRCut_1 = cms.double( 0.1 ), - Propagator = cms.string( "hltESPSmartPropagator" ), - Quality_1 = cms.double( 20.0 ) + DoBackwardFilter = cms.bool( True ), + SeedPosition = cms.string( "in" ), + BWFilterParameters = cms.PSet( + NumberOfSigma = cms.double( 3.0 ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + FitDirection = cms.string( "outsideIn" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + MaxChi2 = cms.double( 100.0 ), + MuonTrajectoryUpdatorParameters = cms.PSet( + MaxChi2 = cms.double( 25.0 ), + RescaleErrorFactor = cms.double( 100.0 ), + Granularity = cms.int32( 0 ), + ExcludeRPCFromFit = cms.bool( False ), + UseInvalidHits = cms.bool( True ), + RescaleError = cms.bool( False ) + ), + EnableRPCMeasurement = cms.bool( True ), + BWSeedType = cms.string( "fromGenerator" ), + EnableDTMeasurement = cms.bool( True ), + RPCRecSegmentLabel = cms.InputTag( "hltRpcRecHits" ), + Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), + EnableCSCMeasurement = cms.bool( True ) ), - PtCut = cms.double( 1.0 ), - TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), - tkTrajLabel = cms.InputTag( "hltL3TkTracksFromL2IOHit" ), - tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - tkTrajMaxChi2 = cms.double( 9999.0 ), - tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), - tkTrajVertex = cms.InputTag( "pixelVertices" ), - tkTrajUseVertex = cms.bool( False ) + DoSeedRefit = cms.bool( False ) ), + DoSeedRefit = cms.bool( False ), TrackLoaderParameters = cms.PSet( - PutTkTrackIntoEvent = cms.untracked.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - SmoothTkTrack = cms.untracked.bool( False ), - MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + DoSmoothing = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), MuonUpdatorAtVertexParameters = cms.PSet( MaxChi2 = cms.double( 1000000.0 ), - Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPosition = cms.vdouble( 0.0, 0.0, 0.0 ), + Propagator = cms.string( "hltESPFastSteppingHelixPropagatorOpposite" ), BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) ), - VertexConstraint = cms.bool( False ), - DoSmoothing = cms.bool( True ), + VertexConstraint = cms.bool( True ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) ), - MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) + MuonTrajectoryBuilder = cms.string( "Exhaustive" ) ) -process.hltL3TrajectorySeed = cms.EDProducer( "L3MuonTrajectorySeedCombiner", - labels = cms.VInputTag( 'hltL3TrajSeedIOHit','hltL3TrajSeedOIState','hltL3TrajSeedOIHit' ) -) -process.hltL3TrackCandidateFromL2 = cms.EDProducer( "L3TrackCandCombiner", - labels = cms.VInputTag( 'hltL3TrackCandidateFromL2IOHit','hltL3TrackCandidateFromL2OIHit','hltL3TrackCandidateFromL2OIState' ) -) -process.hltL3TkTracksMergeStep1 = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltL3TkTracksFromL2OIState','hltL3TkTracksFromL2OIHit' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 100.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltL3TkTracksFromL2OIState','hltL3TkTracksFromL2OIHit' ), - LostHitPenalty = cms.double( 0.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltL3TkTracksFromL2 = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltL3TkTracksMergeStep1','hltL3TkTracksFromL2IOHit' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 100.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltL3TkTracksMergeStep1','hltL3TkTracksFromL2IOHit' ), - LostHitPenalty = cms.double( 0.0 ), - newQuality = cms.string( "confirmed" ) +process.hltL2MuonCandidates = cms.EDProducer( "L2MuonCandidateProducer", + InputObjects = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) +) +process.hltHIL2Mu3L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) ) -process.hltL3MuonsLinksCombination = cms.EDProducer( "L3TrackLinksCombiner", - labels = cms.VInputTag( 'hltL3MuonsOIState','hltL3MuonsOIHit','hltL3MuonsIOHit' ) +process.hltPreHIL2Mu7 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) ) -process.hltL3Muons = cms.EDProducer( "L3TrackCombiner", - labels = cms.VInputTag( 'hltL3MuonsOIState','hltL3MuonsOIHit','hltL3MuonsIOHit' ) +process.hltHIL2Mu7L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 7.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) ) -process.hltL3MuonCandidates = cms.EDProducer( "L3MuonCandidateProducer", - InputLinksObjects = cms.InputTag( "hltL3MuonsLinksCombination" ), - InputObjects = cms.InputTag( "hltL3Muons" ), - MuonPtOption = cms.string( "Tracker" ) +process.hltPreHIL2Mu15 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) ) -process.hltL3fL1sMu16orMu25L1f0L2f16QL3Filtered50Q = cms.EDFilter( "HLTMuonL3PreFilter", - MaxNormalizedChi2 = cms.double( 20.0 ), +process.hltHIL2Mu15L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", saveTags = cms.bool( True ), - PreviousCandTag = cms.InputTag( "hltL2fL1sMu16orMu25L1f0L2Filtered16Q" ), - MinNmuonHits = cms.int32( 0 ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 15.0 ), MinN = cms.int32( 1 ), - MinTrackPt = cms.double( 0.0 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), MaxEta = cms.double( 2.5 ), - MaxDXYBeamSpot = cms.double( 0.1 ), - MinNhits = cms.int32( 0 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2Mu3NHitQ = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIL2Mu3N1HitQL2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 1 ), MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2DoubleMu0 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIDoubleMuLevel1PathL1OpenFiltered = cms.EDFilter( "HLTMuonL1Filter", + saveTags = cms.bool( True ), + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1DoubleMuOpenBptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "hltL1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) +) +process.hltHIL2DoubleMu0L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), MaxDz = cms.double( 9999.0 ), - MaxPtDifference = cms.double( 9999.0 ), - MaxDr = cms.double( 2.0 ), - CandTag = cms.InputTag( "hltL3MuonCandidates" ), - MinDXYBeamSpot = cms.double( -1.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2DoubleMu0NHitQ = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIL2DoubleMu0L2N1HitsFiltered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 1 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2DoubleMu3 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIL2DoubleMu3L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), - MinPt = cms.double( 50.0 ) + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) ) -process.hltPrePFJet260 = cms.EDFilter( "HLTPrescaler", +process.hltPreHIL3Mu3 = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) -process.hltSingleCaloJet210 = cms.EDFilter( "HLT1CaloJet", - saveTags = cms.bool( True ), - MinPt = cms.double( 210.0 ), - MinN = cms.int32( 1 ), - MaxEta = cms.double( 5.0 ), - MinMass = cms.double( -1.0 ), - inputTag = cms.InputTag( "hltAK4CaloJetsCorrectedIDPassed" ), - MinE = cms.double( -1.0 ), - triggerType = cms.int32( 85 ) -) -process.hltTowerMakerForPF = cms.EDProducer( "CaloTowersCreator", - EBSumThreshold = cms.double( 0.2 ), - MomHBDepth = cms.double( 0.2 ), - UseEtEBTreshold = cms.bool( False ), - hfInput = cms.InputTag( "hltHfreco" ), - AllowMissingInputs = cms.bool( False ), - MomEEDepth = cms.double( 0.0 ), - EESumThreshold = cms.double( 0.45 ), - HBGrid = cms.vdouble( ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - HBThreshold = cms.double( 0.4 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), - UseEcalRecoveredHits = cms.bool( False ), - MomConstrMethod = cms.int32( 1 ), - MomHEDepth = cms.double( 0.4 ), - HcalThreshold = cms.double( -1000.0 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), - UseSymEBTreshold = cms.bool( False ), - EEWeights = cms.vdouble( ), - EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), - HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HEDGrid = cms.vdouble( ), - EBWeight = cms.double( 1.0 ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), - HOWeight = cms.double( 1.0 ), - HESWeight = cms.double( 1.0 ), - HESThreshold = cms.double( 0.4 ), - hbheInput = cms.InputTag( "hltHbhereco" ), - HF2Weight = cms.double( 1.0 ), - HF2Threshold = cms.double( 1.8 ), - HcalAcceptSeverityLevel = cms.uint32( 11 ), - EEThreshold = cms.double( 0.3 ), - HOThresholdPlus1 = cms.double( 1.1 ), - HOThresholdPlus2 = cms.double( 1.1 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HF1Threshold = cms.double( 1.2 ), - HOThresholdMinus1 = cms.double( 1.1 ), - HESGrid = cms.vdouble( ), - EcutTower = cms.double( -1000.0 ), - UseRejectedRecoveredEcalHits = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - HESWeights = cms.vdouble( ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), - HEDWeight = cms.double( 1.0 ), - UseSymEETreshold = cms.bool( False ), - HEDThreshold = cms.double( 0.4 ), - EBThreshold = cms.double( 0.07 ), - UseRejectedHitsOnly = cms.bool( False ), - UseHcalRecoveredHits = cms.bool( True ), - HOThresholdMinus2 = cms.double( 1.1 ), - HOThreshold0 = cms.double( 1.1 ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), - UseRejectedRecoveredHcalHits = cms.bool( False ), - MomEBDepth = cms.double( 0.3 ), - HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ) -) -process.hltAK4CaloJetsPF = cms.EDProducer( "FastjetJetProducer", - Active_Area_Repeats = cms.int32( 5 ), - doAreaFastjet = cms.bool( False ), - voronoiRfact = cms.double( -9.0 ), - maxBadHcalCells = cms.uint32( 9999999 ), - doAreaDiskApprox = cms.bool( False ), - maxRecoveredEcalCells = cms.uint32( 9999999 ), - jetType = cms.string( "CaloJet" ), - minSeed = cms.uint32( 0 ), - Ghost_EtaMax = cms.double( 6.0 ), - doRhoFastjet = cms.bool( False ), - jetAlgorithm = cms.string( "AntiKt" ), - nSigmaPU = cms.double( 1.0 ), - GhostArea = cms.double( 0.01 ), - Rho_EtaMax = cms.double( 4.4 ), - maxBadEcalCells = cms.uint32( 9999999 ), - useDeterministicSeed = cms.bool( True ), - doPVCorrection = cms.bool( False ), - maxRecoveredHcalCells = cms.uint32( 9999999 ), - rParam = cms.double( 0.4 ), - maxProblematicHcalCells = cms.uint32( 9999999 ), - doOutputJets = cms.bool( True ), - src = cms.InputTag( "hltTowerMakerForPF" ), - inputEtMin = cms.double( 0.3 ), - puPtMin = cms.double( 10.0 ), - srcPVs = cms.InputTag( "NotUsed" ), - jetPtMin = cms.double( 1.0 ), - radiusPU = cms.double( 0.4 ), - maxProblematicEcalCells = cms.uint32( 9999999 ), - doPUOffsetCorr = cms.bool( False ), - inputEMin = cms.double( 0.0 ), - useMassDropTagger = cms.bool( False ), - muMin = cms.double( -1.0 ), - subtractorName = cms.string( "" ), - muCut = cms.double( -1.0 ), - subjetPtMin = cms.double( -1.0 ), - useTrimming = cms.bool( False ), - muMax = cms.double( -1.0 ), - yMin = cms.double( -1.0 ), - useFiltering = cms.bool( False ), - rFilt = cms.double( -1.0 ), - yMax = cms.double( -1.0 ), - zcut = cms.double( -1.0 ), - MinVtxNdof = cms.int32( 5 ), - MaxVtxZ = cms.double( 15.0 ), - UseOnlyVertexTracks = cms.bool( False ), - dRMin = cms.double( -1.0 ), - nFilt = cms.int32( -1 ), - usePruning = cms.bool( False ), - maxDepth = cms.int32( -1 ), - yCut = cms.double( -1.0 ), - DzTrVtxMax = cms.double( 0.0 ), - UseOnlyOnePV = cms.bool( False ), - rcut_factor = cms.double( -1.0 ), - sumRecHits = cms.bool( False ), - trimPtFracMin = cms.double( -1.0 ), - dRMax = cms.double( -1.0 ), - DxyTrVtxMax = cms.double( 0.0 ), - useCMSBoostedTauSeedingAlgorithm = cms.bool( False ) -) -process.hltAK4CaloJetsPFEt5 = cms.EDFilter( "EtMinCaloJetSelector", - filter = cms.bool( False ), - src = cms.InputTag( "hltAK4CaloJetsPF" ), - etMin = cms.double( 5.0 ) -) -process.hltPixelTracks = cms.EDProducer( "PixelTrackProducer", - useFilterWithES = cms.bool( False ), - FilterPSet = cms.PSet( - chi2 = cms.double( 1000.0 ), - nSigmaTipMaxTolerance = cms.double( 0.0 ), - ComponentName = cms.string( "PixelTrackFilterByKinematics" ), - nSigmaInvPtTolerance = cms.double( 0.0 ), - ptMin = cms.double( 0.1 ), - tipMax = cms.double( 1.0 ) - ), - passLabel = cms.string( "Pixel triplet primary tracks with vertex constraint" ), - FitterPSet = cms.PSet( - ComponentName = cms.string( "PixelFitterByHelixProjections" ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - fixImpactParameter = cms.double( 0.0 ) - ), - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "GlobalRegionProducerFromBeamSpot" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.2 ), - ptMin = cms.double( 0.9 ), - originHalfLength = cms.double( 24.0 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) - ) - ), - CleanerPSet = cms.PSet( ComponentName = cms.string( "PixelTrackCleanerBySharedHits" ) ), - OrderedHitsFactoryPSet = cms.PSet( - ComponentName = cms.string( "StandardHitTripletGenerator" ), - GeneratorPSet = cms.PSet( - useBending = cms.bool( True ), - useFixedPreFiltering = cms.bool( False ), - maxElement = cms.uint32( 100000 ), - phiPreFiltering = cms.double( 0.3 ), - extraHitRPhitolerance = cms.double( 0.06 ), - useMultScattering = cms.bool( True ), - SeedComparitorPSet = cms.PSet( - ComponentName = cms.string( "LowPtClusterShapeSeedComparitor" ), - clusterShapeCacheSrc = cms.InputTag( "hltSiPixelClustersCache" ) - ), - extraHitRZtolerance = cms.double( 0.06 ), - ComponentName = cms.string( "PixelTripletHLTGenerator" ) - ), - SeedingLayers = cms.InputTag( "hltPixelLayerTriplets" ) - ) +process.hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", + UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), + InputLabel = cms.InputTag( "rawDataRepacker" ), + IncludeErrors = cms.bool( False ), + ErrorList = cms.vint32( ), + Regions = cms.PSet( ), + Timing = cms.untracked.bool( False ), + UserErrorList = cms.vint32( ) +) +process.hltHISiPixelClusters = cms.EDProducer( "SiPixelClusterProducer", + src = cms.InputTag( "hltSiPixelDigis" ), + ChannelThreshold = cms.int32( 1000 ), + maxNumberOfClusters = cms.int32( -1 ), + VCaltoElectronGain = cms.int32( 65 ), + MissCalibrate = cms.untracked.bool( True ), + SplitClusters = cms.bool( False ), + VCaltoElectronOffset = cms.int32( -414 ), + payloadType = cms.string( "HLT" ), + SeedThreshold = cms.int32( 1000 ), + ClusterThreshold = cms.double( 4000.0 ) ) -process.hltPixelVertices = cms.EDProducer( "PixelVertexProducer", - WtAverage = cms.bool( True ), - Method2 = cms.bool( True ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - PVcomparer = cms.PSet( refToPSet_ = cms.string( "HLTPSetPvClusterComparerForIT" ) ), - Verbosity = cms.int32( 0 ), - UseError = cms.bool( True ), - TrackCollection = cms.InputTag( "hltPixelTracks" ), - PtMin = cms.double( 1.0 ), - NTrkMin = cms.int32( 2 ), - ZOffset = cms.double( 5.0 ), - Finder = cms.string( "DivisiveVertexFinder" ), - ZSeparation = cms.double( 0.05 ) -) -process.hltTrimmedPixelVertices = cms.EDProducer( "PixelVertexCollectionTrimmer", - minSumPt2 = cms.double( 0.0 ), - PVcomparer = cms.PSet( refToPSet_ = cms.string( "HLTPSetPvClusterComparerForIT" ) ), - maxVtx = cms.uint32( 100 ), - fractionSumPt2 = cms.double( 0.3 ), - src = cms.InputTag( "hltPixelVertices" ) -) -process.hltIter0PFLowPixelSeedsFromPixelTracks = cms.EDProducer( "SeedGeneratorFromProtoTracksEDProducer", - useEventsWithNoVertex = cms.bool( True ), - originHalfLength = cms.double( 0.3 ), - useProtoTrackKinematics = cms.bool( False ), - usePV = cms.bool( False ), - InputVertexCollection = cms.InputTag( "hltTrimmedPixelVertices" ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - InputCollection = cms.InputTag( "hltPixelTracks" ), - originRadius = cms.double( 0.1 ) -) -process.hltIter0PFlowCkfTrackCandidates = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter0PFLowPixelSeedsFromPixelTracks" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter0PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) +process.hltHISiPixelClustersCache = cms.EDProducer( "SiPixelClusterShapeCacheProducer", + src = cms.InputTag( "hltHISiPixelClusters" ), + onDemand = cms.bool( False ) ) -process.hltIter0PFlowCtfWithMaterialTracks = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter0PFlowCkfTrackCandidates" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIter0" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -process.hltIter0PFlowTrackSelectionHighPurity = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.4, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.35, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter0PFlowCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltTrimmedPixelVertices" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.4, 4.0 ), - d0_par1 = cms.vdouble( 0.3, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltTrackIter0RefsForJets4Iter1 = cms.EDProducer( "ChargedRefCandidateProducer", - src = cms.InputTag( "hltIter0PFlowTrackSelectionHighPurity" ), - particleType = cms.string( "pi+" ) -) -process.hltAK4Iter0TrackJets4Iter1 = cms.EDProducer( "FastjetJetProducer", - Active_Area_Repeats = cms.int32( 5 ), - doAreaFastjet = cms.bool( False ), - voronoiRfact = cms.double( 0.9 ), - maxBadHcalCells = cms.uint32( 9999999 ), - doAreaDiskApprox = cms.bool( False ), - maxRecoveredEcalCells = cms.uint32( 9999999 ), - jetType = cms.string( "TrackJet" ), - minSeed = cms.uint32( 14327 ), - Ghost_EtaMax = cms.double( 6.0 ), - doRhoFastjet = cms.bool( False ), - jetAlgorithm = cms.string( "AntiKt" ), - nSigmaPU = cms.double( 1.0 ), - GhostArea = cms.double( 0.01 ), - Rho_EtaMax = cms.double( 4.4 ), - maxBadEcalCells = cms.uint32( 9999999 ), - useDeterministicSeed = cms.bool( True ), - doPVCorrection = cms.bool( False ), - maxRecoveredHcalCells = cms.uint32( 9999999 ), - rParam = cms.double( 0.4 ), - maxProblematicHcalCells = cms.uint32( 9999999 ), - doOutputJets = cms.bool( True ), - src = cms.InputTag( "hltTrackIter0RefsForJets4Iter1" ), - inputEtMin = cms.double( 0.1 ), - puPtMin = cms.double( 0.0 ), - srcPVs = cms.InputTag( "hltTrimmedPixelVertices" ), - jetPtMin = cms.double( 1.0 ), - radiusPU = cms.double( 0.4 ), - maxProblematicEcalCells = cms.uint32( 9999999 ), - doPUOffsetCorr = cms.bool( False ), - inputEMin = cms.double( 0.0 ), - useMassDropTagger = cms.bool( False ), - muMin = cms.double( -1.0 ), - subtractorName = cms.string( "" ), - muCut = cms.double( -1.0 ), - subjetPtMin = cms.double( -1.0 ), - useTrimming = cms.bool( False ), - muMax = cms.double( -1.0 ), - yMin = cms.double( -1.0 ), - useFiltering = cms.bool( False ), - rFilt = cms.double( -1.0 ), - yMax = cms.double( -1.0 ), - zcut = cms.double( -1.0 ), - MinVtxNdof = cms.int32( 0 ), - MaxVtxZ = cms.double( 30.0 ), - UseOnlyVertexTracks = cms.bool( False ), - dRMin = cms.double( -1.0 ), - nFilt = cms.int32( -1 ), - usePruning = cms.bool( False ), - maxDepth = cms.int32( -1 ), - yCut = cms.double( -1.0 ), - DzTrVtxMax = cms.double( 0.5 ), - UseOnlyOnePV = cms.bool( True ), - rcut_factor = cms.double( -1.0 ), - sumRecHits = cms.bool( False ), - trimPtFracMin = cms.double( -1.0 ), - dRMax = cms.double( -1.0 ), - DxyTrVtxMax = cms.double( 0.2 ), - useCMSBoostedTauSeedingAlgorithm = cms.bool( False ) -) -process.hltIter0TrackAndTauJets4Iter1 = cms.EDProducer( "TauJetSelectorForHLTTrackSeeding", - fractionMinCaloInTauCone = cms.double( 0.7 ), - fractionMaxChargedPUInCaloCone = cms.double( 0.3 ), - tauConeSize = cms.double( 0.2 ), - ptTrkMaxInCaloCone = cms.double( 1.0 ), - isolationConeSize = cms.double( 0.5 ), - inputTrackJetTag = cms.InputTag( "hltAK4Iter0TrackJets4Iter1" ), - nTrkMaxInCaloCone = cms.int32( 0 ), - inputCaloJetTag = cms.InputTag( "hltAK4CaloJetsPFEt5" ), - etaMinCaloJet = cms.double( -2.7 ), - etaMaxCaloJet = cms.double( 2.7 ), - ptMinCaloJet = cms.double( 5.0 ), - inputTrackTag = cms.InputTag( "hltIter0PFlowTrackSelectionHighPurity" ) -) -process.hltIter1ClustersRefRemoval = cms.EDProducer( "TrackClusterRemover", - minNumberOfLayersWithMeasBeforeFiltering = cms.int32( 0 ), - maxChi2 = cms.double( 9.0 ), - trajectories = cms.InputTag( "hltIter0PFlowTrackSelectionHighPurity" ), - oldClusterRemovalInfo = cms.InputTag( "" ), - stripClusters = cms.InputTag( "hltSiStripRawToClustersFacility" ), - overrideTrkQuals = cms.InputTag( "" ), - pixelClusters = cms.InputTag( "hltSiPixelClusters" ), - TrackQuality = cms.string( "highPurity" ) -) -process.hltIter1MaskedMeasurementTrackerEvent = cms.EDProducer( "MaskedMeasurementTrackerEventProducer", - clustersToSkip = cms.InputTag( "hltIter1ClustersRefRemoval" ), - OnDemand = cms.bool( False ), - src = cms.InputTag( "hltSiStripClusters" ) -) -process.hltIter1PixelLayerTriplets = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2+BPix3', - 'BPix1+BPix2+FPix1_pos', - 'BPix1+BPix2+FPix1_neg', - 'BPix1+FPix1_pos+FPix2_pos', - 'BPix1+FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter1ClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0051 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter1ClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0027 ) - ), - TIB = cms.PSet( ) -) -process.hltIter1PFlowPixelSeeds = cms.EDProducer( "SeedGeneratorFromRegionHitsEDProducer", - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "CandidateSeededTrackingRegionsProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.05 ), - searchOpt = cms.bool( True ), - ptMin = cms.double( 0.5 ), - measurementTrackerName = cms.string( "hltIter1MaskedMeasurementTrackerEvent" ), - mode = cms.string( "VerticesFixed" ), - maxNRegions = cms.int32( 100 ), - maxNVertices = cms.int32( 10 ), - deltaPhi = cms.double( 1.0 ), - deltaEta = cms.double( 1.0 ), - zErrorBeamSpot = cms.double( 15.0 ), - nSigmaZBeamSpot = cms.double( 3.0 ), - zErrorVetex = cms.double( 0.1 ), - vertexCollection = cms.InputTag( "hltTrimmedPixelVertices" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - input = cms.InputTag( "hltIter0TrackAndTauJets4Iter1" ) - ) - ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ), - ClusterCheckPSet = cms.PSet( - PixelClusterCollectionLabel = cms.InputTag( "hltSiPixelClusters" ), - MaxNumberOfCosmicClusters = cms.uint32( 50000 ), - doClusterCheck = cms.bool( False ), - ClusterCollectionLabel = cms.InputTag( "hltSiStripClusters" ), - MaxNumberOfPixelClusters = cms.uint32( 10000 ) - ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitTripletGenerator" ), - GeneratorPSet = cms.PSet( - useBending = cms.bool( True ), - useFixedPreFiltering = cms.bool( False ), - maxElement = cms.uint32( 100000 ), - phiPreFiltering = cms.double( 0.3 ), - extraHitRPhitolerance = cms.double( 0.032 ), - useMultScattering = cms.bool( True ), - ComponentName = cms.string( "PixelTripletHLTGenerator" ), - extraHitRZtolerance = cms.double( 0.037 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) - ), - SeedingLayers = cms.InputTag( "hltIter1PixelLayerTriplets" ) - ), - SeedCreatorPSet = cms.PSet( - ComponentName = cms.string( "SeedFromConsecutiveHitsTripletOnlyCreator" ), - propagator = cms.string( "PropagatorWithMaterialParabolicMf" ), - SeedMomentumForBOFF = cms.double( 5.0 ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - TTRHBuilder = cms.string( "(unused)" ) +process.hltHISiPixelRecHits = cms.EDProducer( "SiPixelRecHitConverter", + VerboseLevel = cms.untracked.int32( 0 ), + src = cms.InputTag( "hltHISiPixelClusters" ), + CPE = cms.string( "hltESPPixelCPEGeneric" ) ) -process.hltIter1PFlowCkfTrackCandidates = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter1PFlowPixelSeeds" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter1MaskedMeasurementTrackerEvent" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter1PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) +process.hltSiStripExcludedFEDListProducer = cms.EDProducer( "SiStripExcludedFEDListProducer", + ProductLabel = cms.InputTag( "rawDataRepacker" ) ) -process.hltIter1PFlowCtfWithMaterialTracks = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter1PFlowCkfTrackCandidates" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter1MaskedMeasurementTrackerEvent" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIter1" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -process.hltIter1PFlowTrackSelectionHighPurityLoose = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.9, 3.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.8, 3.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter1PFlowCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltTrimmedPixelVertices" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.9, 3.0 ), - d0_par1 = cms.vdouble( 0.85, 3.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter1PFlowTrackSelectionHighPurityTight = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 5 ), - chi2n_par = cms.double( 0.4 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 1.0, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 1.0, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter1PFlowCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltTrimmedPixelVertices" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 1.0, 4.0 ), - d0_par1 = cms.vdouble( 1.0, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter1PFlowTrackSelectionHighPurity = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter1PFlowTrackSelectionHighPurityLoose','hltIter1PFlowTrackSelectionHighPurityTight' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter1PFlowTrackSelectionHighPurityLoose','hltIter1PFlowTrackSelectionHighPurityTight' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltIter1Merged = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter0PFlowTrackSelectionHighPurity','hltIter1PFlowTrackSelectionHighPurity' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter0PFlowTrackSelectionHighPurity','hltIter1PFlowTrackSelectionHighPurity' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltIter1TrackRefsForJets4Iter2 = cms.EDProducer( "ChargedRefCandidateProducer", - src = cms.InputTag( "hltIter1Merged" ), - particleType = cms.string( "pi+" ) -) -process.hltAK4Iter1TrackJets4Iter2 = cms.EDProducer( "FastjetJetProducer", - Active_Area_Repeats = cms.int32( 5 ), - doAreaFastjet = cms.bool( False ), - voronoiRfact = cms.double( 0.9 ), - maxBadHcalCells = cms.uint32( 9999999 ), - doAreaDiskApprox = cms.bool( False ), - maxRecoveredEcalCells = cms.uint32( 9999999 ), - jetType = cms.string( "TrackJet" ), - minSeed = cms.uint32( 14327 ), - Ghost_EtaMax = cms.double( 6.0 ), - doRhoFastjet = cms.bool( False ), - jetAlgorithm = cms.string( "AntiKt" ), - nSigmaPU = cms.double( 1.0 ), - GhostArea = cms.double( 0.01 ), - Rho_EtaMax = cms.double( 4.4 ), - maxBadEcalCells = cms.uint32( 9999999 ), - useDeterministicSeed = cms.bool( True ), - doPVCorrection = cms.bool( False ), - maxRecoveredHcalCells = cms.uint32( 9999999 ), - rParam = cms.double( 0.4 ), - maxProblematicHcalCells = cms.uint32( 9999999 ), - doOutputJets = cms.bool( True ), - src = cms.InputTag( "hltIter1TrackRefsForJets4Iter2" ), - inputEtMin = cms.double( 0.1 ), - puPtMin = cms.double( 0.0 ), - srcPVs = cms.InputTag( "hltTrimmedPixelVertices" ), - jetPtMin = cms.double( 7.5 ), - radiusPU = cms.double( 0.4 ), - maxProblematicEcalCells = cms.uint32( 9999999 ), - doPUOffsetCorr = cms.bool( False ), - inputEMin = cms.double( 0.0 ), - useMassDropTagger = cms.bool( False ), - muMin = cms.double( -1.0 ), - subtractorName = cms.string( "" ), - muCut = cms.double( -1.0 ), - subjetPtMin = cms.double( -1.0 ), - useTrimming = cms.bool( False ), - muMax = cms.double( -1.0 ), - yMin = cms.double( -1.0 ), - useFiltering = cms.bool( False ), - rFilt = cms.double( -1.0 ), - yMax = cms.double( -1.0 ), - zcut = cms.double( -1.0 ), - MinVtxNdof = cms.int32( 0 ), - MaxVtxZ = cms.double( 30.0 ), - UseOnlyVertexTracks = cms.bool( False ), - dRMin = cms.double( -1.0 ), - nFilt = cms.int32( -1 ), - usePruning = cms.bool( False ), - maxDepth = cms.int32( -1 ), - yCut = cms.double( -1.0 ), - DzTrVtxMax = cms.double( 0.5 ), - UseOnlyOnePV = cms.bool( True ), - rcut_factor = cms.double( -1.0 ), - sumRecHits = cms.bool( False ), - trimPtFracMin = cms.double( -1.0 ), - dRMax = cms.double( -1.0 ), - DxyTrVtxMax = cms.double( 0.2 ), - useCMSBoostedTauSeedingAlgorithm = cms.bool( False ) -) -process.hltIter1TrackAndTauJets4Iter2 = cms.EDProducer( "TauJetSelectorForHLTTrackSeeding", - fractionMinCaloInTauCone = cms.double( 0.7 ), - fractionMaxChargedPUInCaloCone = cms.double( 0.3 ), - tauConeSize = cms.double( 0.2 ), - ptTrkMaxInCaloCone = cms.double( 1.4 ), - isolationConeSize = cms.double( 0.5 ), - inputTrackJetTag = cms.InputTag( "hltAK4Iter1TrackJets4Iter2" ), - nTrkMaxInCaloCone = cms.int32( 0 ), - inputCaloJetTag = cms.InputTag( "hltAK4CaloJetsPFEt5" ), - etaMinCaloJet = cms.double( -2.7 ), - etaMaxCaloJet = cms.double( 2.7 ), - ptMinCaloJet = cms.double( 5.0 ), - inputTrackTag = cms.InputTag( "hltIter1Merged" ) -) -process.hltIter2ClustersRefRemoval = cms.EDProducer( "TrackClusterRemover", - minNumberOfLayersWithMeasBeforeFiltering = cms.int32( 0 ), - maxChi2 = cms.double( 16.0 ), - trajectories = cms.InputTag( "hltIter1PFlowTrackSelectionHighPurity" ), - oldClusterRemovalInfo = cms.InputTag( "hltIter1ClustersRefRemoval" ), - stripClusters = cms.InputTag( "hltSiStripRawToClustersFacility" ), - overrideTrkQuals = cms.InputTag( "" ), - pixelClusters = cms.InputTag( "hltSiPixelClusters" ), - TrackQuality = cms.string( "highPurity" ) -) -process.hltIter2MaskedMeasurementTrackerEvent = cms.EDProducer( "MaskedMeasurementTrackerEventProducer", - clustersToSkip = cms.InputTag( "hltIter2ClustersRefRemoval" ), - OnDemand = cms.bool( False ), - src = cms.InputTag( "hltSiStripClusters" ) -) -process.hltIter2PixelLayerPairs = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2', - 'BPix1+BPix3', - 'BPix2+BPix3', - 'BPix1+FPix1_pos', - 'BPix1+FPix1_neg', - 'BPix1+FPix2_pos', - 'BPix1+FPix2_neg', - 'BPix2+FPix1_pos', - 'BPix2+FPix1_neg', - 'BPix2+FPix2_pos', - 'BPix2+FPix2_neg', - 'FPix1_pos+FPix2_pos', - 'FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter2ClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0051 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter2ClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0027 ) - ), - TIB = cms.PSet( ) -) -process.hltIter2PFlowPixelSeeds = cms.EDProducer( "SeedGeneratorFromRegionHitsEDProducer", - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "CandidateSeededTrackingRegionsProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.025 ), - searchOpt = cms.bool( True ), - originZPos = cms.double( 0.0 ), - ptMin = cms.double( 1.2 ), - measurementTrackerName = cms.string( "hltIter2MaskedMeasurementTrackerEvent" ), - mode = cms.string( "VerticesFixed" ), - maxNRegions = cms.int32( 100 ), - maxNVertices = cms.int32( 10 ), - deltaPhi = cms.double( 0.8 ), - deltaEta = cms.double( 0.8 ), - zErrorBeamSpot = cms.double( 15.0 ), - nSigmaZBeamSpot = cms.double( 3.0 ), - zErrorVetex = cms.double( 0.05 ), - vertexCollection = cms.InputTag( "hltTrimmedPixelVertices" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - input = cms.InputTag( "hltIter1TrackAndTauJets4Iter2" ) - ) - ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ), - ClusterCheckPSet = cms.PSet( - PixelClusterCollectionLabel = cms.InputTag( "hltSiPixelClusters" ), - MaxNumberOfCosmicClusters = cms.uint32( 50000 ), - doClusterCheck = cms.bool( False ), - ClusterCollectionLabel = cms.InputTag( "hltSiStripClusters" ), - MaxNumberOfPixelClusters = cms.uint32( 10000 ) - ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitPairGenerator" ), - GeneratorPSet = cms.PSet( - maxElement = cms.uint32( 100000 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) - ), - SeedingLayers = cms.InputTag( "hltIter2PixelLayerPairs" ) +process.hltSiStripRawToClustersFacility = cms.EDProducer( "SiStripClusterizerFromRaw", + ProductLabel = cms.InputTag( "rawDataRepacker" ), + DoAPVEmulatorCheck = cms.bool( False ), + Algorithms = cms.PSet( + SiStripFedZeroSuppressionMode = cms.uint32( 4 ), + CommonModeNoiseSubtractionMode = cms.string( "Median" ), + PedestalSubtractionFedMode = cms.bool( True ), + TruncateInSuppressor = cms.bool( True ), + doAPVRestore = cms.bool( False ), + useCMMeanMap = cms.bool( False ) ), - SeedCreatorPSet = cms.PSet( - ComponentName = cms.string( "SeedFromConsecutiveHitsCreator" ), - propagator = cms.string( "PropagatorWithMaterialParabolicMf" ), - SeedMomentumForBOFF = cms.double( 5.0 ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + Clusterizer = cms.PSet( + ChannelThreshold = cms.double( 2.0 ), + MaxSequentialBad = cms.uint32( 1 ), + MaxSequentialHoles = cms.uint32( 0 ), + Algorithm = cms.string( "ThreeThresholdAlgorithm" ), + MaxAdjacentBad = cms.uint32( 0 ), + QualityLabel = cms.string( "" ), + SeedThreshold = cms.double( 3.0 ), + ClusterThreshold = cms.double( 5.0 ), + setDetId = cms.bool( True ), + RemoveApvShots = cms.bool( True ) ), - TTRHBuilder = cms.string( "(unused)" ) + onDemand = cms.bool( True ) ) -process.hltIter2PFlowCkfTrackCandidates = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter2PFlowPixelSeeds" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter2MaskedMeasurementTrackerEvent" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter2PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) +process.hltHISiStripClusters = cms.EDProducer( "MeasurementTrackerEventProducer", + inactivePixelDetectorLabels = cms.VInputTag( ), + stripClusterProducer = cms.string( "hltSiStripRawToClustersFacility" ), + pixelClusterProducer = cms.string( "hltHISiPixelClusters" ), + switchOffPixelsIfEmpty = cms.bool( True ), + inactiveStripDetectorLabels = cms.VInputTag( 'hltSiStripExcludedFEDListProducer' ), + skipClusters = cms.InputTag( "" ), + measurementTracker = cms.string( "hltESPMeasurementTracker" ) ) -process.hltIter2PFlowCtfWithMaterialTracks = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter2PFlowCkfTrackCandidates" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter2MaskedMeasurementTrackerEvent" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIter2" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -process.hltIter2PFlowTrackSelectionHighPurity = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.4, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.35, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter2PFlowCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltTrimmedPixelVertices" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.4, 4.0 ), - d0_par1 = cms.vdouble( 0.3, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter2Merged = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter1Merged','hltIter2PFlowTrackSelectionHighPurity' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter1Merged','hltIter2PFlowTrackSelectionHighPurity' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltPFMuonMerging = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltL3TkTracksFromL2','hltIter2Merged' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltL3TkTracksFromL2','hltIter2Merged' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltMuonLinks = cms.EDProducer( "MuonLinksProducerForHLT", - pMin = cms.double( 2.5 ), - InclusiveTrackerTrackCollection = cms.InputTag( "hltPFMuonMerging" ), - shareHitFraction = cms.double( 0.8 ), - LinkCollection = cms.InputTag( "hltL3MuonsLinksCombination" ), - ptMin = cms.double( 2.5 ) -) -process.hltMuons = cms.EDProducer( "MuonIdProducer", - TrackExtractorPSet = cms.PSet( - Diff_z = cms.double( 0.2 ), - inputTrackCollection = cms.InputTag( "hltPFMuonMerging" ), - BeamSpotLabel = cms.InputTag( "hltOnlineBeamSpot" ), - ComponentName = cms.string( "TrackExtractor" ), - DR_Max = cms.double( 1.0 ), - Diff_r = cms.double( 0.1 ), - Chi2Prob_Min = cms.double( -1.0 ), - DR_Veto = cms.double( 0.01 ), - NHits_Min = cms.uint32( 0 ), - Chi2Ndof_Max = cms.double( 1.0E64 ), - Pt_Min = cms.double( -1.0 ), - DepositLabel = cms.untracked.string( "" ), - BeamlineOption = cms.string( "BeamSpotFromEvent" ) - ), - maxAbsEta = cms.double( 3.0 ), - fillGlobalTrackRefits = cms.bool( False ), - arbitrationCleanerOptions = cms.PSet( - Clustering = cms.bool( True ), - ME1a = cms.bool( True ), - ClusterDPhi = cms.double( 0.6 ), - OverlapDTheta = cms.double( 0.02 ), - Overlap = cms.bool( True ), - OverlapDPhi = cms.double( 0.0786 ), - ClusterDTheta = cms.double( 0.02 ) - ), - globalTrackQualityInputTag = cms.InputTag( "glbTrackQual" ), - addExtraSoftMuons = cms.bool( False ), - debugWithTruthMatching = cms.bool( False ), - CaloExtractorPSet = cms.PSet( - PrintTimeReport = cms.untracked.bool( False ), - DR_Max = cms.double( 1.0 ), - DepositInstanceLabels = cms.vstring( 'ecal', - 'hcal', - 'ho' ), - Noise_HE = cms.double( 0.2 ), - NoiseTow_EB = cms.double( 0.04 ), - NoiseTow_EE = cms.double( 0.15 ), - Threshold_H = cms.double( 0.5 ), - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPFastSteppingHelixPropagatorAny' ), - RPCLayers = cms.bool( False ), - UseMuonNavigation = cms.untracked.bool( False ) - ), - Threshold_E = cms.double( 0.2 ), - PropagatorName = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - DepositLabel = cms.untracked.string( "Cal" ), - UseRecHitsFlag = cms.bool( False ), - TrackAssociatorParameters = cms.PSet( - muonMaxDistanceSigmaX = cms.double( 0.0 ), - muonMaxDistanceSigmaY = cms.double( 0.0 ), - CSCSegmentCollectionLabel = cms.InputTag( "hltCscSegments" ), - dRHcal = cms.double( 1.0 ), - dRPreshowerPreselection = cms.double( 0.2 ), - CaloTowerCollectionLabel = cms.InputTag( "hltTowerMakerForPF" ), - useEcal = cms.bool( False ), - dREcal = cms.double( 1.0 ), - dREcalPreselection = cms.double( 1.0 ), - HORecHitCollectionLabel = cms.InputTag( "hltHoreco" ), - dRMuon = cms.double( 9999.0 ), - propagateAllDirections = cms.bool( True ), - muonMaxDistanceX = cms.double( 5.0 ), - muonMaxDistanceY = cms.double( 5.0 ), - useHO = cms.bool( False ), - trajectoryUncertaintyTolerance = cms.double( -1.0 ), - usePreshower = cms.bool( False ), - DTRecSegment4DCollectionLabel = cms.InputTag( "hltDt4DSegments" ), - EERecHitCollectionLabel = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEE' ), - dRHcalPreselection = cms.double( 1.0 ), - useMuon = cms.bool( False ), - useCalo = cms.bool( True ), - accountForTrajectoryChangeCalo = cms.bool( False ), - EBRecHitCollectionLabel = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEB' ), - dRMuonPreselection = cms.double( 0.2 ), - truthMatch = cms.bool( False ), - HBHERecHitCollectionLabel = cms.InputTag( "hltHbhereco" ), - useHcal = cms.bool( False ) - ), - Threshold_HO = cms.double( 0.5 ), - Noise_EE = cms.double( 0.1 ), - Noise_EB = cms.double( 0.025 ), - DR_Veto_H = cms.double( 0.1 ), - CenterConeOnCalIntersection = cms.bool( False ), - ComponentName = cms.string( "CaloExtractorByAssociator" ), - Noise_HB = cms.double( 0.2 ), - DR_Veto_E = cms.double( 0.07 ), - DR_Veto_HO = cms.double( 0.1 ), - Noise_HO = cms.double( 0.2 ) - ), - runArbitrationCleaner = cms.bool( False ), - fillEnergy = cms.bool( True ), - TrackerKinkFinderParameters = cms.PSet( - usePosition = cms.bool( False ), - diagonalOnly = cms.bool( False ) - ), - TimingFillerParameters = cms.PSet( - UseDT = cms.bool( True ), - ErrorDT = cms.double( 6.0 ), - EcalEnergyCut = cms.double( 0.4 ), - ErrorEB = cms.double( 2.085 ), - ErrorCSC = cms.double( 7.4 ), - CSCTimingParameters = cms.PSet( - CSCsegments = cms.InputTag( "hltCscSegments" ), - CSCTimeOffset = cms.double( 0.0 ), - CSCStripTimeOffset = cms.double( 0.0 ), - MatchParameters = cms.PSet( - CSCsegments = cms.InputTag( "hltCscSegments" ), - DTsegments = cms.InputTag( "hltDt4DSegments" ), - DTradius = cms.double( 0.01 ), - TightMatchDT = cms.bool( False ), - TightMatchCSC = cms.bool( True ) - ), - debug = cms.bool( False ), - UseStripTime = cms.bool( True ), - CSCStripError = cms.double( 7.0 ), - CSCWireError = cms.double( 8.6 ), - CSCWireTimeOffset = cms.double( 0.0 ), - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPFastSteppingHelixPropagatorAny' ), - RPCLayers = cms.bool( True ) - ), - PruneCut = cms.double( 100.0 ), - UseWireTime = cms.bool( True ) - ), - DTTimingParameters = cms.PSet( - HitError = cms.double( 6.0 ), - DoWireCorr = cms.bool( False ), - MatchParameters = cms.PSet( - CSCsegments = cms.InputTag( "hltCscSegments" ), - DTsegments = cms.InputTag( "hltDt4DSegments" ), - DTradius = cms.double( 0.01 ), - TightMatchDT = cms.bool( False ), - TightMatchCSC = cms.bool( True ) - ), - debug = cms.bool( False ), - DTsegments = cms.InputTag( "hltDt4DSegments" ), - PruneCut = cms.double( 10000.0 ), - RequireBothProjections = cms.bool( False ), - HitsMin = cms.int32( 5 ), - DTTimeOffset = cms.double( 2.7 ), - DropTheta = cms.bool( True ), - UseSegmentT0 = cms.bool( False ), - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPFastSteppingHelixPropagatorAny' ), - RPCLayers = cms.bool( True ) - ) - ), - ErrorEE = cms.double( 6.95 ), - UseCSC = cms.bool( True ), - UseECAL = cms.bool( True ) - ), - inputCollectionTypes = cms.vstring( 'inner tracks', - 'links', - 'outer tracks' ), - minCaloCompatibility = cms.double( 0.6 ), - ecalDepositName = cms.string( "ecal" ), - minP = cms.double( 10.0 ), - fillIsolation = cms.bool( True ), - jetDepositName = cms.string( "jets" ), - hoDepositName = cms.string( "ho" ), - writeIsoDeposits = cms.bool( False ), - maxAbsPullX = cms.double( 4.0 ), - maxAbsPullY = cms.double( 9999.0 ), - minPt = cms.double( 10.0 ), - TrackAssociatorParameters = cms.PSet( - muonMaxDistanceSigmaX = cms.double( 0.0 ), - muonMaxDistanceSigmaY = cms.double( 0.0 ), - CSCSegmentCollectionLabel = cms.InputTag( "hltCscSegments" ), - dRHcal = cms.double( 9999.0 ), - dRPreshowerPreselection = cms.double( 0.2 ), - CaloTowerCollectionLabel = cms.InputTag( "hltTowerMakerForPF" ), - useEcal = cms.bool( True ), - dREcal = cms.double( 9999.0 ), - dREcalPreselection = cms.double( 0.05 ), - HORecHitCollectionLabel = cms.InputTag( "hltHoreco" ), - dRMuon = cms.double( 9999.0 ), - propagateAllDirections = cms.bool( True ), - muonMaxDistanceX = cms.double( 5.0 ), - muonMaxDistanceY = cms.double( 5.0 ), - useHO = cms.bool( True ), - trajectoryUncertaintyTolerance = cms.double( -1.0 ), - usePreshower = cms.bool( False ), - DTRecSegment4DCollectionLabel = cms.InputTag( "hltDt4DSegments" ), - EERecHitCollectionLabel = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEE' ), - dRHcalPreselection = cms.double( 0.2 ), - useMuon = cms.bool( True ), - useCalo = cms.bool( False ), - accountForTrajectoryChangeCalo = cms.bool( False ), - EBRecHitCollectionLabel = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEB' ), - dRMuonPreselection = cms.double( 0.2 ), - truthMatch = cms.bool( False ), - HBHERecHitCollectionLabel = cms.InputTag( "hltHbhereco" ), - useHcal = cms.bool( True ) - ), - JetExtractorPSet = cms.PSet( - PrintTimeReport = cms.untracked.bool( False ), - ExcludeMuonVeto = cms.bool( True ), - TrackAssociatorParameters = cms.PSet( - muonMaxDistanceSigmaX = cms.double( 0.0 ), - muonMaxDistanceSigmaY = cms.double( 0.0 ), - CSCSegmentCollectionLabel = cms.InputTag( "hltCscSegments" ), - dRHcal = cms.double( 0.5 ), - dRPreshowerPreselection = cms.double( 0.2 ), - CaloTowerCollectionLabel = cms.InputTag( "hltTowerMakerForPF" ), - useEcal = cms.bool( False ), - dREcal = cms.double( 0.5 ), - dREcalPreselection = cms.double( 0.5 ), - HORecHitCollectionLabel = cms.InputTag( "hltHoreco" ), - dRMuon = cms.double( 9999.0 ), - propagateAllDirections = cms.bool( True ), - muonMaxDistanceX = cms.double( 5.0 ), - muonMaxDistanceY = cms.double( 5.0 ), - useHO = cms.bool( False ), - trajectoryUncertaintyTolerance = cms.double( -1.0 ), - usePreshower = cms.bool( False ), - DTRecSegment4DCollectionLabel = cms.InputTag( "hltDt4DSegments" ), - EERecHitCollectionLabel = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEE' ), - dRHcalPreselection = cms.double( 0.5 ), - useMuon = cms.bool( False ), - useCalo = cms.bool( True ), - accountForTrajectoryChangeCalo = cms.bool( False ), - EBRecHitCollectionLabel = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEB' ), - dRMuonPreselection = cms.double( 0.2 ), - truthMatch = cms.bool( False ), - HBHERecHitCollectionLabel = cms.InputTag( "hltHbhereco" ), - useHcal = cms.bool( False ) - ), - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPFastSteppingHelixPropagatorAny' ), - RPCLayers = cms.bool( False ), - UseMuonNavigation = cms.untracked.bool( False ) - ), - ComponentName = cms.string( "JetExtractor" ), - DR_Max = cms.double( 1.0 ), - PropagatorName = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - JetCollectionLabel = cms.InputTag( "hltAK4CaloJetsPFEt5" ), - DR_Veto = cms.double( 0.1 ), - Threshold = cms.double( 5.0 ) - ), - fillGlobalTrackQuality = cms.bool( False ), - minPCaloMuon = cms.double( 1.0E9 ), - maxAbsDy = cms.double( 9999.0 ), - fillCaloCompatibility = cms.bool( True ), - fillMatching = cms.bool( True ), - MuonCaloCompatibility = cms.PSet( - allSiPMHO = cms.bool( False ), - PionTemplateFileName = cms.FileInPath( "RecoMuon/MuonIdentification/data/MuID_templates_pions_lowPt_3_1_norm.root" ), - MuonTemplateFileName = cms.FileInPath( "RecoMuon/MuonIdentification/data/MuID_templates_muons_lowPt_3_1_norm.root" ), - delta_eta = cms.double( 0.02 ), - delta_phi = cms.double( 0.02 ) - ), - fillTrackerKink = cms.bool( False ), - hcalDepositName = cms.string( "hcal" ), - sigmaThresholdToFillCandidateP4WithGlobalFit = cms.double( 2.0 ), - inputCollectionLabels = cms.VInputTag( 'hltPFMuonMerging','hltMuonLinks','hltL2Muons' ), - trackDepositName = cms.string( "tracker" ), - maxAbsDx = cms.double( 3.0 ), - ptThresholdToFillCandidateP4WithGlobalFit = cms.double( 200.0 ), - minNumberOfMatches = cms.int32( 1 ) -) -process.hltParticleFlowRecHitECALUnseeded = cms.EDProducer( "PFRecHitProducer", - producers = cms.VPSet( - cms.PSet( src = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEB' ), - qualityTests = cms.VPSet( - cms.PSet( threshold = cms.double( 0.08 ), - name = cms.string( "PFRecHitQTestThreshold" ) +process.hltHIL3TrajSeedOIState = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + propagatorCompatibleName = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + option = cms.uint32( 3 ), + maxChi2 = cms.double( 40.0 ), + errorMatrixPset = cms.PSet( + atIP = cms.bool( True ), + action = cms.string( "use" ), + errorMatrixValuesPSet = cms.PSet( + pf3_V12 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) ), - cms.PSet( timingCleaning = cms.bool( True ), - topologicalCleaning = cms.bool( True ), - cleaningThreshold = cms.double( 2.0 ), - skipTTRecoveredHits = cms.bool( True ), - name = cms.string( "PFRecHitQTestECAL" ) - ) - ), - name = cms.string( "PFEBRecHitCreator" ) - ), - cms.PSet( src = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEE' ), - qualityTests = cms.VPSet( - cms.PSet( threshold = cms.double( 0.3 ), - name = cms.string( "PFRecHitQTestThreshold" ) + pf3_V13 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) ), - cms.PSet( timingCleaning = cms.bool( True ), - topologicalCleaning = cms.bool( True ), - cleaningThreshold = cms.double( 2.0 ), - skipTTRecoveredHits = cms.bool( True ), - name = cms.string( "PFRecHitQTestECAL" ) - ) - ), - name = cms.string( "PFEERecHitCreator" ) - ) - ), - navigator = cms.PSet( - barrel = cms.PSet( ), - endcap = cms.PSet( ), - name = cms.string( "PFRecHitECALNavigator" ) - ) -) -process.hltParticleFlowRecHitHCAL = cms.EDProducer( "PFCTRecHitProducer", - ECAL_Compensate = cms.bool( False ), - ECAL_Dead_Code = cms.uint32( 10 ), - MinLongTiming_Cut = cms.double( -5.0 ), - ECAL_Compensation = cms.double( 0.5 ), - MaxLongTiming_Cut = cms.double( 5.0 ), - weight_HFhad = cms.double( 1.0 ), - ApplyPulseDPG = cms.bool( False ), - navigator = cms.PSet( name = cms.string( "PFRecHitCaloTowerNavigator" ) ), - ECAL_Threshold = cms.double( 10.0 ), - ApplyTimeDPG = cms.bool( False ), - caloTowers = cms.InputTag( "hltTowerMakerForPF" ), - hcalRecHitsHBHE = cms.InputTag( "hltHbhereco" ), - LongFibre_Fraction = cms.double( 0.1 ), - MaxShortTiming_Cut = cms.double( 5.0 ), - HcalMaxAllowedHFLongShortSev = cms.int32( 9 ), - thresh_Barrel = cms.double( 0.4 ), - navigation_HF = cms.bool( True ), - HcalMaxAllowedHFInTimeWindowSev = cms.int32( 9 ), - HF_Calib_29 = cms.double( 1.07 ), - LongFibre_Cut = cms.double( 120.0 ), - EM_Depth = cms.double( 22.0 ), - weight_HFem = cms.double( 1.0 ), - LongShortFibre_Cut = cms.double( 1.0E9 ), - MinShortTiming_Cut = cms.double( -5.0 ), - HCAL_Calib = cms.bool( True ), - thresh_HF = cms.double( 0.4 ), - HcalMaxAllowedHFDigiTimeSev = cms.int32( 9 ), - thresh_Endcap = cms.double( 0.4 ), - HcalMaxAllowedChannelStatusSev = cms.int32( 9 ), - hcalRecHitsHF = cms.InputTag( "hltHfreco" ), - ShortFibre_Cut = cms.double( 60.0 ), - ApplyLongShortDPG = cms.bool( True ), - HF_Calib = cms.bool( True ), - HAD_Depth = cms.double( 47.0 ), - ShortFibre_Fraction = cms.double( 0.01 ), - HCAL_Calib_29 = cms.double( 1.35 ) -) -process.hltParticleFlowRecHitPSUnseeded = cms.EDProducer( "PFRecHitProducer", - producers = cms.VPSet( - cms.PSet( src = cms.InputTag( 'hltEcalPreshowerRecHit','EcalRecHitsES' ), - qualityTests = cms.VPSet( - cms.PSet( threshold = cms.double( 7.0E-6 ), - name = cms.string( "PFRecHitQTestThreshold" ) - ) - ), - name = cms.string( "PFPSRecHitCreator" ) - ) - ), - navigator = cms.PSet( name = cms.string( "PFRecHitPreshowerNavigator" ) ) -) -process.hltParticleFlowClusterECALUncorrectedUnseeded = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.08 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( 9 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - minFracTot = cms.double( 1.0E-20 ), - positionCalcForConvergence = cms.PSet( - minFractionInCalc = cms.double( 0.0 ), - W0 = cms.double( 4.2 ), - minAllowedNormalization = cms.double( 0.0 ), - T0_EB = cms.double( 7.4 ), - X0 = cms.double( 0.89 ), - T0_ES = cms.double( 1.2 ), - T0_EE = cms.double( 3.1 ), - algoName = cms.string( "ECAL2DPositionCalcWithDepthCorr" ) - ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 1.5 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "ECAL_BARREL" ), - recHitEnergyNorm = cms.double( 0.08 ) - ), - cms.PSet( detector = cms.string( "ECAL_ENDCAP" ), - recHitEnergyNorm = cms.double( 0.3 ) - ) - ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ), - allCellsPositionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.08 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ) - ), - positionReCalc = cms.PSet( - minFractionInCalc = cms.double( 0.0 ), - W0 = cms.double( 4.2 ), - minAllowedNormalization = cms.double( 0.0 ), - T0_EB = cms.double( 7.4 ), - X0 = cms.double( 0.89 ), - T0_ES = cms.double( 1.2 ), - T0_EE = cms.double( 3.1 ), - algoName = cms.string( "ECAL2DPositionCalcWithDepthCorr" ) - ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 0.08 ), - detector = cms.string( "ECAL_BARREL" ), - gatheringThresholdPt = cms.double( 0.0 ) - ), - cms.PSet( gatheringThreshold = cms.double( 0.3 ), - detector = cms.string( "ECAL_ENDCAP" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) - ), - useCornerCells = cms.bool( True ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - cms.PSet( cleaningByDetector = cms.VPSet( - cms.PSet( doubleSpikeS6S2 = cms.double( 0.04 ), - fractionThresholdModifier = cms.double( 3.0 ), - doubleSpikeThresh = cms.double( 10.0 ), - minS4S1_b = cms.double( -0.024 ), - singleSpikeThresh = cms.double( 4.0 ), - detector = cms.string( "ECAL_BARREL" ), - minS4S1_a = cms.double( 0.04 ), - energyThresholdModifier = cms.double( 2.0 ) - ), - cms.PSet( doubleSpikeS6S2 = cms.double( -1.0 ), - fractionThresholdModifier = cms.double( 3.0 ), - doubleSpikeThresh = cms.double( 1.0E9 ), - minS4S1_b = cms.double( -0.0125 ), - singleSpikeThresh = cms.double( 15.0 ), - detector = cms.string( "ECAL_ENDCAP" ), - minS4S1_a = cms.double( 0.02 ), - energyThresholdModifier = cms.double( 2.0 ) - ) -), - algoName = cms.string( "SpikeAndDoubleSpikeCleaner" ) - ) - ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 8 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 0.6 ), - seedingThresholdPt = cms.double( 0.15 ), - detector = cms.string( "ECAL_ENDCAP" ) - ), - cms.PSet( seedingThreshold = cms.double( 0.23 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "ECAL_BARREL" ) - ) - ), - algoName = cms.string( "LocalMaximumSeedFinder" ) - ), - recHitsSource = cms.InputTag( "hltParticleFlowRecHitECALUnseeded" ) -) -process.hltParticleFlowClusterPSUnseeded = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - minFracTot = cms.double( 1.0E-20 ), - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 6.0E-5 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 0.3 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "PS1" ), - recHitEnergyNorm = cms.double( 6.0E-5 ) - ), - cms.PSet( detector = cms.string( "PS2" ), - recHitEnergyNorm = cms.double( 6.0E-5 ) - ) - ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ) - ), - positionReCalc = cms.PSet( ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 6.0E-5 ), - detector = cms.string( "PS1" ), - gatheringThresholdPt = cms.double( 0.0 ) - ), - cms.PSet( gatheringThreshold = cms.double( 6.0E-5 ), - detector = cms.string( "PS2" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) - ), - useCornerCells = cms.bool( False ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 4 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 1.2E-4 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "PS1" ) - ), - cms.PSet( seedingThreshold = cms.double( 1.2E-4 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "PS2" ) - ) - ), - algoName = cms.string( "LocalMaximumSeedFinder" ) - ), - recHitsSource = cms.InputTag( "hltParticleFlowRecHitPSUnseeded" ) -) -process.hltParticleFlowClusterECALUnseeded = cms.EDProducer( "CorrectedECALPFClusterProducer", - inputPS = cms.InputTag( "hltParticleFlowClusterPSUnseeded" ), - minimumPSEnergy = cms.double( 0.0 ), - energyCorrector = cms.PSet( - applyCrackCorrections = cms.bool( False ), - algoName = cms.string( "PFClusterEMEnergyCorrector" ) - ), - inputECAL = cms.InputTag( "hltParticleFlowClusterECALUncorrectedUnseeded" ) -) -process.hltParticleFlowClusterHCAL = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( 5 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - minFracTot = cms.double( 1.0E-20 ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 10.0 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "HCAL_BARREL1" ), - recHitEnergyNorm = cms.double( 0.8 ) - ), - cms.PSet( detector = cms.string( "HCAL_ENDCAP" ), - recHitEnergyNorm = cms.double( 0.8 ) - ) - ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ), - allCellsPositionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ) - ), - positionReCalc = cms.PSet( ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 0.8 ), - detector = cms.string( "HCAL_BARREL1" ), - gatheringThresholdPt = cms.double( 0.0 ) - ), - cms.PSet( gatheringThreshold = cms.double( 0.8 ), - detector = cms.string( "HCAL_ENDCAP" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) - ), - useCornerCells = cms.bool( True ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - cms.PSet( algoName = cms.string( "RBXAndHPDCleaner" ) ) - ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 4 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 0.8 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "HCAL_BARREL1" ) - ), - cms.PSet( seedingThreshold = cms.double( 1.1 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "HCAL_ENDCAP" ) + pf3_V11 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V14 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V15 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), + pf3_V33 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + zAxis = cms.vdouble( -3.14159, 3.14159 ), + pf3_V44 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), + pf3_V22 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V23 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V45 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V55 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V34 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V35 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V25 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V24 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ) ) ), - algoName = cms.string( "LocalMaximumSeedFinder" ) + propagatorName = cms.string( "hltESPSteppingHelixPropagatorAlong" ), + manySeeds = cms.bool( False ), + copyMuonRecHit = cms.bool( False ), + ComponentName = cms.string( "TSGForRoadSearch" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ) ), - recHitsSource = cms.InputTag( "hltParticleFlowRecHitHCAL" ) -) -process.hltParticleFlowClusterHFEM = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( 5 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - minFracTot = cms.double( 1.0E-20 ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 10.0 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "HF_EM" ), - recHitEnergyNorm = cms.double( 0.8 ) - ) - ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ), - allCellsPositionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ) + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSteppingHelixPropagatorOpposite', + 'hltESPSteppingHelixPropagatorAlong' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) ), - positionReCalc = cms.PSet( ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 0.8 ), - detector = cms.string( "HF_EM" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) - ), - useCornerCells = cms.bool( False ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( ), + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( ), + PtCut = cms.double( 1.0 ) +) +process.hltHIL3TrackCandidateFromL2OIState = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedOIState" ), + reverseTrajectories = cms.bool( True ), + TransientInitialStateEstimatorParameters = cms.PSet( + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), + numberMeasurementsForFit = cms.int32( 4 ), + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - cms.PSet( cleaningByDetector = cms.VPSet( - cms.PSet( doubleSpikeS6S2 = cms.double( -1.0 ), - fractionThresholdModifier = cms.double( 1.0 ), - doubleSpikeThresh = cms.double( 1.0E9 ), - minS4S1_b = cms.double( -0.19 ), - singleSpikeThresh = cms.double( 80.0 ), - detector = cms.string( "HF_EM" ), - minS4S1_a = cms.double( 0.11 ), - energyThresholdModifier = cms.double( 1.0 ) - ) -), - algoName = cms.string( "SpikeAndDoubleSpikeCleaner" ) - ) + TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + cleanTrajectoryAfterInOut = cms.bool( False ), + useHitsSplitting = cms.bool( False ), + RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), + doSeedingRegionRebuilding = cms.bool( False ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilderSeedHit" ) ), + NavigationSchool = cms.string( "SimpleNavigationSchool" ), + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) +) +process.hltHIL3TkTracksFromL2OIState = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2OIState" ), + SimpleMagneticField = cms.string( "" ), + clusterRemovalInfo = cms.InputTag( "" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), + useHitsSplitting = cms.bool( False ), + MeasurementTracker = cms.string( "" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), + NavigationSchool = cms.string( "" ), + TrajectoryInEvent = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + GeometricInnerState = cms.bool( True ), + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +process.hltHIL3MuonsOIState = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 0 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 1.4 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "HF_EM" ) - ) + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) ), - algoName = cms.string( "LocalMaximumSeedFinder" ) - ), - recHitsSource = cms.InputTag( 'hltParticleFlowRecHitHCAL','HFEM' ) -) -process.hltParticleFlowClusterHFHAD = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( 5 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) ), - minFracTot = cms.double( 1.0E-20 ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 10.0 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "HF_HAD" ), - recHitEnergyNorm = cms.double( 0.8 ) - ) + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ), - allCellsPositionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ) - ), - positionReCalc = cms.PSet( ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 0.8 ), - detector = cms.string( "HF_HAD" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) ), - useCornerCells = cms.bool( False ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - cms.PSet( cleaningByDetector = cms.VPSet( - cms.PSet( doubleSpikeS6S2 = cms.double( -1.0 ), - fractionThresholdModifier = cms.double( 1.0 ), - doubleSpikeThresh = cms.double( 1.0E9 ), - minS4S1_b = cms.double( -0.08 ), - singleSpikeThresh = cms.double( 120.0 ), - detector = cms.string( "HF_HAD" ), - minS4S1_a = cms.double( 0.045 ), - energyThresholdModifier = cms.double( 1.0 ) - ) -), - algoName = cms.string( "SpikeAndDoubleSpikeCleaner" ) - ) + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2OIState" ), + tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 0 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 1.4 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "HF_HAD" ) - ) + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) ), - algoName = cms.string( "LocalMaximumSeedFinder" ) + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) ), - recHitsSource = cms.InputTag( 'hltParticleFlowRecHitHCAL','HFHAD' ) -) -process.hltLightPFTracks = cms.EDProducer( "LightPFTrackProducer", - TrackQuality = cms.string( "none" ), - UseQuality = cms.bool( False ), - TkColList = cms.VInputTag( 'hltPFMuonMerging' ) + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) ) -process.hltParticleFlowBlock = cms.EDProducer( "PFBlockProducer", - debug = cms.untracked.bool( False ), - linkDefinitions = cms.VPSet( - cms.PSet( useKDTree = cms.bool( True ), - linkType = cms.string( "PS1:ECAL" ), - linkerName = cms.string( "PreshowerAndECALLinker" ) - ), - cms.PSet( useKDTree = cms.bool( True ), - linkType = cms.string( "PS2:ECAL" ), - linkerName = cms.string( "PreshowerAndECALLinker" ) - ), - cms.PSet( useKDTree = cms.bool( True ), - linkType = cms.string( "TRACK:ECAL" ), - linkerName = cms.string( "TrackAndECALLinker" ) - ), - cms.PSet( useKDTree = cms.bool( True ), - linkType = cms.string( "TRACK:HCAL" ), - linkerName = cms.string( "TrackAndHCALLinker" ) - ), - cms.PSet( useKDTree = cms.bool( False ), - linkType = cms.string( "ECAL:HCAL" ), - linkerName = cms.string( "ECALAndHCALLinker" ) - ), - cms.PSet( useKDTree = cms.bool( False ), - linkType = cms.string( "HFEM:HFHAD" ), - linkerName = cms.string( "HFEMAndHFHADLinker" ) - ) - ), - elementImporters = cms.VPSet( - cms.PSet( importerName = cms.string( "GeneralTracksImporter" ), - useIterativeTracking = cms.bool( False ), - source = cms.InputTag( "hltLightPFTracks" ), - NHitCuts_byTrackAlgo = cms.vuint32( 3, 3, 3, 3, 3 ), - muonSrc = cms.InputTag( "hltMuons" ), - DPtOverPtCuts_byTrackAlgo = cms.vdouble( 0.5, 0.5, 0.5, 0.5, 0.5 ) - ), - cms.PSet( importerName = cms.string( "ECALClusterImporter" ), - source = cms.InputTag( "hltParticleFlowClusterECALUnseeded" ), - BCtoPFCMap = cms.InputTag( "" ) - ), - cms.PSet( importerName = cms.string( "GenericClusterImporter" ), - source = cms.InputTag( "hltParticleFlowClusterHCAL" ) - ), - cms.PSet( importerName = cms.string( "GenericClusterImporter" ), - source = cms.InputTag( "hltParticleFlowClusterHFEM" ) - ), - cms.PSet( importerName = cms.string( "GenericClusterImporter" ), - source = cms.InputTag( "hltParticleFlowClusterHFHAD" ) +process.hltHIL3TrajSeedOIHit = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + PSetNames = cms.vstring( 'skipTSG', + 'iterativeTSG' ), + L3TkCollectionA = cms.InputTag( "hltHIL3MuonsOIState" ), + iterativeTSG = cms.PSet( + ErrorRescaling = cms.double( 3.0 ), + beamSpot = cms.InputTag( "unused" ), + MaxChi2 = cms.double( 40.0 ), + errorMatrixPset = cms.PSet( + atIP = cms.bool( True ), + action = cms.string( "use" ), + errorMatrixValuesPSet = cms.PSet( + pf3_V12 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V13 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V11 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V14 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V15 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), + pf3_V33 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + zAxis = cms.vdouble( -3.14159, 3.14159 ), + pf3_V44 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), + pf3_V22 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V23 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V45 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V55 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V34 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V35 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V25 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V24 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ) + ) + ), + UpdateState = cms.bool( True ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + SelectState = cms.bool( False ), + SigmaZ = cms.double( 25.0 ), + ResetMethod = cms.string( "matrix" ), + ComponentName = cms.string( "TSGFromPropagation" ), + UseVertexState = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAnyOpposite" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ) ), - cms.PSet( importerName = cms.string( "GenericClusterImporter" ), - source = cms.InputTag( "hltParticleFlowClusterPSUnseeded" ) - ) - ), - verbose = cms.untracked.bool( False ) -) -process.hltParticleFlow = cms.EDProducer( "PFProducer", - photon_SigmaiEtaiEta_endcap = cms.double( 0.034 ), - minPtForPostCleaning = cms.double( 20.0 ), - pf_nsigma_ECAL = cms.double( 0.0 ), - GedPhotonValueMap = cms.InputTag( 'tmpGedPhotons','valMapPFEgammaCandToPhoton' ), - sumPtTrackIsoForPhoton = cms.double( -1.0 ), - metFactorForFakes = cms.double( 4.0 ), - muon_HO = cms.vdouble( 0.9, 0.9 ), - electron_missinghits = cms.uint32( 1 ), - metSignificanceForCleaning = cms.double( 3.0 ), - usePFPhotons = cms.bool( False ), - dptRel_DispVtx = cms.double( 10.0 ), - nTrackIsoForEgammaSC = cms.uint32( 2 ), - pf_nsigma_HCAL = cms.double( 1.0 ), - cosmicRejectionDistance = cms.double( 1.0 ), - useEGammaFilters = cms.bool( False ), - useEGammaElectrons = cms.bool( False ), - nsigma_TRACK = cms.double( 1.0 ), - useEGammaSupercluster = cms.bool( False ), - sumPtTrackIsoForEgammaSC_barrel = cms.double( 4.0 ), - eventFractionForCleaning = cms.double( 0.8 ), - usePFDecays = cms.bool( False ), - rejectTracks_Step45 = cms.bool( False ), - eventFractionForRejection = cms.double( 0.8 ), - photon_MinEt = cms.double( 10.0 ), - usePFNuclearInteractions = cms.bool( False ), - maxSignificance = cms.double( 2.5 ), - electron_iso_mva_endcap = cms.double( -0.1075 ), - debug = cms.untracked.bool( False ), - pf_convID_mvaWeightFile = cms.string( "RecoParticleFlow/PFProducer/data/MVAnalysis_BDT.weights_pfConversionAug0411.txt" ), - calibHF_eta_step = cms.vdouble( 0.0, 2.9, 3.0, 3.2, 4.2, 4.4, 4.6, 4.8, 5.2, 5.4 ), - ptErrorScale = cms.double( 8.0 ), - minSignificance = cms.double( 2.5 ), - minMomentumForPunchThrough = cms.double( 100.0 ), - pf_conv_mvaCut = cms.double( 0.0 ), - useCalibrationsFromDB = cms.bool( True ), - usePFElectrons = cms.bool( False ), - electron_iso_combIso_endcap = cms.double( 10.0 ), - photon_combIso = cms.double( 10.0 ), - electron_iso_mva_barrel = cms.double( -0.1875 ), - postHFCleaning = cms.bool( False ), - factors_45 = cms.vdouble( 10.0, 100.0 ), - cleanedHF = cms.VInputTag( 'hltParticleFlowRecHitHCAL:Cleaned','hltParticleFlowClusterHFHAD:Cleaned','hltParticleFlowClusterHFEM:Cleaned' ), - coneEcalIsoForEgammaSC = cms.double( 0.3 ), - minSignificanceReduction = cms.double( 1.4 ), - photon_SigmaiEtaiEta_barrel = cms.double( 0.0125 ), - calibHF_b_HADonly = cms.vdouble( 1.27541, 0.85361, 0.86333, 0.89091, 0.94348, 0.94348, 0.9437, 1.0034, 1.0444, 1.0444 ), - minPixelHits = cms.int32( 1 ), - maxDPtOPt = cms.double( 1.0 ), - useHO = cms.bool( False ), - pf_electron_output_col = cms.string( "electrons" ), - electron_noniso_mvaCut = cms.double( -0.1 ), - GedElectronValueMap = cms.InputTag( "gedGsfElectronsTmp" ), - useVerticesForNeutral = cms.bool( True ), - pf_Res_mvaWeightFile = cms.string( "RecoParticleFlow/PFProducer/data/TMVARegression_BDTG_PFRes.root" ), - PFEGammaCandidates = cms.InputTag( "particleFlowEGamma" ), - sumPtTrackIsoSlopeForPhoton = cms.double( -1.0 ), - coneTrackIsoForEgammaSC = cms.double( 0.3 ), - minDeltaMet = cms.double( 0.4 ), - pt_Error = cms.double( 1.0 ), - useProtectionsForJetMET = cms.bool( True ), - metFactorForRejection = cms.double( 4.0 ), - sumPtTrackIsoForEgammaSC_endcap = cms.double( 4.0 ), - calibHF_use = cms.bool( False ), - verbose = cms.untracked.bool( False ), - usePFConversions = cms.bool( False ), - trackQuality = cms.string( "highPurity" ), - calibPFSCEle_endcap = cms.vdouble( 1.153, -16.5975, 5.668, -0.1772, 16.22, 7.326, 0.0483, -4.068, 9.406 ), - metFactorForCleaning = cms.double( 4.0 ), - eventFactorForCosmics = cms.double( 10.0 ), - egammaElectrons = cms.InputTag( "" ), - minEnergyForPunchThrough = cms.double( 100.0 ), - minTrackerHits = cms.int32( 8 ), - iCfgCandConnector = cms.PSet( - bCalibSecondary = cms.bool( False ), - bCalibPrimary = cms.bool( False ), - bCorrect = cms.bool( False ), - nuclCalibFactors = cms.vdouble( 0.8, 0.15, 0.5, 0.5, 0.05 ) + skipTSG = cms.PSet( ), + ComponentName = cms.string( "DualByL2TSG" ) ), - rejectTracks_Bad = cms.bool( False ), - pf_electronID_crackCorrection = cms.bool( False ), - pf_locC_mvaWeightFile = cms.string( "RecoParticleFlow/PFProducer/data/TMVARegression_BDTG_PFClusterCorr.root" ), - calibHF_a_EMonly = cms.vdouble( 0.96945, 0.96701, 0.76309, 0.82268, 0.87583, 0.89718, 0.98674, 1.4681, 1.458, 1.458 ), - muons = cms.InputTag( "hltMuons" ), - metFactorForHighEta = cms.double( 25.0 ), - minHFCleaningPt = cms.double( 5.0 ), - muon_HCAL = cms.vdouble( 3.0, 3.0 ), - pf_electron_mvaCut = cms.double( -0.1 ), - ptFactorForHighEta = cms.double( 2.0 ), - maxDeltaPhiPt = cms.double( 7.0 ), - pf_electronID_mvaWeightFile = cms.string( "RecoParticleFlow/PFProducer/data/MVAnalysis_BDT.weights_PfElectrons23Jan_IntToFloat.txt" ), - sumEtEcalIsoForEgammaSC_endcap = cms.double( 2.0 ), - calibHF_b_EMHAD = cms.vdouble( 1.27541, 0.85361, 0.86333, 0.89091, 0.94348, 0.94348, 0.9437, 1.0034, 1.0444, 1.0444 ), - pf_GlobC_mvaWeightFile = cms.string( "RecoParticleFlow/PFProducer/data/TMVARegression_BDTG_PFGlobalCorr.root" ), - photon_HoE = cms.double( 0.1 ), - sumEtEcalIsoForEgammaSC_barrel = cms.double( 1.0 ), - calibPFSCEle_Fbrem_endcap = cms.vdouble( 0.9, 6.5, -0.0692932, 0.101776, 0.995338, -0.00236548, 0.874998, 1.653, -0.0750184, 0.147, 0.923165, 4.74665E-4, 1.10782 ), - punchThroughFactor = cms.double( 3.0 ), - algoType = cms.uint32( 0 ), - electron_iso_combIso_barrel = cms.double( 10.0 ), - postMuonCleaning = cms.bool( True ), - calibPFSCEle_barrel = cms.vdouble( 1.004, -1.536, 22.88, -1.467, 0.3555, 0.6227, 14.65, 2051.0, 25.0, 0.9932, -0.5444, 0.0, 0.5438, 0.7109, 7.645, 0.2904, 0.0 ), - electron_protectionsForJetMET = cms.PSet( - maxE = cms.double( 50.0 ), - maxTrackPOverEele = cms.double( 1.0 ), - maxEcalEOverP_2 = cms.double( 0.2 ), - maxHcalEOverEcalE = cms.double( 0.1 ), - maxEcalEOverP_1 = cms.double( 0.5 ), - maxHcalEOverP = cms.double( 1.0 ), - maxEcalEOverPRes = cms.double( 0.2 ), - maxHcalE = cms.double( 10.0 ), - maxEeleOverPout = cms.double( 0.2 ), - maxNtracks = cms.double( 3.0 ), - maxEleHcalEOverEcalE = cms.double( 0.1 ), - maxDPhiIN = cms.double( 0.1 ), - maxEeleOverPoutRes = cms.double( 0.5 ) + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'PropagatorWithMaterial', + 'hltESPSmartPropagatorAnyOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) ), - electron_iso_pt = cms.double( 10.0 ), - isolatedElectronID_mvaWeightFile = cms.string( "RecoEgamma/ElectronIdentification/data/TMVA_BDTSimpleCat_17Feb2011.weights.xml" ), - vertexCollection = cms.InputTag( "hltPixelVertices" ), - X0_Map = cms.string( "RecoParticleFlow/PFProducer/data/allX0histos.root" ), - calibPFSCEle_Fbrem_barrel = cms.vdouble( 0.6, 6.0, -0.0255975, 0.0576727, 0.975442, -5.46394E-4, 1.26147, 25.0, -0.02025, 0.04537, 0.9728, -8.962E-4, 1.172 ), - blocks = cms.InputTag( "hltParticleFlowBlock" ), - punchThroughMETFactor = cms.double( 4.0 ), - metSignificanceForRejection = cms.double( 4.0 ), - photon_protectionsForJetMET = cms.PSet( - sumPtTrackIsoSlope = cms.double( 0.001 ), - sumPtTrackIso = cms.double( 2.0 ) + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( ), + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( + cleanerFromSharedHits = cms.bool( True ), + ptCleaner = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + directionCleaner = cms.bool( True ) ), - usePhotonReg = cms.bool( False ), - dzPV = cms.double( 0.2 ), - calibHF_a_EMHAD = cms.vdouble( 1.42215, 1.00496, 0.68961, 0.81656, 0.98504, 0.98504, 1.00802, 1.0593, 1.4576, 1.4576 ), - useRegressionFromDB = cms.bool( False ), - muon_ECAL = cms.vdouble( 0.5, 0.5 ), - usePFSCEleCalib = cms.bool( True ) -) -process.hltAK4PFJets = cms.EDProducer( "FastjetJetProducer", - Active_Area_Repeats = cms.int32( 5 ), - doAreaFastjet = cms.bool( False ), - voronoiRfact = cms.double( -9.0 ), - maxBadHcalCells = cms.uint32( 9999999 ), - doAreaDiskApprox = cms.bool( True ), - maxRecoveredEcalCells = cms.uint32( 9999999 ), - jetType = cms.string( "PFJet" ), - minSeed = cms.uint32( 0 ), - Ghost_EtaMax = cms.double( 6.0 ), - doRhoFastjet = cms.bool( False ), - jetAlgorithm = cms.string( "AntiKt" ), - nSigmaPU = cms.double( 1.0 ), - GhostArea = cms.double( 0.01 ), - Rho_EtaMax = cms.double( 4.4 ), - maxBadEcalCells = cms.uint32( 9999999 ), - useDeterministicSeed = cms.bool( True ), - doPVCorrection = cms.bool( False ), - maxRecoveredHcalCells = cms.uint32( 9999999 ), - rParam = cms.double( 0.4 ), - maxProblematicHcalCells = cms.uint32( 9999999 ), - doOutputJets = cms.bool( True ), - src = cms.InputTag( "hltParticleFlow" ), - inputEtMin = cms.double( 0.0 ), - puPtMin = cms.double( 10.0 ), - srcPVs = cms.InputTag( "hltPixelVertices" ), - jetPtMin = cms.double( 0.0 ), - radiusPU = cms.double( 0.4 ), - maxProblematicEcalCells = cms.uint32( 9999999 ), - doPUOffsetCorr = cms.bool( False ), - inputEMin = cms.double( 0.0 ), - useMassDropTagger = cms.bool( False ), - muMin = cms.double( -1.0 ), - subtractorName = cms.string( "" ), - muCut = cms.double( -1.0 ), - subjetPtMin = cms.double( -1.0 ), - useTrimming = cms.bool( False ), - muMax = cms.double( -1.0 ), - yMin = cms.double( -1.0 ), - useFiltering = cms.bool( False ), - rFilt = cms.double( -1.0 ), - yMax = cms.double( -1.0 ), - zcut = cms.double( -1.0 ), - MinVtxNdof = cms.int32( 0 ), - MaxVtxZ = cms.double( 15.0 ), - UseOnlyVertexTracks = cms.bool( False ), - dRMin = cms.double( -1.0 ), - nFilt = cms.int32( -1 ), - usePruning = cms.bool( False ), - maxDepth = cms.int32( -1 ), - yCut = cms.double( -1.0 ), - DzTrVtxMax = cms.double( 0.0 ), - UseOnlyOnePV = cms.bool( False ), - rcut_factor = cms.double( -1.0 ), - sumRecHits = cms.bool( False ), - trimPtFracMin = cms.double( -1.0 ), - dRMax = cms.double( -1.0 ), - DxyTrVtxMax = cms.double( 0.0 ), - useCMSBoostedTauSeedingAlgorithm = cms.bool( False ) -) -process.hltFixedGridRhoFastjetAll = cms.EDProducer( "FixedGridRhoProducerFastjet", - gridSpacing = cms.double( 0.55 ), - maxRapidity = cms.double( 5.0 ), - pfCandidatesTag = cms.InputTag( "hltParticleFlow" ) -) -process.hltAK4PFJetsCorrected = cms.EDProducer( "PFJetCorrectionProducer", - src = cms.InputTag( "hltAK4PFJets" ), - correctors = cms.vstring( 'hltESPAK4PFCorrection' ) -) -process.hltPFJetsCorrectedMatchedToCaloJets210 = cms.EDProducer( "PFJetsMatchedToFilteredCaloJetsProducer", - DeltaR = cms.double( 0.5 ), - CaloJetFilter = cms.InputTag( "hltSingleCaloJet210" ), - TriggerType = cms.int32( 85 ), - PFJetSrc = cms.InputTag( "hltAK4PFJetsCorrected" ) -) -process.hltSinglePFJet260 = cms.EDFilter( "HLT1PFJet", - saveTags = cms.bool( True ), - MinPt = cms.double( 260.0 ), - MinN = cms.int32( 1 ), - MaxEta = cms.double( 5.0 ), - MinMass = cms.double( -1.0 ), - inputTag = cms.InputTag( "hltPFJetsCorrectedMatchedToCaloJets210" ), - MinE = cms.double( -1.0 ), - triggerType = cms.int32( 85 ) -) -process.hltL1sL1SingleEG10 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleEG10" ), - saveTags = cms.bool( True ), - L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), - L1UseL1TriggerObjectMaps = cms.bool( True ), - L1UseAliasesForSeeding = cms.bool( True ), - L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), - L1CollectionsTag = cms.InputTag( "hltL1extraParticles" ), - L1NrBxInEvent = cms.int32( 3 ), - L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), - L1TechTriggerSeeding = cms.bool( False ) -) -process.hltPrePhoton20CaloIdVLIsoL = cms.EDFilter( "HLTPrescaler", - L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), - offset = cms.uint32( 0 ) + PtCut = cms.double( 1.0 ) ) -process.hltEGL1SingleEG12Filter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", - doIsolated = cms.bool( False ), - endcap_end = cms.double( 2.65 ), - saveTags = cms.bool( False ), - region_eta_size_ecap = cms.double( 1.0 ), - barrel_end = cms.double( 1.4791 ), - l1IsolatedTag = cms.InputTag( 'hltL1extraParticles','Isolated' ), - candIsolatedTag = cms.InputTag( "hltEgammaCandidates" ), - region_phi_size = cms.double( 1.044 ), - region_eta_size = cms.double( 0.522 ), - L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleEG10" ), - candNonIsolatedTag = cms.InputTag( "" ), - l1NonIsolatedTag = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), - ncandcut = cms.int32( 1 ) -) -process.hltEG20EtFilter = cms.EDFilter( "HLTEgammaEtFilter", - saveTags = cms.bool( False ), - L1NonIsoCand = cms.InputTag( "" ), - relaxed = cms.untracked.bool( False ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - inputTag = cms.InputTag( "hltEGL1SingleEG12Filter" ), - etcutEB = cms.double( 20.0 ), - etcutEE = cms.double( 20.0 ), - ncandcut = cms.int32( 1 ) -) -process.hltEG20CaloIdVLClusterShapeFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( 0.04 ), - thrOverEEE = cms.double( -1.0 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( -1.0 ), - thrRegularEB = cms.double( 0.024 ), - lessThan = cms.bool( True ), - useEt = cms.bool( False ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( 'hltEgammaClusterShape','sigmaIEtaIEta5x5' ), - candTag = cms.InputTag( "hltEG20EtFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltEG20CaloIdVLHEFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( -1.0 ), - thrOverEEE = cms.double( 0.1 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.15 ), - thrRegularEB = cms.double( -1.0 ), - lessThan = cms.bool( True ), - useEt = cms.bool( False ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaHoverE" ), - candTag = cms.InputTag( "hltEG20CaloIdVLClusterShapeFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltEG20CaloIdVLIsoLEcalIsoFilter = cms.EDFilter( "HLTEgammaGenericQuadraticFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( 0.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( 0.0 ), - thrRegularEE = cms.double( 5.5 ), - thrOverEEE = cms.double( 0.012 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.012 ), - thrRegularEB = cms.double( 5.5 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaEcalPFClusterIso" ), - candTag = cms.InputTag( "hltEG20CaloIdVLHEFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltEG20CaloIdVLIsoLHcalIsoFilter = cms.EDFilter( "HLTEgammaGenericQuadraticFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( 0.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( 0.0 ), - thrRegularEE = cms.double( 3.5 ), - thrOverEEE = cms.double( 0.005 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.005 ), - thrRegularEB = cms.double( 3.5 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaHcalPFClusterIso" ), - candTag = cms.InputTag( "hltEG20CaloIdVLHEFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltPixelVerticesForPhotons = cms.EDProducer( "PixelVertexProducer", - WtAverage = cms.bool( True ), - Method2 = cms.bool( True ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - PVcomparer = cms.PSet( refToPSet_ = cms.string( "HLTPSetPvClusterComparer" ) ), - Verbosity = cms.int32( 0 ), - UseError = cms.bool( True ), - TrackCollection = cms.InputTag( "hltPixelTracks" ), - PtMin = cms.double( 1.0 ), - NTrkMin = cms.int32( 2 ), - ZOffset = cms.double( 5.0 ), - Finder = cms.string( "DivisiveVertexFinder" ), - ZSeparation = cms.double( 0.05 ) -) -process.hltIter0PFlowPixelSeedsFromPixelTracksForPhotons = cms.EDProducer( "SeedGeneratorFromProtoTracksEDProducer", - useEventsWithNoVertex = cms.bool( True ), - originHalfLength = cms.double( 0.3 ), - useProtoTrackKinematics = cms.bool( False ), - usePV = cms.bool( True ), - InputVertexCollection = cms.InputTag( "hltPixelVerticesForPhotons" ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - InputCollection = cms.InputTag( "hltPixelTracks" ), - originRadius = cms.double( 0.1 ) -) -process.hltIter0PFlowCkfTrackCandidatesForPhotons = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter0PFlowPixelSeedsFromPixelTracksForPhotons" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), +process.hltHIL3TrackCandidateFromL2OIHit = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedOIHit" ), + reverseTrajectories = cms.bool( True ), TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) ), TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), cleanTrajectoryAfterInOut = cms.bool( False ), useHitsSplitting = cms.bool( False ), RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter0PSetTrajectoryBuilderIT" ) ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) ) -process.hltIter0PFlowCtfWithMaterialTracksForPhotons = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter0PFlowCkfTrackCandidatesForPhotons" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), +process.hltHIL3TkTracksFromL2OIHit = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2OIHit" ), + SimpleMagneticField = cms.string( "" ), clusterRemovalInfo = cms.InputTag( "" ), beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), useHitsSplitting = cms.bool( False ), MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), NavigationSchool = cms.string( "" ), TrajectoryInEvent = cms.bool( True ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -process.hltIter0PFlowTrackSelectionHighPurityForPhotons = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.4, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.35, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter0PFlowCtfWithMaterialTracksForPhotons" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesForPhotons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.4, 4.0 ), - d0_par1 = cms.vdouble( 0.3, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter1ClustersRefRemovalForPhotons = cms.EDProducer( "TrackClusterRemover", - minNumberOfLayersWithMeasBeforeFiltering = cms.int32( 0 ), - maxChi2 = cms.double( 9.0 ), - trajectories = cms.InputTag( "hltIter0PFlowTrackSelectionHighPurityForPhotons" ), - oldClusterRemovalInfo = cms.InputTag( "" ), - stripClusters = cms.InputTag( "hltSiStripRawToClustersFacility" ), - overrideTrkQuals = cms.InputTag( "" ), - pixelClusters = cms.InputTag( "hltSiPixelClusters" ), - TrackQuality = cms.string( "highPurity" ) -) -process.hltIter1MaskedMeasurementTrackerEventForPhotons = cms.EDProducer( "MaskedMeasurementTrackerEventProducer", - clustersToSkip = cms.InputTag( "hltIter1ClustersRefRemovalForPhotons" ), - OnDemand = cms.bool( False ), - src = cms.InputTag( "hltSiStripClusters" ) -) -process.hltIter1PixelLayerTripletsForPhotons = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2+BPix3', - 'BPix1+BPix2+FPix1_pos', - 'BPix1+BPix2+FPix1_neg', - 'BPix1+FPix1_pos+FPix2_pos', - 'BPix1+FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter1ClustersRefRemovalForPhotons" ), - hitErrorRPhi = cms.double( 0.0051 ) + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +process.hltHIL3MuonsOIHit = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) + ), + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + ), + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) + ), + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) + ), + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2OIHit" ), + tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter1ClustersRefRemovalForPhotons" ), - hitErrorRPhi = cms.double( 0.0027 ) + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) + ), + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) ), - TIB = cms.PSet( ) -) -process.hltIter1PFlowPixelSeedsForPhotons = cms.EDProducer( "SeedGeneratorFromRegionHitsEDProducer", - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "CandidateSeededTrackingRegionsProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.05 ), - ptMin = cms.double( 0.5 ), - input = cms.InputTag( "hltEgammaCandidates" ), - maxNRegions = cms.int32( 10 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - vertexCollection = cms.InputTag( "hltPixelVerticesForPhotons" ), - zErrorBeamSpot = cms.double( 24.2 ), - deltaEta = cms.double( 0.5 ), - deltaPhi = cms.double( 0.5 ), - nSigmaZVertex = cms.double( 3.0 ), - nSigmaZBeamSpot = cms.double( 4.0 ), - mode = cms.string( "VerticesFixed" ), - maxNVertices = cms.int32( 3 ), - zErrorVetex = cms.double( 0.2 ) - ) + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) +) +process.hltHIL3TkFromL2OICombination = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit' ) +) +process.hltHIL3TrajSeedIOHit = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + PSetNames = cms.vstring( 'skipTSG', + 'skipTSG' ), + L3TkCollectionA = cms.InputTag( "hltHIL3TkFromL2OICombination" ), + iterativeTSG = cms.PSet( + firstTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + ComponentName = cms.string( "StandardHitTripletGenerator" ), + GeneratorPSet = cms.PSet( + useBending = cms.bool( True ), + useFixedPreFiltering = cms.bool( False ), + maxElement = cms.uint32( 0 ), + phiPreFiltering = cms.double( 0.3 ), + extraHitRPhitolerance = cms.double( 0.06 ), + useMultScattering = cms.bool( True ), + ComponentName = cms.string( "PixelTripletHLTGenerator" ), + extraHitRZtolerance = cms.double( 0.06 ), + SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) + ), + SeedingLayers = cms.InputTag( "hltPixelLayerTriplets" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ), + PSetNames = cms.vstring( 'firstTSG', + 'secondTSG' ), + ComponentName = cms.string( "CombinedTSG" ), + thirdTSG = cms.PSet( + PSetNames = cms.vstring( 'endcapTSG', + 'barrelTSG' ), + barrelTSG = cms.PSet( ), + endcapTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + maxElement = cms.uint32( 0 ), + ComponentName = cms.string( "StandardHitPairGenerator" ), + useOnDemandTracker = cms.untracked.int32( 0 ), + SeedingLayers = cms.InputTag( "hltMixedLayerPairs" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ), + etaSeparation = cms.double( 2.0 ), + ComponentName = cms.string( "DualByEtaTSG" ) + ), + secondTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + maxElement = cms.uint32( 0 ), + ComponentName = cms.string( "StandardHitPairGenerator" ), + useOnDemandTracker = cms.untracked.int32( 0 ), + SeedingLayers = cms.InputTag( "hltPixelLayerPairs" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ) + ), + skipTSG = cms.PSet( ), + ComponentName = cms.string( "DualByL2TSG" ) ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ), - ClusterCheckPSet = cms.PSet( - PixelClusterCollectionLabel = cms.InputTag( "hltSiPixelClusters" ), - MaxNumberOfCosmicClusters = cms.uint32( 50000 ), - doClusterCheck = cms.bool( False ), - ClusterCollectionLabel = cms.InputTag( "hltSiStripClusters" ), - MaxNumberOfPixelClusters = cms.uint32( 10000 ) + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'PropagatorWithMaterial' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitTripletGenerator" ), - GeneratorPSet = cms.PSet( - useBending = cms.bool( True ), - useFixedPreFiltering = cms.bool( False ), - maxElement = cms.uint32( 100000 ), - phiPreFiltering = cms.double( 0.3 ), - extraHitRPhitolerance = cms.double( 0.032 ), - useMultScattering = cms.bool( True ), - ComponentName = cms.string( "PixelTripletHLTGenerator" ), - extraHitRZtolerance = cms.double( 0.037 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) - ), - SeedingLayers = cms.InputTag( "hltIter1PixelLayerTripletsForPhotons" ) + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.1 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.1 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) ), - SeedCreatorPSet = cms.PSet( - ComponentName = cms.string( "SeedFromConsecutiveHitsTripletOnlyCreator" ), - propagator = cms.string( "PropagatorWithMaterialParabolicMf" ), - SeedMomentumForBOFF = cms.double( 5.0 ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( + cleanerFromSharedHits = cms.bool( True ), + ptCleaner = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + directionCleaner = cms.bool( True ) ), - TTRHBuilder = cms.string( "(unused)" ) + PtCut = cms.double( 1.0 ) ) -process.hltIter1PFlowCkfTrackCandidatesForPhotons = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter1PFlowPixelSeedsForPhotons" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), +process.hltHIL3TrackCandidateFromL2IOHit = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedIOHit" ), + reverseTrajectories = cms.bool( False ), TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) ), TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter1MaskedMeasurementTrackerEventForPhotons" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), cleanTrajectoryAfterInOut = cms.bool( False ), useHitsSplitting = cms.bool( False ), RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter1PSetTrajectoryBuilderIT" ) ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) ) -process.hltIter1PFlowCtfWithMaterialTracksForPhotons = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter1PFlowCkfTrackCandidatesForPhotons" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), +process.hltHIL3TkTracksFromL2IOHit = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2IOHit" ), + SimpleMagneticField = cms.string( "" ), clusterRemovalInfo = cms.InputTag( "" ), beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter1MaskedMeasurementTrackerEventForPhotons" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), useHitsSplitting = cms.bool( False ), MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), NavigationSchool = cms.string( "" ), TrajectoryInEvent = cms.bool( True ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -process.hltIter1PFlowTrackSelectionHighPurityLooseForPhotons = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.9, 3.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.8, 3.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter1PFlowCtfWithMaterialTracksForPhotons" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesForPhotons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.9, 3.0 ), - d0_par1 = cms.vdouble( 0.85, 3.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter1PFlowTrackSelectionHighPurityTightForPhotons = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 5 ), - chi2n_par = cms.double( 0.4 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 1.0, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 1.0, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter1PFlowCtfWithMaterialTracksForPhotons" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesForPhotons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 1.0, 4.0 ), - d0_par1 = cms.vdouble( 1.0, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter1PFlowTrackSelectionHighPurityForPhotons = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter1PFlowTrackSelectionHighPurityLooseForPhotons','hltIter1PFlowTrackSelectionHighPurityTightForPhotons' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter1PFlowTrackSelectionHighPurityLooseForPhotons','hltIter1PFlowTrackSelectionHighPurityTightForPhotons' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltIter1MergedForPhotons = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter0PFlowTrackSelectionHighPurityForPhotons','hltIter1PFlowTrackSelectionHighPurityForPhotons' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter0PFlowTrackSelectionHighPurityForPhotons','hltIter1PFlowTrackSelectionHighPurityForPhotons' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltIter2ClustersRefRemovalForPhotons = cms.EDProducer( "TrackClusterRemover", - minNumberOfLayersWithMeasBeforeFiltering = cms.int32( 0 ), - maxChi2 = cms.double( 16.0 ), - trajectories = cms.InputTag( "hltIter1PFlowTrackSelectionHighPurityForPhotons" ), - oldClusterRemovalInfo = cms.InputTag( "hltIter1ClustersRefRemovalForPhotons" ), - stripClusters = cms.InputTag( "hltSiStripRawToClustersFacility" ), - overrideTrkQuals = cms.InputTag( "" ), - pixelClusters = cms.InputTag( "hltSiPixelClusters" ), - TrackQuality = cms.string( "highPurity" ) -) -process.hltIter2MaskedMeasurementTrackerEventForPhotons = cms.EDProducer( "MaskedMeasurementTrackerEventProducer", - clustersToSkip = cms.InputTag( "hltIter2ClustersRefRemovalForPhotons" ), - OnDemand = cms.bool( False ), - src = cms.InputTag( "hltSiStripClusters" ) -) -process.hltIter2PixelLayerPairsForPhotons = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2', - 'BPix1+BPix3', - 'BPix2+BPix3', - 'BPix1+FPix1_pos', - 'BPix1+FPix1_neg', - 'BPix1+FPix2_pos', - 'BPix1+FPix2_neg', - 'BPix2+FPix1_pos', - 'BPix2+FPix1_neg', - 'BPix2+FPix2_pos', - 'BPix2+FPix2_neg', - 'FPix1_pos+FPix2_pos', - 'FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter2ClustersRefRemovalForPhotons" ), - hitErrorRPhi = cms.double( 0.0051 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter2ClustersRefRemovalForPhotons" ), - hitErrorRPhi = cms.double( 0.0027 ) - ), - TIB = cms.PSet( ) -) -process.hltIter2PFlowPixelSeedsForPhotons = cms.EDProducer( "SeedGeneratorFromRegionHitsEDProducer", - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "CandidateSeededTrackingRegionsProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.05 ), - ptMin = cms.double( 1.2 ), - deltaEta = cms.double( 0.5 ), - deltaPhi = cms.double( 0.5 ), - vertexCollection = cms.InputTag( "hltPixelVerticesForPhotons" ), - input = cms.InputTag( "hltEgammaCandidates" ), - mode = cms.string( "VerticesFixed" ), - maxNRegions = cms.int32( 10 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - maxNVertices = cms.int32( 3 ), - zErrorBeamSpot = cms.double( 24.2 ), - nSigmaZVertex = cms.double( 3.0 ), - nSigmaZBeamSpot = cms.double( 4.0 ), - zErrorVetex = cms.double( 0.2 ) - ) - ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ), - ClusterCheckPSet = cms.PSet( - PixelClusterCollectionLabel = cms.InputTag( "hltSiPixelClusters" ), - MaxNumberOfCosmicClusters = cms.uint32( 50000 ), - doClusterCheck = cms.bool( False ), - ClusterCollectionLabel = cms.InputTag( "hltSiStripClusters" ), - MaxNumberOfPixelClusters = cms.uint32( 10000 ) + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +process.hltHIAllL3MuonsIOHit = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitPairGenerator" ), - GeneratorPSet = cms.PSet( - maxElement = cms.uint32( 100000 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) + ), + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + ), + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) + ), + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) ), - SeedingLayers = cms.InputTag( "hltIter2PixelLayerPairsForPhotons" ) + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2IOHit" ), + tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) ), - SeedCreatorPSet = cms.PSet( - ComponentName = cms.string( "SeedFromConsecutiveHitsCreator" ), - propagator = cms.string( "PropagatorWithMaterialParabolicMf" ), - SeedMomentumForBOFF = cms.double( 5.0 ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) + ), + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) ), - TTRHBuilder = cms.string( "(unused)" ) + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) ) -process.hltIter2PFlowCkfTrackCandidatesForPhotons = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter2PFlowPixelSeedsForPhotons" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter2MaskedMeasurementTrackerEventForPhotons" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter2PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) +process.hltHIL3TrajectorySeed = cms.EDProducer( "L3MuonTrajectorySeedCombiner", + labels = cms.VInputTag( 'hltHIL3TrajSeedIOHit','hltHIL3TrajSeedOIState','hltHIL3TrajSeedOIHit' ) ) -process.hltIter2PFlowCtfWithMaterialTracksForPhotons = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter2PFlowCkfTrackCandidatesForPhotons" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter2MaskedMeasurementTrackerEventForPhotons" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -process.hltIter2PFlowTrackSelectionHighPurityForPhotons = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.4, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.35, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter2PFlowCtfWithMaterialTracksForPhotons" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesForPhotons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.4, 4.0 ), - d0_par1 = cms.vdouble( 0.3, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter2MergedForPhotons = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter1MergedForPhotons','hltIter2PFlowTrackSelectionHighPurityForPhotons' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter1MergedForPhotons','hltIter2PFlowTrackSelectionHighPurityForPhotons' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltEgammaHollowTrackIso = cms.EDProducer( "EgammaHLTPhotonTrackIsolationProducersRegional", - egTrkIsoStripEndcap = cms.double( 0.03 ), - egTrkIsoConeSize = cms.double( 0.29 ), - trackProducer = cms.InputTag( "hltIter2MergedForPhotons" ), - egTrkIsoStripBarrel = cms.double( 0.03 ), - countTracks = cms.bool( False ), - egTrkIsoRSpan = cms.double( 999999.0 ), - egTrkIsoVetoConeSize = cms.double( 0.06 ), - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - egTrkIsoPtMin = cms.double( 1.0 ), - egTrkIsoZSpan = cms.double( 999999.0 ) -) -process.hltEG20CaloIdVLIsoLTrackIsoFilter = cms.EDFilter( "HLTEgammaGenericQuadraticFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( 0.0 ), - L1NonIsoCand = cms.InputTag( "" ), +process.hltHIL3TrackCandidateFromL2 = cms.EDProducer( "L3TrackCandCombiner", + labels = cms.VInputTag( 'hltHIL3TrackCandidateFromL2IOHit','hltHIL3TrackCandidateFromL2OIHit','hltHIL3TrackCandidateFromL2OIState' ) +) +process.hltHIL3TkTracksFromL2 = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3TkTracksFromL2IOHit','hltHIL3TkTracksFromL2OIHit','hltHIL3TkTracksFromL2OIState' ) +) +process.hltHIL3MuonsLinksCombination = cms.EDProducer( "L3TrackLinksCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit','hltHIAllL3MuonsIOHit' ) +) +process.hltHIL3Muons = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit','hltHIAllL3MuonsIOHit' ) +) +process.hltHIL3MuonCandidates = cms.EDProducer( "L3MuonCandidateProducer", + InputLinksObjects = cms.InputTag( "hltHIL3MuonsLinksCombination" ), + InputObjects = cms.InputTag( "hltHIL3Muons" ), + MuonPtOption = cms.string( "Global" ) +) +process.hltHISingleMu3L3Filtered = cms.EDFilter( "HLTMuonL3PreFilter", + MaxNormalizedChi2 = cms.double( 20.0 ), + saveTags = cms.bool( True ), + PreviousCandTag = cms.InputTag( "hltHIL2Mu3L2Filtered" ), + MinNmuonHits = cms.int32( 0 ), + MinN = cms.int32( 1 ), + MinTrackPt = cms.double( 0.0 ), + MaxEta = cms.double( 2.5 ), + MaxDXYBeamSpot = cms.double( 0.1 ), + MinNhits = cms.int32( 0 ), + MinDxySig = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MaxDz = cms.double( 9999.0 ), + MaxPtDifference = cms.double( 9999.0 ), + MaxDr = cms.double( 2.0 ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + MinDXYBeamSpot = cms.double( -1.0 ), + MinDr = cms.double( -1.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinPt = cms.double( 3.0 ) +) +process.hltPreHIL3DoubleMuOpen = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIDimuonL2PreFiltered0 = cms.EDFilter( "HLTMuonL2PreFilter", saveTags = cms.bool( True ), - thrOverE2EB = cms.double( 0.0 ), - thrRegularEE = cms.double( 3.5 ), - thrOverEEE = cms.double( 0.002 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.002 ), - thrRegularEB = cms.double( 3.5 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaHollowTrackIso" ), - candTag = cms.InputTag( "hltEG20CaloIdVLIsoLHcalIsoFilter" ), - nonIsoTag = cms.InputTag( "" ) + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) ) -process.hltPrePhysics = cms.EDFilter( "HLTPrescaler", +process.hltHIDimuonL3FilterOpen = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( 0 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +process.hltPreHIL3DoubleMuOpenSS = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIDimuonL3FilterOpenSS = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( 1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +process.hltPreHIL3DoubleMuOpenOS = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIDimuonL3FilterOpenOS = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( -1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +process.hltPreHIL3DoubleMuOpenOSNoCowboy = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) +process.hltHIDimuonL3FilterOpenOSNoCowboy = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( -1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( True ), + MinInvMass = cms.vdouble( 0.0 ) +) process.hltFEDSelector = cms.EDProducer( "EvFFEDSelector", inputTag = cms.InputTag( "rawDataRepacker" ), fedList = cms.vuint32( 1023 ) @@ -8438,11 +3874,19 @@ filterName = cms.untracked.string( "" ), dataTier = cms.untracked.string( "RAW" ) ), - SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring( 'HLT_CaloJet260_v1', - 'HLT_Ele27_eta2p1_WP75_Gsf_v1', - 'HLT_Mu50_v1', - 'HLT_PFJet260_v1', - 'HLT_Photon20_CaloIdVL_IsoL_v1', + SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring( 'HLT_HIL1DoubleMu0_HighQ_v1', + 'HLT_HIL2DoubleMu0_NHitQ_v1', + 'HLT_HIL2DoubleMu0_v1', + 'HLT_HIL2DoubleMu3_v1', + 'HLT_HIL2Mu15_v1', + 'HLT_HIL2Mu3_NHitQ_v1', + 'HLT_HIL2Mu3_v1', + 'HLT_HIL2Mu7_v1', + 'HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1', + 'HLT_HIL3DoubleMuOpen_OS_v1', + 'HLT_HIL3DoubleMuOpen_SS_v1', + 'HLT_HIL3DoubleMuOpen_v1', + 'HLT_HIL3Mu3_v1', 'HLT_Physics_v1' ) ), outputCommands = cms.untracked.vstring( 'drop *', 'keep *_hltL1GtObjectMap_*_*', @@ -8454,66 +3898,31 @@ process.HLTL1UnpackerSequence = cms.Sequence( process.hltGtDigis + process.hltGctDigis + process.hltL1GtObjectMap + process.hltL1extraParticles ) process.HLTBeamSpot = cms.Sequence( process.hltScalersRawToDigi + process.hltOnlineBeamSpot ) process.HLTBeginSequence = cms.Sequence( process.hltTriggerType + process.HLTL1UnpackerSequence + process.HLTBeamSpot ) -process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence = cms.Sequence( process.hltEcalDigis + process.hltEcalUncalibRecHit + process.hltEcalDetIdToBeRecovered + process.hltEcalRecHit ) -process.HLTDoLocalHcalSequence = cms.Sequence( process.hltHcalDigis + process.hltHbhereco + process.hltHfreco + process.hltHoreco ) -process.HLTDoCaloSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence + process.HLTDoLocalHcalSequence + process.hltTowerMakerForAll ) -process.HLTAK4CaloJetsReconstructionSequence = cms.Sequence( process.HLTDoCaloSequence + process.hltAK4CaloJets + process.hltAK4CaloJetsIDPassed ) -process.HLTAK4CaloJetsCorrectionSequence = cms.Sequence( process.hltFixedGridRhoFastjetAllCalo + process.hltAK4CaloJetsCorrected + process.hltAK4CaloJetsCorrectedIDPassed ) -process.HLTAK4CaloJetsSequence = cms.Sequence( process.HLTAK4CaloJetsReconstructionSequence + process.HLTAK4CaloJetsCorrectionSequence ) process.HLTEndSequence = cms.Sequence( process.hltBoolEnd ) -process.HLTDoFullUnpackingEgammaEcalSequence = cms.Sequence( process.hltEcalDigis + process.hltEcalPreshowerDigis + process.hltEcalUncalibRecHit + process.hltEcalDetIdToBeRecovered + process.hltEcalRecHit + process.hltEcalPreshowerRecHit ) -process.HLTPFClusteringForEgamma = cms.Sequence( process.hltRechitInRegionsECAL + process.hltRechitInRegionsES + process.hltParticleFlowRecHitECALL1Seeded + process.hltParticleFlowRecHitPSL1Seeded + process.hltParticleFlowClusterPSL1Seeded + process.hltParticleFlowClusterECALUncorrectedL1Seeded + process.hltParticleFlowClusterECALL1Seeded + process.hltParticleFlowSuperClusterECALL1Seeded ) -process.HLTDoLocalHcalWithTowerSequence = cms.Sequence( process.hltHcalDigis + process.hltHbhereco + process.hltHfreco + process.hltHoreco + process.hltTowerMakerForAll ) -process.HLTFastJetForEgamma = cms.Sequence( process.hltFixedGridRhoFastjetAllCaloForMuons ) -process.HLTPFHcalClusteringForEgamma = cms.Sequence( process.hltRegionalTowerForEgamma + process.hltParticleFlowRecHitHCALForEgamma + process.hltParticleFlowClusterHCALForEgamma ) -process.HLTDoLocalPixelSequence = cms.Sequence( process.hltSiPixelDigis + process.hltSiPixelClusters + process.hltSiPixelClustersCache + process.hltSiPixelRecHits ) -process.HLTDoLocalStripSequence = cms.Sequence( process.hltSiStripExcludedFEDListProducer + process.hltSiStripRawToClustersFacility + process.hltSiStripClusters ) -process.HLTGsfElectronSequence = cms.Sequence( process.hltEgammaCkfTrackCandidatesForGSF + process.hltEgammaGsfTracks + process.hltEgammaGsfElectrons + process.hltEgammaGsfTrackVars ) -process.HLTRecoPixelVertexingForElectronSequence = cms.Sequence( process.hltPixelLayerTriplets + process.hltPixelTracksElectrons + process.hltPixelVerticesElectrons ) -process.HLTPixelTrackingForElectron = cms.Sequence( process.hltElectronsVertex + process.HLTDoLocalPixelSequence + process.HLTRecoPixelVertexingForElectronSequence ) -process.HLTIterativeTrackingForElectronsIteration0 = cms.Sequence( process.hltIter0ElectronsPixelSeedsFromPixelTracks + process.hltIter0ElectronsCkfTrackCandidates + process.hltIter0ElectronsCtfWithMaterialTracks + process.hltIter0ElectronsTrackSelectionHighPurity ) -process.HLTIterativeTrackingForElectronsIteration1 = cms.Sequence( process.hltIter1ElectronsClustersRefRemoval + process.hltIter1ElectronsMaskedMeasurementTrackerEvent + process.hltIter1ElectronsPixelLayerTriplets + process.hltIter1ElectronsPixelSeeds + process.hltIter1ElectronsCkfTrackCandidates + process.hltIter1ElectronsCtfWithMaterialTracks + process.hltIter1ElectronsTrackSelectionHighPurityLoose + process.hltIter1ElectronsTrackSelectionHighPurityTight + process.hltIter1ElectronsTrackSelectionHighPurity ) -process.HLTIterativeTrackingForElectronsIteration2 = cms.Sequence( process.hltIter2ElectronsClustersRefRemoval + process.hltIter2ElectronsMaskedMeasurementTrackerEvent + process.hltIter2ElectronsPixelLayerPairs + process.hltIter2ElectronsPixelSeeds + process.hltIter2ElectronsCkfTrackCandidates + process.hltIter2ElectronsCtfWithMaterialTracks + process.hltIter2ElectronsTrackSelectionHighPurity ) -process.HLTIterativeTrackingForElectronIter02 = cms.Sequence( process.HLTIterativeTrackingForElectronsIteration0 + process.HLTIterativeTrackingForElectronsIteration1 + process.hltIter1MergedForElectrons + process.HLTIterativeTrackingForElectronsIteration2 + process.hltIter2MergedForElectrons ) -process.HLTTrackReconstructionForIsoElectronIter02 = cms.Sequence( process.HLTPixelTrackingForElectron + process.HLTDoLocalStripSequence + process.HLTIterativeTrackingForElectronIter02 ) -process.HLTEle27erWP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleIsoEG22erFilter + process.hltEG27EtL1IsoEG22erFilter + process.hltEgammaClusterShape + process.hltEle27WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEle27WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltEle27WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltEle27WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltEle27WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltEle27WP75GsfOneOEMinusOneOPFilter + process.hltEle27WP75GsfChi2Filter + process.hltEle27WP75GsfDetaFilter + process.hltEle27WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltEle27WP75GsfTrackIsoFilter ) process.HLTMuonLocalRecoSequence = cms.Sequence( process.hltMuonDTDigis + process.hltDt1DRecHits + process.hltDt4DSegments + process.hltMuonCSCDigis + process.hltCsc2DRecHits + process.hltCscSegments + process.hltMuonRPCDigis + process.hltRpcRecHits ) process.HLTL2muonrecoNocandSequence = cms.Sequence( process.HLTMuonLocalRecoSequence + process.hltL2OfflineMuonSeeds + process.hltL2MuonSeeds + process.hltL2Muons ) process.HLTL2muonrecoSequence = cms.Sequence( process.HLTL2muonrecoNocandSequence + process.hltL2MuonCandidates ) -process.HLTL3muonTkCandidateSequence = cms.Sequence( process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltL3TrajSeedOIState + process.hltL3TrackCandidateFromL2OIState + process.hltL3TkTracksFromL2OIState + process.hltL3MuonsOIState + process.hltL3TrajSeedOIHit + process.hltL3TrackCandidateFromL2OIHit + process.hltL3TkTracksFromL2OIHit + process.hltL3MuonsOIHit + process.hltL3TkFromL2OICombination + process.hltPixelLayerTriplets + process.hltPixelLayerPairs + process.hltMixedLayerPairs + process.hltL3TrajSeedIOHit + process.hltL3TrackCandidateFromL2IOHit + process.hltL3TkTracksFromL2IOHit + process.hltL3MuonsIOHit + process.hltL3TrajectorySeed + process.hltL3TrackCandidateFromL2 ) -process.HLTL3muonrecoNocandSequence = cms.Sequence( process.HLTL3muonTkCandidateSequence + process.hltL3TkTracksMergeStep1 + process.hltL3TkTracksFromL2 + process.hltL3MuonsLinksCombination + process.hltL3Muons ) -process.HLTL3muonrecoSequence = cms.Sequence( process.HLTL3muonrecoNocandSequence + process.hltL3MuonCandidates ) -process.HLTDoCaloSequencePF = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence + process.HLTDoLocalHcalSequence + process.hltTowerMakerForPF ) -process.HLTAK4CaloJetsPrePFRecoSequence = cms.Sequence( process.HLTDoCaloSequencePF + process.hltAK4CaloJetsPF ) -process.HLTPreAK4PFJetsRecoSequence = cms.Sequence( process.HLTAK4CaloJetsPrePFRecoSequence + process.hltAK4CaloJetsPFEt5 ) -process.HLTRecopixelvertexingSequence = cms.Sequence( process.hltPixelLayerTriplets + process.hltPixelTracks + process.hltPixelVertices + process.hltTrimmedPixelVertices ) -process.HLTIterativeTrackingIteration0 = cms.Sequence( process.hltIter0PFLowPixelSeedsFromPixelTracks + process.hltIter0PFlowCkfTrackCandidates + process.hltIter0PFlowCtfWithMaterialTracks + process.hltIter0PFlowTrackSelectionHighPurity ) -process.HLTIter0TrackAndTauJet4Iter1Sequence = cms.Sequence( process.hltTrackIter0RefsForJets4Iter1 + process.hltAK4Iter0TrackJets4Iter1 + process.hltIter0TrackAndTauJets4Iter1 ) -process.HLTIterativeTrackingIteration1 = cms.Sequence( process.hltIter1ClustersRefRemoval + process.hltIter1MaskedMeasurementTrackerEvent + process.hltIter1PixelLayerTriplets + process.hltIter1PFlowPixelSeeds + process.hltIter1PFlowCkfTrackCandidates + process.hltIter1PFlowCtfWithMaterialTracks + process.hltIter1PFlowTrackSelectionHighPurityLoose + process.hltIter1PFlowTrackSelectionHighPurityTight + process.hltIter1PFlowTrackSelectionHighPurity ) -process.HLTIter1TrackAndTauJets4Iter2Sequence = cms.Sequence( process.hltIter1TrackRefsForJets4Iter2 + process.hltAK4Iter1TrackJets4Iter2 + process.hltIter1TrackAndTauJets4Iter2 ) -process.HLTIterativeTrackingIteration2 = cms.Sequence( process.hltIter2ClustersRefRemoval + process.hltIter2MaskedMeasurementTrackerEvent + process.hltIter2PixelLayerPairs + process.hltIter2PFlowPixelSeeds + process.hltIter2PFlowCkfTrackCandidates + process.hltIter2PFlowCtfWithMaterialTracks + process.hltIter2PFlowTrackSelectionHighPurity ) -process.HLTIterativeTrackingIter02 = cms.Sequence( process.HLTIterativeTrackingIteration0 + process.HLTIter0TrackAndTauJet4Iter1Sequence + process.HLTIterativeTrackingIteration1 + process.hltIter1Merged + process.HLTIter1TrackAndTauJets4Iter2Sequence + process.HLTIterativeTrackingIteration2 + process.hltIter2Merged ) -process.HLTTrackReconstructionForPF = cms.Sequence( process.HLTDoLocalPixelSequence + process.HLTRecopixelvertexingSequence + process.HLTDoLocalStripSequence + process.HLTIterativeTrackingIter02 + process.hltPFMuonMerging + process.hltMuonLinks + process.hltMuons ) -process.HLTPreshowerSequence = cms.Sequence( process.hltEcalPreshowerDigis + process.hltEcalPreshowerRecHit ) -process.HLTParticleFlowSequence = cms.Sequence( process.HLTPreshowerSequence + process.hltParticleFlowRecHitECALUnseeded + process.hltParticleFlowRecHitHCAL + process.hltParticleFlowRecHitPSUnseeded + process.hltParticleFlowClusterECALUncorrectedUnseeded + process.hltParticleFlowClusterPSUnseeded + process.hltParticleFlowClusterECALUnseeded + process.hltParticleFlowClusterHCAL + process.hltParticleFlowClusterHFEM + process.hltParticleFlowClusterHFHAD + process.hltLightPFTracks + process.hltParticleFlowBlock + process.hltParticleFlow ) -process.HLTAK4PFJetsReconstructionSequence = cms.Sequence( process.HLTL2muonrecoSequence + process.HLTL3muonrecoSequence + process.HLTTrackReconstructionForPF + process.HLTParticleFlowSequence + process.hltAK4PFJets ) -process.HLTAK4PFJetsCorrectionSequence = cms.Sequence( process.hltFixedGridRhoFastjetAll + process.hltAK4PFJetsCorrected ) -process.HLTAK4PFJetsSequence = cms.Sequence( process.HLTPreAK4PFJetsRecoSequence + process.HLTAK4PFJetsReconstructionSequence + process.HLTAK4PFJetsCorrectionSequence ) -process.HLTRecoPixelVertexingForPhotonsSequence = cms.Sequence( process.hltPixelLayerTriplets + process.hltPixelTracks + process.hltPixelVerticesForPhotons ) -process.HLTIterativeTrackingForPhotonsIteration0 = cms.Sequence( process.hltIter0PFlowPixelSeedsFromPixelTracksForPhotons + process.hltIter0PFlowCkfTrackCandidatesForPhotons + process.hltIter0PFlowCtfWithMaterialTracksForPhotons + process.hltIter0PFlowTrackSelectionHighPurityForPhotons ) -process.HLTIterativeTrackingForPhotonsIteration1 = cms.Sequence( process.hltIter1ClustersRefRemovalForPhotons + process.hltIter1MaskedMeasurementTrackerEventForPhotons + process.hltIter1PixelLayerTripletsForPhotons + process.hltIter1PFlowPixelSeedsForPhotons + process.hltIter1PFlowCkfTrackCandidatesForPhotons + process.hltIter1PFlowCtfWithMaterialTracksForPhotons + process.hltIter1PFlowTrackSelectionHighPurityLooseForPhotons + process.hltIter1PFlowTrackSelectionHighPurityTightForPhotons + process.hltIter1PFlowTrackSelectionHighPurityForPhotons ) -process.HLTIterativeTrackingForPhotonsIteration2 = cms.Sequence( process.hltIter2ClustersRefRemovalForPhotons + process.hltIter2MaskedMeasurementTrackerEventForPhotons + process.hltIter2PixelLayerPairsForPhotons + process.hltIter2PFlowPixelSeedsForPhotons + process.hltIter2PFlowCkfTrackCandidatesForPhotons + process.hltIter2PFlowCtfWithMaterialTracksForPhotons + process.hltIter2PFlowTrackSelectionHighPurityForPhotons ) -process.HLTIterativeTrackingForPhotonsIter02 = cms.Sequence( process.HLTIterativeTrackingForPhotonsIteration0 + process.HLTIterativeTrackingForPhotonsIteration1 + process.hltIter1MergedForPhotons + process.HLTIterativeTrackingForPhotonsIteration2 + process.hltIter2MergedForPhotons ) -process.HLTTrackReconstructionForIsoForPhotons = cms.Sequence( process.HLTDoLocalPixelSequence + process.HLTRecoPixelVertexingForPhotonsSequence + process.HLTDoLocalStripSequence + process.HLTIterativeTrackingForPhotonsIter02 ) -process.HLTPhoton20CaloIdVLIsoLSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleEG12Filter + process.hltEG20EtFilter + process.hltEgammaClusterShape + process.hltEG20CaloIdVLClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEG20CaloIdVLHEFilter + process.hltEgammaEcalPFClusterIso + process.hltEG20CaloIdVLIsoLEcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltEG20CaloIdVLIsoLHcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.HLTTrackReconstructionForIsoForPhotons + process.hltEgammaHollowTrackIso + process.hltEG20CaloIdVLIsoLTrackIsoFilter ) +process.HLTDoHILocalPixelSequence = cms.Sequence( process.hltSiPixelDigis + process.hltHISiPixelClusters + process.hltHISiPixelClustersCache + process.hltHISiPixelRecHits ) +process.HLTDoHILocalStripSequence = cms.Sequence( process.hltSiStripExcludedFEDListProducer + process.hltSiStripRawToClustersFacility + process.hltHISiStripClusters ) +process.HLTHIL3muonTkCandidateSequence = cms.Sequence( process.HLTDoHILocalPixelSequence + process.HLTDoHILocalStripSequence + process.hltHIL3TrajSeedOIState + process.hltHIL3TrackCandidateFromL2OIState + process.hltHIL3TkTracksFromL2OIState + process.hltHIL3MuonsOIState + process.hltHIL3TrajSeedOIHit + process.hltHIL3TrackCandidateFromL2OIHit + process.hltHIL3TkTracksFromL2OIHit + process.hltHIL3MuonsOIHit + process.hltHIL3TkFromL2OICombination + process.hltHIL3TrajSeedIOHit + process.hltHIL3TrackCandidateFromL2IOHit + process.hltHIL3TkTracksFromL2IOHit + process.hltHIAllL3MuonsIOHit + process.hltHIL3TrajectorySeed + process.hltHIL3TrackCandidateFromL2 ) +process.HLTHIL3muonrecoNocandSequence = cms.Sequence( process.HLTHIL3muonTkCandidateSequence + process.hltHIL3TkTracksFromL2 + process.hltHIL3MuonsLinksCombination + process.hltHIL3Muons ) +process.HLTHIL3muonrecoSequence = cms.Sequence( process.HLTHIL3muonrecoNocandSequence + process.hltHIL3MuonCandidates ) process.HLTriggerFirstPath = cms.Path( process.hltGetConditions + process.hltGetRaw + process.hltBoolFalse ) -process.HLT_CaloJet260_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleJet200 + process.hltPreCaloJet260 + process.HLTAK4CaloJetsSequence + process.hltSingleCaloJet260 + process.HLTEndSequence ) -process.HLT_Ele27_eta2p1_WP75_Gsf_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleIsoEG22er + process.hltPreEle27eta2p1WP75Gsf + process.HLTEle27erWP75GsfSequence + process.HLTEndSequence ) -process.HLT_Mu50_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu16ORSingleMu25 + process.hltPreMu50 + process.hltL1fL1sMu16orMu25L1Filtered0 + process.HLTL2muonrecoSequence + process.hltL2fL1sMu16orMu25L1f0L2Filtered16Q + process.HLTL3muonrecoSequence + process.hltL3fL1sMu16orMu25L1f0L2f16QL3Filtered50Q + process.HLTEndSequence ) -process.HLT_PFJet260_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleJet200 + process.hltPrePFJet260 + process.HLTAK4CaloJetsSequence + process.hltSingleCaloJet210 + process.HLTAK4PFJetsSequence + process.hltPFJetsCorrectedMatchedToCaloJets210 + process.hltSinglePFJet260 + process.HLTEndSequence ) -process.HLT_Photon20_CaloIdVL_IsoL_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG10 + process.hltPrePhoton20CaloIdVLIsoL + process.HLTPhoton20CaloIdVLIsoLSequence + process.HLTEndSequence ) process.HLT_Physics_v1 = cms.Path( process.HLTBeginSequence + process.hltPrePhysics + process.HLTEndSequence ) +process.HLT_HIL1DoubleMu0_HighQ_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL1DoubleMu0HighQ + process.hltL1fL1DoubleMu0HQL1Filtered0 + process.HLTEndSequence ) +process.HLT_HIL2Mu3_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL2Mu3 + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu3L2Filtered + process.HLTEndSequence ) +process.HLT_HIL2Mu7_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL2Mu7 + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu7L2Filtered + process.HLTEndSequence ) +process.HLT_HIL2Mu15_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL2Mu15 + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu15L2Filtered + process.HLTEndSequence ) +process.HLT_HIL2Mu3_NHitQ_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL2Mu3NHitQ + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu3N1HitQL2Filtered + process.HLTEndSequence ) +process.HLT_HIL2DoubleMu0_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL2DoubleMu0 + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIL2DoubleMu0L2Filtered + process.HLTEndSequence ) +process.HLT_HIL2DoubleMu0_NHitQ_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL2DoubleMu0NHitQ + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIL2DoubleMu0L2N1HitsFiltered + process.HLTEndSequence ) +process.HLT_HIL2DoubleMu3_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL2DoubleMu3 + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIL2DoubleMu3L2Filtered + process.HLTEndSequence ) +process.HLT_HIL3Mu3_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL3Mu3 + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu3L2Filtered + process.HLTHIL3muonrecoSequence + process.hltHISingleMu3L3Filtered + process.HLTEndSequence ) +process.HLT_HIL3DoubleMuOpen_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL3DoubleMuOpen + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIDimuonL2PreFiltered0 + process.HLTHIL3muonrecoSequence + process.hltHIDimuonL3FilterOpen + process.HLTEndSequence ) +process.HLT_HIL3DoubleMuOpen_SS_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL3DoubleMuOpenSS + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIDimuonL2PreFiltered0 + process.HLTHIL3muonrecoSequence + process.hltHIDimuonL3FilterOpenSS + process.HLTEndSequence ) +process.HLT_HIL3DoubleMuOpen_OS_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL3DoubleMuOpenOS + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIDimuonL2PreFiltered0 + process.HLTHIL3muonrecoSequence + process.hltHIDimuonL3FilterOpenOS + process.HLTEndSequence ) +process.HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL3DoubleMuOpenOSNoCowboy + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIDimuonL2PreFiltered0 + process.HLTHIL3muonrecoSequence + process.hltHIDimuonL3FilterOpenOSNoCowboy + process.HLTEndSequence ) process.HLTriggerFinalPath = cms.Path( process.hltGtDigis + process.hltScalersRawToDigi + process.hltFEDSelector + process.hltTriggerSummaryAOD + process.hltTriggerSummaryRAW ) process.AOutput = cms.EndPath( process.hltPreAOutput + process.hltOutputA ) diff --git a/HLTrigger/Configuration/test/OnData_HLT_PIon.py b/HLTrigger/Configuration/test/OnData_HLT_PIon.py index d315d49edd479..cfa762dfc4f16 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_PIon.py +++ b/HLTrigger/Configuration/test/OnData_HLT_PIon.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/PIon/V4 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/PIon/V5 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTPIon" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/PIon/V4') + tableName = cms.string('/dev/CMSSW_7_4_0/PIon/V5') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( diff --git a/HLTrigger/Configuration/test/OnMc_HLT_50nsGRun.py b/HLTrigger/Configuration/test/OnMc_HLT_50nsGRun.py index f49efd5b4936f..d80fec431caee 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_50nsGRun.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_50nsGRun.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/50nsGRun/V9 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/50nsGRun/V11 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLT50nsGRun" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V9') + tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V11') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -158,7 +158,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), MeasurementTrackerName = cms.string( "hltIter4ESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator16" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator16" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -173,7 +173,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), MeasurementTrackerName = cms.string( "hltIter3ESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator16" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator16" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -187,7 +187,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), MeasurementTrackerName = cms.string( "hltIter2ESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator16" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator16" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -201,7 +201,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), MeasurementTrackerName = cms.string( "hltIter1ESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator16" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator16" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -229,7 +229,7 @@ ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialOpposite" ), MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -259,7 +259,7 @@ useSeedLayer = cms.bool( True ), deltaEta = cms.double( -1.0 ), deltaPhi = cms.double( -1.0 ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), rescaleErrorIfFail = cms.double( 1.0 ), propagatorProximity = cms.string( "SteppingHelixPropagatorAny" ), updator = cms.string( "hltESPKFUpdator" ), @@ -278,7 +278,7 @@ useSeedLayer = cms.bool( False ), deltaEta = cms.double( -1.0 ), deltaPhi = cms.double( -1.0 ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), rescaleErrorIfFail = cms.double( 1.0 ), propagatorProximity = cms.string( "SteppingHelixPropagatorAny" ), updator = cms.string( "hltESPKFUpdator" ), @@ -300,7 +300,7 @@ maxCand = cms.int32( 2 ), ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator9" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator9" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -343,7 +343,7 @@ maxCand = cms.int32( 4 ), ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( True ), @@ -356,7 +356,7 @@ maxCand = cms.int32( 2 ), ComponentType = cms.string( "CkfTrajectoryBuilder" ), propagatorOpposite = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), - estimator = cms.string( "hltESPChi2ChargeMeasurementEstimator30" ), + estimator = cms.string( "hltESPChi2MeasurementEstimator30" ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), updator = cms.string( "hltESPKFUpdator" ), alwaysUseInvalidHits = cms.bool( False ), @@ -16001,8 +16001,8 @@ reqOppCharge = cms.untracked.bool( False ), nZcandcut = cms.int32( 1 ) ) -process.hltL1sL1SingleIsoEG18 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG18" ), +process.hltL1sL1SingleIsoEG20er = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG20er" ), saveTags = cms.bool( True ), L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), L1UseL1TriggerObjectMaps = cms.bool( True ), @@ -16017,7 +16017,7 @@ L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) -process.hltEGL1SingleIsoEG18erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", +process.hltEGL1SingleIsoEG20erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", doIsolated = cms.bool( False ), endcap_end = cms.double( 2.17 ), saveTags = cms.bool( False ), @@ -16027,7 +16027,7 @@ candIsolatedTag = cms.InputTag( "hltEgammaCandidates" ), region_phi_size = cms.double( 1.044 ), region_eta_size = cms.double( 0.522 ), - L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG18" ), + L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG20er" ), candNonIsolatedTag = cms.InputTag( "" ), l1NonIsolatedTag = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), ncandcut = cms.int32( 1 ) @@ -16037,7 +16037,7 @@ L1NonIsoCand = cms.InputTag( "" ), relaxed = cms.untracked.bool( False ), L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - inputTag = cms.InputTag( "hltEGL1SingleIsoEG18erFilter" ), + inputTag = cms.InputTag( "hltEGL1SingleIsoEG20erFilter" ), etcutEB = cms.double( 22.0 ), etcutEE = cms.double( 22.0 ), ncandcut = cms.int32( 1 ) @@ -39660,7 +39660,7 @@ tanhSO10ForwardThres = cms.double( 1.0 ), L1IsoPixelSeedsTag = cms.InputTag( "hltEgammaElectronPixelSeedsUnseeded" ), L1NonIsoCand = cms.InputTag( "" ), - ncandcut = cms.int32( 1 ), + ncandcut = cms.int32( 2 ), tanhSO10BarrelThres = cms.double( 0.35 ), s_a_rF = cms.double( 0.04 ), L1NonIsoPixelSeedsTag = cms.InputTag( "" ), @@ -44211,7 +44211,7 @@ process.HLTTrackReconstructionIter02 = cms.Sequence( process.HLTPixelTrackingL3Muon + process.HLTDoLocalStripSequence + process.HLTIterativeTrackingL3MuonIter02 ) process.HLTDoublePho85Sequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleEG40ORL1SingleEG35Filter + process.hltEG85EtFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEG85HEFilter + process.HLTPFClusteringForEgammaUnseeded + process.hltEgammaCandidatesUnseeded + process.hltEgammaCandidatesWrapperUnseeded + process.hltDiEG85EtUnseededFilter + process.hltEgammaHoverEUnseeded + process.hltDiEG85HEUnseededFilter ) process.HLTEle20WP60Ele8Mass55Sequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleEG20Filter + process.hltEle20WP60Ele8EtFilter + process.hltEgammaClusterShape + process.hltEle20WP60Ele8ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEle20WP60Ele8HEFilter + process.hltEgammaEcalPFClusterIso + process.hltEle20WP60Ele8EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltEle20WP60Ele8HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltEle20WP60Ele8PixelMatchFilter + process.HLTGsfElectronSequence + process.hltEle20WP60Ele8OneOEMinusOneOPFilter + process.hltEle20WP60Ele8DetaFilter + process.hltEle20WP60Ele8DphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltEle20WP60Ele8TrackIsoFilter + process.HLTPFClusteringForEgammaUnseeded + process.hltEgammaCandidatesUnseeded + process.hltEgammaCandidatesWrapperUnseeded + process.hltEle20WP60Ele8EtUnseededFilter + process.HLTElePixelMatchUnseededSequence + process.hltEle20WP60Ele8PixelMatchUnseededFilter + process.hltEle20WP60Ele8Mass55Filter ) -process.HLTSingleEle22erWP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleIsoEG18erFilter + process.hltSingleEG22EtFilter + process.hltEgammaClusterShape + process.hltSingleEle22WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltSingleEle22WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltSingleEle22WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltSingleEle22WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltSingleEle22WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + process.hltSingleEle22WP75GsfChi2Filter + process.hltSingleEle22WP75GsfDetaFilter + process.hltSingleEle22WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltSingleEle22WP75GsfTrackIsoFilter ) +process.HLTSingleEle22erWP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleIsoEG20erFilter + process.hltSingleEG22EtFilter + process.hltEgammaClusterShape + process.hltSingleEle22WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltSingleEle22WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltSingleEle22WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltSingleEle22WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltSingleEle22WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + process.hltSingleEle22WP75GsfChi2Filter + process.hltSingleEle22WP75GsfDetaFilter + process.hltSingleEle22WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltSingleEle22WP75GsfTrackIsoFilter ) process.HLTEle22WP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGRegionalL1IsoEG20erTauJet20er + process.hltEG22L1sIsoEG20erTauJet20erEtFilter + process.hltEgammaClusterShape + process.hltEle22WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEle22WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltEle22WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltEle22WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltEle22WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltEle22WP75GsfOneOESuperMinusOneOPFilter + process.hltEle22WP75GsfChi2Filter + process.hltEle22WP75GsfDetaFilter + process.hltEle22WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltEle22WP75GsfTrackIsoFilter ) process.HLTParticleFlowSequenceForTaus = cms.Sequence( process.HLTPreshowerSequence + process.hltParticleFlowRecHitECALUnseeded + process.hltParticleFlowRecHitHCAL + process.hltParticleFlowRecHitPSUnseeded + process.hltParticleFlowClusterECALUncorrectedUnseeded + process.hltParticleFlowClusterPSUnseeded + process.hltParticleFlowClusterECALUnseeded + process.hltParticleFlowClusterHCAL + process.hltParticleFlowClusterHFEM + process.hltParticleFlowClusterHFHAD + process.hltLightPFTracks + process.hltParticleFlowBlockForTaus + process.hltParticleFlowForTaus ) process.HLTPFTriggerSequenceForTaus = cms.Sequence( process.HLTL2muonrecoSequence + process.HLTL3muonrecoSequence + process.HLTTrackReconstructionForPF + process.HLTParticleFlowSequenceForTaus + process.hltAK4PFJetsForTaus ) @@ -44440,7 +44440,7 @@ process.HLT_Dimuon6_Jpsi_NoVertexing_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMu0 + process.hltPreDimuon6JpsiNoVertexing + process.hltL1fL1DoubleMu0L1Filtered0 + process.HLTL2muonrecoSequence + process.hltL2fDoubleMu2L2PreFiltered2 + process.HLTL3muonrecoSequence + process.hltDimuon6JpsiL3Filtered + process.HLTEndSequence ) process.HLT_DoublePhoton85_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG40ORL1SingleEG35 + process.hltPreDoublePhoton85 + process.HLTDoublePho85Sequence + process.HLTEndSequence ) process.HLT_Ele20WP60_Ele8_Mass55_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG20 + process.hltPreEle20WP60Ele8Mass55 + process.HLTEle20WP60Ele8Mass55Sequence + process.HLTEndSequence ) -process.HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleIsoEG18 + process.hltPreEle22eta2p1WP75Gsf + process.HLTSingleEle22erWP75GsfSequence + process.HLTEndSequence ) +process.HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleIsoEG20er + process.hltPreEle22eta2p1WP75Gsf + process.HLTSingleEle22erWP75GsfSequence + process.HLTEndSequence ) process.HLT_Ele22_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1IsoEG20erTauJet20er + process.hltPreEle22eta2p1WP75GsfLooseIsoPFTau20 + process.HLTEle22WP75GsfSequence + process.HLTRecoJetSequenceAK4PrePF + process.hltTauJet5 + process.hltOverlapFilterIsoEle22WP75GsfCaloJet5 + process.HLTPFTriggerSequenceForTaus + process.HLTIsoEle22WP75GsfLooseIsoPFTau20Sequence + process.HLTEndSequence ) process.HLT_Ele25WP60_SC4_Mass55_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG20 + process.hltPreEle25WP60SC4Mass55 + process.HLTEle25WP60SC4Mass55Sequence + process.HLTEndSequence ) process.HLT_Ele25_eta2p1_WP85_Gsf_PFMET80_boostedW_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG40ORL1SingleIsoEG30erORL1ETM70 + process.hltPreEle25eta2p1WP85GsfPFMET80boostedW + process.HLTEle25WP85GsfSequence + process.HLTAK4PFJetsSequence + process.hltPFMETProducer + process.hltPFMET80Filter + process.HLTEndSequence ) diff --git a/HLTrigger/Configuration/test/OnMc_HLT_FULL.py b/HLTrigger/Configuration/test/OnMc_HLT_FULL.py index 3d9001490d322..26269740c388f 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_FULL.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_FULL.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/HLT/V6 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/HLT/V10 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTFULL" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V6') + tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V10') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -383,6 +383,7 @@ ) process.streams = cms.PSet( A = cms.vstring( 'InitialPD', + 'InitialPDForHI', 'Templates' ), ALCAP0 = cms.vstring( 'AlCaP0' ), ALCAPHISYM = cms.vstring( 'AlCaPhiSym' ), @@ -704,6 +705,19 @@ 'HLT_VBF_DisplacedJet40_TightID_DisplacedTrack_v1', 'HLT_VBF_DisplacedJet40_TightID_Hadronic_v1', 'HLT_ZeroBias_v1') ), + InitialPDForHI = cms.vstring( 'HLT_HIL1DoubleMu0_HighQ_v1', + 'HLT_HIL2DoubleMu0_NHitQ_v1', + 'HLT_HIL2DoubleMu0_v1', + 'HLT_HIL2DoubleMu3_v1', + 'HLT_HIL2Mu15_v1', + 'HLT_HIL2Mu3_NHitQ_v1', + 'HLT_HIL2Mu3_v1', + 'HLT_HIL2Mu7_v1', + 'HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1', + 'HLT_HIL3DoubleMuOpen_OS_v1', + 'HLT_HIL3DoubleMuOpen_SS_v1', + 'HLT_HIL3DoubleMuOpen_v1', + 'HLT_HIL3Mu3_v1' ), OfflineMonitor = cms.vstring( ), OfflineMonitorHI = cms.vstring( ), OnlineHltMonitor = cms.vstring( ), @@ -18232,8 +18246,8 @@ reqOppCharge = cms.untracked.bool( False ), nZcandcut = cms.int32( 1 ) ) -process.hltL1sL1SingleIsoEG18 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG18" ), +process.hltL1sL1SingleIsoEG20er = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG20er" ), saveTags = cms.bool( True ), L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), L1UseL1TriggerObjectMaps = cms.bool( True ), @@ -18248,7 +18262,7 @@ L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) -process.hltEGL1SingleIsoEG18erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", +process.hltEGL1SingleIsoEG20erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", doIsolated = cms.bool( False ), endcap_end = cms.double( 2.17 ), saveTags = cms.bool( False ), @@ -18258,7 +18272,7 @@ candIsolatedTag = cms.InputTag( "hltEgammaCandidates" ), region_phi_size = cms.double( 1.044 ), region_eta_size = cms.double( 0.522 ), - L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG18" ), + L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG20er" ), candNonIsolatedTag = cms.InputTag( "" ), l1NonIsolatedTag = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), ncandcut = cms.int32( 1 ) @@ -18268,7 +18282,7 @@ L1NonIsoCand = cms.InputTag( "" ), relaxed = cms.untracked.bool( False ), L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - inputTag = cms.InputTag( "hltEGL1SingleIsoEG18erFilter" ), + inputTag = cms.InputTag( "hltEGL1SingleIsoEG20erFilter" ), etcutEB = cms.double( 22.0 ), etcutEE = cms.double( 22.0 ), ncandcut = cms.int32( 1 ) @@ -41907,7 +41921,7 @@ tanhSO10ForwardThres = cms.double( 1.0 ), L1IsoPixelSeedsTag = cms.InputTag( "hltEgammaElectronPixelSeedsUnseeded" ), L1NonIsoCand = cms.InputTag( "" ), - ncandcut = cms.int32( 1 ), + ncandcut = cms.int32( 2 ), tanhSO10BarrelThres = cms.double( 0.35 ), s_a_rF = cms.double( 0.04 ), L1NonIsoPixelSeedsTag = cms.InputTag( "" ), @@ -45997,6 +46011,1214 @@ L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) +process.hltL1sL1DoubleMuOpenBptxAND = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_DoubleMuOpen_BptxAND" ), + saveTags = cms.bool( True ), + L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), + L1UseL1TriggerObjectMaps = cms.bool( True ), + L1UseAliasesForSeeding = cms.bool( True ), + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + L1CollectionsTag = cms.InputTag( "hltL1extraParticles" ), + L1NrBxInEvent = cms.int32( 3 ), + L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), + L1TechTriggerSeeding = cms.bool( False ) +) +process.hltPreHIL1DoubleMu0HighQ = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltL1fL1DoubleMu0HQL1Filtered0 = cms.EDFilter( "HLTMuonL1Filter", + saveTags = cms.bool( True ), + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1DoubleMuOpenBptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "hltL1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) +) +process.hltL1sL1SingleMu3BptxAND = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleMu3_BptxAND" ), + saveTags = cms.bool( True ), + L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), + L1UseL1TriggerObjectMaps = cms.bool( True ), + L1UseAliasesForSeeding = cms.bool( True ), + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + L1CollectionsTag = cms.InputTag( "hltL1extraParticles" ), + L1NrBxInEvent = cms.int32( 3 ), + L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), + L1TechTriggerSeeding = cms.bool( False ) +) +process.hltPreHIL2Mu3 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIL1SingleMu3Filtered = cms.EDFilter( "HLTMuonL1Filter", + saveTags = cms.bool( False ), + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1SingleMu3BptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 1 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "hltL1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) +) +process.hltHIL2Mu3L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2Mu7 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIL2Mu7L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 7.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2Mu15 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIL2Mu15L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 15.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2Mu3NHitQ = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIL2Mu3N1HitQL2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 1 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2DoubleMu0 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIDoubleMuLevel1PathL1OpenFiltered = cms.EDFilter( "HLTMuonL1Filter", + saveTags = cms.bool( True ), + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1DoubleMuOpenBptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "hltL1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) +) +process.hltHIL2DoubleMu0L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2DoubleMu0NHitQ = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIL2DoubleMu0L2N1HitsFiltered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 1 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2DoubleMu3 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIL2DoubleMu3L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL3Mu3 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHISiPixelClusters = cms.EDProducer( "SiPixelClusterProducer", + src = cms.InputTag( "hltSiPixelDigis" ), + ChannelThreshold = cms.int32( 1000 ), + maxNumberOfClusters = cms.int32( -1 ), + VCaltoElectronGain = cms.int32( 65 ), + MissCalibrate = cms.untracked.bool( True ), + SplitClusters = cms.bool( False ), + VCaltoElectronOffset = cms.int32( -414 ), + payloadType = cms.string( "HLT" ), + SeedThreshold = cms.int32( 1000 ), + ClusterThreshold = cms.double( 4000.0 ) +) +process.hltHISiPixelClustersCache = cms.EDProducer( "SiPixelClusterShapeCacheProducer", + src = cms.InputTag( "hltHISiPixelClusters" ), + onDemand = cms.bool( False ) +) +process.hltHISiPixelRecHits = cms.EDProducer( "SiPixelRecHitConverter", + VerboseLevel = cms.untracked.int32( 0 ), + src = cms.InputTag( "hltHISiPixelClusters" ), + CPE = cms.string( "hltESPPixelCPEGeneric" ) +) +process.hltHISiStripClusters = cms.EDProducer( "MeasurementTrackerEventProducer", + inactivePixelDetectorLabels = cms.VInputTag( ), + stripClusterProducer = cms.string( "hltSiStripRawToClustersFacility" ), + pixelClusterProducer = cms.string( "hltHISiPixelClusters" ), + switchOffPixelsIfEmpty = cms.bool( True ), + inactiveStripDetectorLabels = cms.VInputTag( 'hltSiStripExcludedFEDListProducer' ), + skipClusters = cms.InputTag( "" ), + measurementTracker = cms.string( "hltESPMeasurementTracker" ) +) +process.hltHIL3TrajSeedOIState = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + propagatorCompatibleName = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + option = cms.uint32( 3 ), + maxChi2 = cms.double( 40.0 ), + errorMatrixPset = cms.PSet( + atIP = cms.bool( True ), + action = cms.string( "use" ), + errorMatrixValuesPSet = cms.PSet( + pf3_V12 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V13 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V11 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V14 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V15 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), + pf3_V33 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + zAxis = cms.vdouble( -3.14159, 3.14159 ), + pf3_V44 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), + pf3_V22 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V23 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V45 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V55 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V34 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V35 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V25 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V24 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ) + ) + ), + propagatorName = cms.string( "hltESPSteppingHelixPropagatorAlong" ), + manySeeds = cms.bool( False ), + copyMuonRecHit = cms.bool( False ), + ComponentName = cms.string( "TSGForRoadSearch" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ) + ), + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSteppingHelixPropagatorOpposite', + 'hltESPSteppingHelixPropagatorAlong' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( ), + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( ), + PtCut = cms.double( 1.0 ) +) +process.hltHIL3TrackCandidateFromL2OIState = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedOIState" ), + reverseTrajectories = cms.bool( True ), + TransientInitialStateEstimatorParameters = cms.PSet( + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), + numberMeasurementsForFit = cms.int32( 4 ), + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) + ), + TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + cleanTrajectoryAfterInOut = cms.bool( False ), + useHitsSplitting = cms.bool( False ), + RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), + doSeedingRegionRebuilding = cms.bool( False ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilderSeedHit" ) ), + NavigationSchool = cms.string( "SimpleNavigationSchool" ), + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) +) +process.hltHIL3TkTracksFromL2OIState = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2OIState" ), + SimpleMagneticField = cms.string( "" ), + clusterRemovalInfo = cms.InputTag( "" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), + useHitsSplitting = cms.bool( False ), + MeasurementTracker = cms.string( "" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), + NavigationSchool = cms.string( "" ), + TrajectoryInEvent = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + GeometricInnerState = cms.bool( True ), + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +process.hltHIL3MuonsOIState = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) + ), + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + ), + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) + ), + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) + ), + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2OIState" ), + tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) + ), + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) + ), + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) +) +process.hltHIL3TrajSeedOIHit = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + PSetNames = cms.vstring( 'skipTSG', + 'iterativeTSG' ), + L3TkCollectionA = cms.InputTag( "hltHIL3MuonsOIState" ), + iterativeTSG = cms.PSet( + ErrorRescaling = cms.double( 3.0 ), + beamSpot = cms.InputTag( "unused" ), + MaxChi2 = cms.double( 40.0 ), + errorMatrixPset = cms.PSet( + atIP = cms.bool( True ), + action = cms.string( "use" ), + errorMatrixValuesPSet = cms.PSet( + pf3_V12 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V13 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V11 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V14 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V15 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), + pf3_V33 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + zAxis = cms.vdouble( -3.14159, 3.14159 ), + pf3_V44 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), + pf3_V22 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V23 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V45 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V55 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V34 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V35 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V25 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V24 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ) + ) + ), + UpdateState = cms.bool( True ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + SelectState = cms.bool( False ), + SigmaZ = cms.double( 25.0 ), + ResetMethod = cms.string( "matrix" ), + ComponentName = cms.string( "TSGFromPropagation" ), + UseVertexState = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAnyOpposite" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ) + ), + skipTSG = cms.PSet( ), + ComponentName = cms.string( "DualByL2TSG" ) + ), + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'PropagatorWithMaterial', + 'hltESPSmartPropagatorAnyOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( ), + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( + cleanerFromSharedHits = cms.bool( True ), + ptCleaner = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + directionCleaner = cms.bool( True ) + ), + PtCut = cms.double( 1.0 ) +) +process.hltHIL3TrackCandidateFromL2OIHit = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedOIHit" ), + reverseTrajectories = cms.bool( True ), + TransientInitialStateEstimatorParameters = cms.PSet( + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), + numberMeasurementsForFit = cms.int32( 4 ), + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) + ), + TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + cleanTrajectoryAfterInOut = cms.bool( False ), + useHitsSplitting = cms.bool( False ), + RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), + doSeedingRegionRebuilding = cms.bool( False ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), + NavigationSchool = cms.string( "SimpleNavigationSchool" ), + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) +) +process.hltHIL3TkTracksFromL2OIHit = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2OIHit" ), + SimpleMagneticField = cms.string( "" ), + clusterRemovalInfo = cms.InputTag( "" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), + useHitsSplitting = cms.bool( False ), + MeasurementTracker = cms.string( "" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), + NavigationSchool = cms.string( "" ), + TrajectoryInEvent = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + GeometricInnerState = cms.bool( True ), + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +process.hltHIL3MuonsOIHit = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) + ), + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + ), + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) + ), + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) + ), + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2OIHit" ), + tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) + ), + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) + ), + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) +) +process.hltHIL3TkFromL2OICombination = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit' ) +) +process.hltHIL3TrajSeedIOHit = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + PSetNames = cms.vstring( 'skipTSG', + 'skipTSG' ), + L3TkCollectionA = cms.InputTag( "hltHIL3TkFromL2OICombination" ), + iterativeTSG = cms.PSet( + firstTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + ComponentName = cms.string( "StandardHitTripletGenerator" ), + GeneratorPSet = cms.PSet( + useBending = cms.bool( True ), + useFixedPreFiltering = cms.bool( False ), + maxElement = cms.uint32( 0 ), + phiPreFiltering = cms.double( 0.3 ), + extraHitRPhitolerance = cms.double( 0.06 ), + useMultScattering = cms.bool( True ), + ComponentName = cms.string( "PixelTripletHLTGenerator" ), + extraHitRZtolerance = cms.double( 0.06 ), + SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) + ), + SeedingLayers = cms.InputTag( "hltPixelLayerTriplets" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ), + PSetNames = cms.vstring( 'firstTSG', + 'secondTSG' ), + ComponentName = cms.string( "CombinedTSG" ), + thirdTSG = cms.PSet( + PSetNames = cms.vstring( 'endcapTSG', + 'barrelTSG' ), + barrelTSG = cms.PSet( ), + endcapTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + maxElement = cms.uint32( 0 ), + ComponentName = cms.string( "StandardHitPairGenerator" ), + useOnDemandTracker = cms.untracked.int32( 0 ), + SeedingLayers = cms.InputTag( "hltMixedLayerPairs" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ), + etaSeparation = cms.double( 2.0 ), + ComponentName = cms.string( "DualByEtaTSG" ) + ), + secondTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + maxElement = cms.uint32( 0 ), + ComponentName = cms.string( "StandardHitPairGenerator" ), + useOnDemandTracker = cms.untracked.int32( 0 ), + SeedingLayers = cms.InputTag( "hltPixelLayerPairs" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ) + ), + skipTSG = cms.PSet( ), + ComponentName = cms.string( "DualByL2TSG" ) + ), + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'PropagatorWithMaterial' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.1 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.1 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + ), + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( + cleanerFromSharedHits = cms.bool( True ), + ptCleaner = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + directionCleaner = cms.bool( True ) + ), + PtCut = cms.double( 1.0 ) +) +process.hltHIL3TrackCandidateFromL2IOHit = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedIOHit" ), + reverseTrajectories = cms.bool( False ), + TransientInitialStateEstimatorParameters = cms.PSet( + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), + numberMeasurementsForFit = cms.int32( 4 ), + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) + ), + TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + cleanTrajectoryAfterInOut = cms.bool( False ), + useHitsSplitting = cms.bool( False ), + RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), + doSeedingRegionRebuilding = cms.bool( False ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), + NavigationSchool = cms.string( "SimpleNavigationSchool" ), + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) +) +process.hltHIL3TkTracksFromL2IOHit = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2IOHit" ), + SimpleMagneticField = cms.string( "" ), + clusterRemovalInfo = cms.InputTag( "" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), + useHitsSplitting = cms.bool( False ), + MeasurementTracker = cms.string( "" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), + NavigationSchool = cms.string( "" ), + TrajectoryInEvent = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + GeometricInnerState = cms.bool( True ), + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +process.hltHIAllL3MuonsIOHit = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) + ), + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + ), + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) + ), + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) + ), + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2IOHit" ), + tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) + ), + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) + ), + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) + ), + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) +) +process.hltHIL3TrajectorySeed = cms.EDProducer( "L3MuonTrajectorySeedCombiner", + labels = cms.VInputTag( 'hltHIL3TrajSeedIOHit','hltHIL3TrajSeedOIState','hltHIL3TrajSeedOIHit' ) +) +process.hltHIL3TrackCandidateFromL2 = cms.EDProducer( "L3TrackCandCombiner", + labels = cms.VInputTag( 'hltHIL3TrackCandidateFromL2IOHit','hltHIL3TrackCandidateFromL2OIHit','hltHIL3TrackCandidateFromL2OIState' ) +) +process.hltHIL3TkTracksFromL2 = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3TkTracksFromL2IOHit','hltHIL3TkTracksFromL2OIHit','hltHIL3TkTracksFromL2OIState' ) +) +process.hltHIL3MuonsLinksCombination = cms.EDProducer( "L3TrackLinksCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit','hltHIAllL3MuonsIOHit' ) +) +process.hltHIL3Muons = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit','hltHIAllL3MuonsIOHit' ) +) +process.hltHIL3MuonCandidates = cms.EDProducer( "L3MuonCandidateProducer", + InputLinksObjects = cms.InputTag( "hltHIL3MuonsLinksCombination" ), + InputObjects = cms.InputTag( "hltHIL3Muons" ), + MuonPtOption = cms.string( "Global" ) +) +process.hltHISingleMu3L3Filtered = cms.EDFilter( "HLTMuonL3PreFilter", + MaxNormalizedChi2 = cms.double( 20.0 ), + saveTags = cms.bool( True ), + PreviousCandTag = cms.InputTag( "hltHIL2Mu3L2Filtered" ), + MinNmuonHits = cms.int32( 0 ), + MinN = cms.int32( 1 ), + MinTrackPt = cms.double( 0.0 ), + MaxEta = cms.double( 2.5 ), + MaxDXYBeamSpot = cms.double( 0.1 ), + MinNhits = cms.int32( 0 ), + MinDxySig = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MaxDz = cms.double( 9999.0 ), + MaxPtDifference = cms.double( 9999.0 ), + MaxDr = cms.double( 2.0 ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + MinDXYBeamSpot = cms.double( -1.0 ), + MinDr = cms.double( -1.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinPt = cms.double( 3.0 ) +) +process.hltPreHIL3DoubleMuOpen = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIDimuonL2PreFiltered0 = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltHIDimuonL3FilterOpen = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( 0 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +process.hltPreHIL3DoubleMuOpenSS = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIDimuonL3FilterOpenSS = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( 1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +process.hltPreHIL3DoubleMuOpenOS = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIDimuonL3FilterOpenOS = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( -1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +process.hltPreHIL3DoubleMuOpenOSNoCowboy = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIDimuonL3FilterOpenOSNoCowboy = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( -1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( True ), + MinInvMass = cms.vdouble( 0.0 ) +) process.hltFEDSelector = cms.EDProducer( "EvFFEDSelector", inputTag = cms.InputTag( "rawDataCollector" ), fedList = cms.vuint32( 1023 ) @@ -46138,6 +47360,19 @@ 'HLT_Ele35_eta2p1_WP85_Gsf_v1', 'HLT_Ele40_eta2p1_WP85_Gsf_v1', 'HLT_Ele45_CaloIdVT_GsfTrkIdT_PFJet200_PFJet50_v1', + 'HLT_HIL1DoubleMu0_HighQ_v1', + 'HLT_HIL2DoubleMu0_NHitQ_v1', + 'HLT_HIL2DoubleMu0_v1', + 'HLT_HIL2DoubleMu3_v1', + 'HLT_HIL2Mu15_v1', + 'HLT_HIL2Mu3_NHitQ_v1', + 'HLT_HIL2Mu3_v1', + 'HLT_HIL2Mu7_v1', + 'HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1', + 'HLT_HIL3DoubleMuOpen_OS_v1', + 'HLT_HIL3DoubleMuOpen_SS_v1', + 'HLT_HIL3DoubleMuOpen_v1', + 'HLT_HIL3Mu3_v1', 'HLT_HT200_v1', 'HLT_HT250_v1', 'HLT_HT300_v1', @@ -46274,8 +47509,7 @@ 'HLT_PFJet400_v1', 'HLT_PFJet40_v1', 'HLT_PFJet450_v1', - 'HLT_PFJet500_v1', - 'HLT_PFJet60_v1', + 'HLT_PFJet500_v1')+cms.vstring( 'HLT_PFJet60_v1', 'HLT_PFJet80_v1', 'HLT_PFMET100_PFMHT100_IDLoose_v1', 'HLT_PFMET110_PFMHT110_IDLoose_v1', @@ -46287,7 +47521,8 @@ 'HLT_PFchMET90_NoiseCleaned_v1', 'HLT_Photon120_R9Id90_HE10_Iso40_EBOnly_PFMET40_v1', 'HLT_Photon120_R9Id90_HE10_Iso40_EBOnly_VBF_v1', - 'HLT_Photon120_R9Id90_HE10_IsoM_v1')+cms.vstring( 'HLT_Photon120_v1', + 'HLT_Photon120_R9Id90_HE10_IsoM_v1', + 'HLT_Photon120_v1', 'HLT_Photon135_PFMET100_NoiseCleaned_v1', 'HLT_Photon165_HE10_v1', 'HLT_Photon165_R9Id90_HE10_IsoM_v1', @@ -46475,7 +47710,7 @@ process.HLTDoublePho85Sequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleEG40ORL1SingleEG35Filter + process.hltEG85EtFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEG85HEFilter + process.HLTPFClusteringForEgammaUnseeded + process.hltEgammaCandidatesUnseeded + process.hltEgammaCandidatesWrapperUnseeded + process.hltDiEG85EtUnseededFilter + process.hltEgammaHoverEUnseeded + process.hltDiEG85HEUnseededFilter ) process.HLTEle17Ele8GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1DoubleEG1510Filter + process.hltEle17Ele8EtLeg1Filter + process.hltEle17Ele8EtLeg2Filter + process.hltEgammaClusterShape + process.hltEle17Ele8ClusterShapeLeg1Filter + process.hltEle17Ele8ClusterShapeLeg2Filter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEle17Ele8HELeg1Filter + process.hltEle17Ele8HELeg2Filter + process.hltEgammaEcalPFClusterIso + process.hltEle17Ele8EcalIsoLeg1Filter + process.hltEle17Ele8EcalIsoLeg2Filter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltEle17Ele8HcalIsoLeg1Filter + process.hltEle17Ele8HcalIsoLeg2Filter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltEle17Ele8PixelMatchLeg1Filter + process.hltEle17Ele8PixelMatchLeg2Filter + process.HLTGsfElectronSequence + process.hltEle17Ele8GsfDetaLeg1Filter + process.hltEle17Ele8GsfDetaLeg2Filter + process.hltEle17Ele8GsfDphiLeg1Filter + process.hltEle17Ele8GsfDphiLeg2Filter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltEle17Ele8GsfTrackIsoLeg1Filter + process.hltEle17Ele8GsfTrackIsoLeg2Filter ) process.HLTEle20WP60Ele8Mass55Sequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleEG20Filter + process.hltEle20WP60Ele8EtFilter + process.hltEgammaClusterShape + process.hltEle20WP60Ele8ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEle20WP60Ele8HEFilter + process.hltEgammaEcalPFClusterIso + process.hltEle20WP60Ele8EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltEle20WP60Ele8HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltEle20WP60Ele8PixelMatchFilter + process.HLTGsfElectronSequence + process.hltEle20WP60Ele8OneOEMinusOneOPFilter + process.hltEle20WP60Ele8DetaFilter + process.hltEle20WP60Ele8DphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltEle20WP60Ele8TrackIsoFilter + process.HLTPFClusteringForEgammaUnseeded + process.hltEgammaCandidatesUnseeded + process.hltEgammaCandidatesWrapperUnseeded + process.hltEle20WP60Ele8EtUnseededFilter + process.HLTElePixelMatchUnseededSequence + process.hltEle20WP60Ele8PixelMatchUnseededFilter + process.hltEle20WP60Ele8Mass55Filter ) -process.HLTSingleEle22erWP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleIsoEG18erFilter + process.hltSingleEG22EtFilter + process.hltEgammaClusterShape + process.hltSingleEle22WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltSingleEle22WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltSingleEle22WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltSingleEle22WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltSingleEle22WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + process.hltSingleEle22WP75GsfChi2Filter + process.hltSingleEle22WP75GsfDetaFilter + process.hltSingleEle22WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltSingleEle22WP75GsfTrackIsoFilter ) +process.HLTSingleEle22erWP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleIsoEG20erFilter + process.hltSingleEG22EtFilter + process.hltEgammaClusterShape + process.hltSingleEle22WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltSingleEle22WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltSingleEle22WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltSingleEle22WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltSingleEle22WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + process.hltSingleEle22WP75GsfChi2Filter + process.hltSingleEle22WP75GsfDetaFilter + process.hltSingleEle22WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltSingleEle22WP75GsfTrackIsoFilter ) process.HLTEle22WP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGRegionalL1IsoEG20erTauJet20er + process.hltEG22L1sIsoEG20erTauJet20erEtFilter + process.hltEgammaClusterShape + process.hltEle22WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEle22WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltEle22WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltEle22WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltEle22WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltEle22WP75GsfOneOESuperMinusOneOPFilter + process.hltEle22WP75GsfChi2Filter + process.hltEle22WP75GsfDetaFilter + process.hltEle22WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltEle22WP75GsfTrackIsoFilter ) process.HLTLooseIsoPFTauSequence = cms.Sequence( process.hltTauPFJets08Region + process.hltTauPFJetsRecoTauChargedHadrons + process.hltPFTauPiZeros + process.hltPFTausSansRef + process.hltPFTaus + process.hltPFTauTrackFindingDiscriminator + process.hltPFTauLooseAbsoluteIsolationDiscriminator + process.hltPFTauLooseRelativeIsolationDiscriminator + process.hltPFTauLooseAbsOrRelIsolationDiscriminator ) process.HLTIsoEle22WP75GsfLooseIsoPFTau20Sequence = cms.Sequence( process.HLTLooseIsoPFTauSequence + process.hltPFTau20 + process.hltSelectedPFTausTrackFinding + process.hltPFTau20Track + process.hltSelectedPFTausTrackFindingLooseIsolation + process.hltPFTau20TrackLooseIso + process.hltOverlapFilterIsoEle22WP75GsfLooseIsoPFTau20 ) @@ -46665,6 +47900,11 @@ process.HLTMu15IsolationSequence = cms.Sequence( process.HLTL3muonEcalPFisorecoSequenceNoBoolsUnseeded + process.hltL3fL1sMu5L1f0L2f3QL3Filtered15QL3pfecalIsoRhoFilteredEB0p13EE0p10 + process.HLTL3muonHcalPFisorecoSequenceNoBoolsUnseeded + process.hltL3fL1sMu5L1f0L2f3QL3Filtered15QL3pfhcalIsoRhoFiltered0p23 + process.HLTTrackReconstructionForIsoL3MuonIter02 + process.hltMuonTkRelIsolationCut0p09Map ) process.HLTRecopixelvertexingForHighMultSequence = cms.Sequence( process.hltPixelLayerTriplets + process.hltPixelTracksForHighMult + process.hltPixelVerticesForHighMult ) process.HLTBeginSequenceRandom = cms.Sequence( process.hltRandomEventsFilter + process.hltGtDigis ) +process.HLTDoHILocalPixelSequence = cms.Sequence( process.hltSiPixelDigis + process.hltHISiPixelClusters + process.hltHISiPixelClustersCache + process.hltHISiPixelRecHits ) +process.HLTDoHILocalStripSequence = cms.Sequence( process.hltSiStripExcludedFEDListProducer + process.hltSiStripRawToClustersFacility + process.hltHISiStripClusters ) +process.HLTHIL3muonTkCandidateSequence = cms.Sequence( process.HLTDoHILocalPixelSequence + process.HLTDoHILocalStripSequence + process.hltHIL3TrajSeedOIState + process.hltHIL3TrackCandidateFromL2OIState + process.hltHIL3TkTracksFromL2OIState + process.hltHIL3MuonsOIState + process.hltHIL3TrajSeedOIHit + process.hltHIL3TrackCandidateFromL2OIHit + process.hltHIL3TkTracksFromL2OIHit + process.hltHIL3MuonsOIHit + process.hltHIL3TkFromL2OICombination + process.hltHIL3TrajSeedIOHit + process.hltHIL3TrackCandidateFromL2IOHit + process.hltHIL3TkTracksFromL2IOHit + process.hltHIAllL3MuonsIOHit + process.hltHIL3TrajectorySeed + process.hltHIL3TrackCandidateFromL2 ) +process.HLTHIL3muonrecoNocandSequence = cms.Sequence( process.HLTHIL3muonTkCandidateSequence + process.hltHIL3TkTracksFromL2 + process.hltHIL3MuonsLinksCombination + process.hltHIL3Muons ) +process.HLTHIL3muonrecoSequence = cms.Sequence( process.HLTHIL3muonrecoNocandSequence + process.hltHIL3MuonCandidates ) process.HLTriggerFirstPath = cms.Path( process.hltGetConditions + process.hltGetRaw + process.hltBoolFalse ) process.HLT_AK8PFJet360TrimMod_Mass30_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleJet176ORSingleJet200 + process.hltPreAK8PFJet360TrimModMass30 + process.HLTAK8CaloJetsSequence + process.hltAK8SingleCaloJet260 + process.HLTAK8PFJetsSequence + process.hltAK8PFJetsCorrectedMatchedToCaloJets260 + process.hltAK8TrimModJets + process.hltAK8SinglePFJet360TrimModMass30 + process.HLTEndSequence ) @@ -46703,7 +47943,7 @@ process.HLT_DoublePhoton85_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG40ORL1SingleEG35 + process.hltPreDoublePhoton85 + process.HLTDoublePho85Sequence + process.HLTEndSequence ) process.HLT_Ele17_Ele8_Gsf_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleEG1510 + process.hltPreEle17Ele8Gsf + process.HLTEle17Ele8GsfSequence + process.HLTEndSequence ) process.HLT_Ele20WP60_Ele8_Mass55_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG20 + process.hltPreEle20WP60Ele8Mass55 + process.HLTEle20WP60Ele8Mass55Sequence + process.HLTEndSequence ) -process.HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleIsoEG18 + process.hltPreEle22eta2p1WP75Gsf + process.HLTSingleEle22erWP75GsfSequence + process.HLTEndSequence ) +process.HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleIsoEG20er + process.hltPreEle22eta2p1WP75Gsf + process.HLTSingleEle22erWP75GsfSequence + process.HLTEndSequence ) process.HLT_Ele22_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1IsoEG20erTauJet20er + process.hltPreEle22eta2p1WP75GsfLooseIsoPFTau20 + process.HLTEle22WP75GsfSequence + process.HLTRecoJetSequenceAK4PrePF + process.hltTauJet5 + process.hltOverlapFilterIsoEle22WP75GsfCaloJet5 + process.HLTPFTriggerSequenceForTaus + process.HLTIsoEle22WP75GsfLooseIsoPFTau20Sequence + process.HLTEndSequence ) process.HLT_Ele25WP60_SC4_Mass55_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG20 + process.hltPreEle25WP60SC4Mass55 + process.HLTEle25WP60SC4Mass55Sequence + process.HLTEndSequence ) process.HLT_Ele25_eta2p1_WP85_Gsf_PFMET80_boostedW_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG40ORL1SingleIsoEG30erORL1ETM70 + process.hltPreEle25eta2p1WP85GsfPFMET80boostedW + process.HLTEle25WP85GsfSequence + process.HLTAK4PFJetsSequence + process.hltPFMETProducer + process.hltPFMET80Filter + process.HLTEndSequence ) @@ -46986,6 +48226,19 @@ process.HLT_ReducedIterativeTracking_v1 = cms.Path( process.HLTBeginSequence + process.hltPreReducedIterativeTracking + process.HLTRecoJetSequenceAK4PrePF + process.HLTDoLocalPixelSequence + process.HLTRecopixelvertexingSequence + process.HLTDoLocalStripSequence + process.HLTIterativeTrackingIter02 + process.HLTEndSequence ) process.HLT_Random_v1 = cms.Path( process.HLTBeginSequenceRandom + process.hltPreRandom + process.HLTEndSequence ) process.HLT_ZeroBias_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1ZeroBias + process.hltPreZeroBias + process.HLTEndSequence ) +process.HLT_HIL1DoubleMu0_HighQ_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL1DoubleMu0HighQ + process.hltL1fL1DoubleMu0HQL1Filtered0 + process.HLTEndSequence ) +process.HLT_HIL2Mu3_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL2Mu3 + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu3L2Filtered + process.HLTEndSequence ) +process.HLT_HIL2Mu7_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL2Mu7 + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu7L2Filtered + process.HLTEndSequence ) +process.HLT_HIL2Mu15_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL2Mu15 + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu15L2Filtered + process.HLTEndSequence ) +process.HLT_HIL2Mu3_NHitQ_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL2Mu3NHitQ + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu3N1HitQL2Filtered + process.HLTEndSequence ) +process.HLT_HIL2DoubleMu0_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL2DoubleMu0 + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIL2DoubleMu0L2Filtered + process.HLTEndSequence ) +process.HLT_HIL2DoubleMu0_NHitQ_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL2DoubleMu0NHitQ + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIL2DoubleMu0L2N1HitsFiltered + process.HLTEndSequence ) +process.HLT_HIL2DoubleMu3_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL2DoubleMu3 + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIL2DoubleMu3L2Filtered + process.HLTEndSequence ) +process.HLT_HIL3Mu3_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL3Mu3 + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu3L2Filtered + process.HLTHIL3muonrecoSequence + process.hltHISingleMu3L3Filtered + process.HLTEndSequence ) +process.HLT_HIL3DoubleMuOpen_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL3DoubleMuOpen + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIDimuonL2PreFiltered0 + process.HLTHIL3muonrecoSequence + process.hltHIDimuonL3FilterOpen + process.HLTEndSequence ) +process.HLT_HIL3DoubleMuOpen_SS_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL3DoubleMuOpenSS + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIDimuonL2PreFiltered0 + process.HLTHIL3muonrecoSequence + process.hltHIDimuonL3FilterOpenSS + process.HLTEndSequence ) +process.HLT_HIL3DoubleMuOpen_OS_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL3DoubleMuOpenOS + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIDimuonL2PreFiltered0 + process.HLTHIL3muonrecoSequence + process.hltHIDimuonL3FilterOpenOS + process.HLTEndSequence ) +process.HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL3DoubleMuOpenOSNoCowboy + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIDimuonL2PreFiltered0 + process.HLTHIL3muonrecoSequence + process.hltHIDimuonL3FilterOpenOSNoCowboy + process.HLTEndSequence ) process.HLTriggerFinalPath = cms.Path( process.hltGtDigis + process.hltScalersRawToDigi + process.hltFEDSelector + process.hltTriggerSummaryAOD + process.hltTriggerSummaryRAW ) process.AOutput = cms.EndPath( process.hltPreAOutput + process.hltOutputA ) diff --git a/HLTrigger/Configuration/test/OnMc_HLT_GRun.py b/HLTrigger/Configuration/test/OnMc_HLT_GRun.py index 3dc3cebffe914..0d482a568dda1 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_GRun.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_GRun.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/GRun/V4 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/GRun/V5 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTGRun" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V4') + tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V5') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -16042,8 +16042,8 @@ reqOppCharge = cms.untracked.bool( False ), nZcandcut = cms.int32( 1 ) ) -process.hltL1sL1SingleIsoEG18 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG18" ), +process.hltL1sL1SingleIsoEG20er = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG20er" ), saveTags = cms.bool( True ), L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), L1UseL1TriggerObjectMaps = cms.bool( True ), @@ -16058,7 +16058,7 @@ L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) -process.hltEGL1SingleIsoEG18erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", +process.hltEGL1SingleIsoEG20erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", doIsolated = cms.bool( False ), endcap_end = cms.double( 2.17 ), saveTags = cms.bool( False ), @@ -16068,7 +16068,7 @@ candIsolatedTag = cms.InputTag( "hltEgammaCandidates" ), region_phi_size = cms.double( 1.044 ), region_eta_size = cms.double( 0.522 ), - L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG18" ), + L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG20er" ), candNonIsolatedTag = cms.InputTag( "" ), l1NonIsolatedTag = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), ncandcut = cms.int32( 1 ) @@ -16078,7 +16078,7 @@ L1NonIsoCand = cms.InputTag( "" ), relaxed = cms.untracked.bool( False ), L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - inputTag = cms.InputTag( "hltEGL1SingleIsoEG18erFilter" ), + inputTag = cms.InputTag( "hltEGL1SingleIsoEG20erFilter" ), etcutEB = cms.double( 22.0 ), etcutEE = cms.double( 22.0 ), ncandcut = cms.int32( 1 ) @@ -39701,7 +39701,7 @@ tanhSO10ForwardThres = cms.double( 1.0 ), L1IsoPixelSeedsTag = cms.InputTag( "hltEgammaElectronPixelSeedsUnseeded" ), L1NonIsoCand = cms.InputTag( "" ), - ncandcut = cms.int32( 1 ), + ncandcut = cms.int32( 2 ), tanhSO10BarrelThres = cms.double( 0.35 ), s_a_rF = cms.double( 0.04 ), L1NonIsoPixelSeedsTag = cms.InputTag( "" ), @@ -44011,7 +44011,7 @@ process.HLTTrackReconstructionIter02 = cms.Sequence( process.HLTPixelTrackingL3Muon + process.HLTDoLocalStripSequence + process.HLTIterativeTrackingL3MuonIter02 ) process.HLTDoublePho85Sequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleEG40ORL1SingleEG35Filter + process.hltEG85EtFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEG85HEFilter + process.HLTPFClusteringForEgammaUnseeded + process.hltEgammaCandidatesUnseeded + process.hltEgammaCandidatesWrapperUnseeded + process.hltDiEG85EtUnseededFilter + process.hltEgammaHoverEUnseeded + process.hltDiEG85HEUnseededFilter ) process.HLTEle20WP60Ele8Mass55Sequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleEG20Filter + process.hltEle20WP60Ele8EtFilter + process.hltEgammaClusterShape + process.hltEle20WP60Ele8ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEle20WP60Ele8HEFilter + process.hltEgammaEcalPFClusterIso + process.hltEle20WP60Ele8EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltEle20WP60Ele8HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltEle20WP60Ele8PixelMatchFilter + process.HLTGsfElectronSequence + process.hltEle20WP60Ele8OneOEMinusOneOPFilter + process.hltEle20WP60Ele8DetaFilter + process.hltEle20WP60Ele8DphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltEle20WP60Ele8TrackIsoFilter + process.HLTPFClusteringForEgammaUnseeded + process.hltEgammaCandidatesUnseeded + process.hltEgammaCandidatesWrapperUnseeded + process.hltEle20WP60Ele8EtUnseededFilter + process.HLTElePixelMatchUnseededSequence + process.hltEle20WP60Ele8PixelMatchUnseededFilter + process.hltEle20WP60Ele8Mass55Filter ) -process.HLTSingleEle22erWP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleIsoEG18erFilter + process.hltSingleEG22EtFilter + process.hltEgammaClusterShape + process.hltSingleEle22WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltSingleEle22WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltSingleEle22WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltSingleEle22WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltSingleEle22WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + process.hltSingleEle22WP75GsfChi2Filter + process.hltSingleEle22WP75GsfDetaFilter + process.hltSingleEle22WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltSingleEle22WP75GsfTrackIsoFilter ) +process.HLTSingleEle22erWP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleIsoEG20erFilter + process.hltSingleEG22EtFilter + process.hltEgammaClusterShape + process.hltSingleEle22WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltSingleEle22WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltSingleEle22WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltSingleEle22WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltSingleEle22WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltSingleEle22WP75GsfOneOESuperMinusOneOPFilter + process.hltSingleEle22WP75GsfChi2Filter + process.hltSingleEle22WP75GsfDetaFilter + process.hltSingleEle22WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltSingleEle22WP75GsfTrackIsoFilter ) process.HLTEle22WP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGRegionalL1IsoEG20erTauJet20er + process.hltEG22L1sIsoEG20erTauJet20erEtFilter + process.hltEgammaClusterShape + process.hltEle22WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEle22WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltEle22WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltEle22WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltEle22WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltEle22WP75GsfOneOESuperMinusOneOPFilter + process.hltEle22WP75GsfChi2Filter + process.hltEle22WP75GsfDetaFilter + process.hltEle22WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltEle22WP75GsfTrackIsoFilter ) process.HLTParticleFlowSequenceForTaus = cms.Sequence( process.HLTPreshowerSequence + process.hltParticleFlowRecHitECALUnseeded + process.hltParticleFlowRecHitHCAL + process.hltParticleFlowRecHitPSUnseeded + process.hltParticleFlowClusterECALUncorrectedUnseeded + process.hltParticleFlowClusterPSUnseeded + process.hltParticleFlowClusterECALUnseeded + process.hltParticleFlowClusterHCAL + process.hltParticleFlowClusterHFEM + process.hltParticleFlowClusterHFHAD + process.hltLightPFTracks + process.hltParticleFlowBlockForTaus + process.hltParticleFlowForTaus ) process.HLTPFTriggerSequenceForTaus = cms.Sequence( process.HLTL2muonrecoSequence + process.HLTL3muonrecoSequence + process.HLTTrackReconstructionForPF + process.HLTParticleFlowSequenceForTaus + process.hltAK4PFJetsForTaus ) @@ -44239,7 +44239,7 @@ process.HLT_Dimuon6_Jpsi_NoVertexing_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMu0 + process.hltPreDimuon6JpsiNoVertexing + process.hltL1fL1DoubleMu0L1Filtered0 + process.HLTL2muonrecoSequence + process.hltL2fDoubleMu2L2PreFiltered2 + process.HLTL3muonrecoSequence + process.hltDimuon6JpsiL3Filtered + process.HLTEndSequence ) process.HLT_DoublePhoton85_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG40ORL1SingleEG35 + process.hltPreDoublePhoton85 + process.HLTDoublePho85Sequence + process.HLTEndSequence ) process.HLT_Ele20WP60_Ele8_Mass55_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG20 + process.hltPreEle20WP60Ele8Mass55 + process.HLTEle20WP60Ele8Mass55Sequence + process.HLTEndSequence ) -process.HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleIsoEG18 + process.hltPreEle22eta2p1WP75Gsf + process.HLTSingleEle22erWP75GsfSequence + process.HLTEndSequence ) +process.HLT_Ele22_eta2p1_WP75_Gsf_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleIsoEG20er + process.hltPreEle22eta2p1WP75Gsf + process.HLTSingleEle22erWP75GsfSequence + process.HLTEndSequence ) process.HLT_Ele22_eta2p1_WP75_Gsf_LooseIsoPFTau20_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1IsoEG20erTauJet20er + process.hltPreEle22eta2p1WP75GsfLooseIsoPFTau20 + process.HLTEle22WP75GsfSequence + process.HLTRecoJetSequenceAK4PrePF + process.hltTauJet5 + process.hltOverlapFilterIsoEle22WP75GsfCaloJet5 + process.HLTPFTriggerSequenceForTaus + process.HLTIsoEle22WP75GsfLooseIsoPFTau20Sequence + process.HLTEndSequence ) process.HLT_Ele25WP60_SC4_Mass55_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG20 + process.hltPreEle25WP60SC4Mass55 + process.HLTEle25WP60SC4Mass55Sequence + process.HLTEndSequence ) process.HLT_Ele25_eta2p1_WP85_Gsf_PFMET80_boostedW_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG40ORL1SingleIsoEG30erORL1ETM70 + process.hltPreEle25eta2p1WP85GsfPFMET80boostedW + process.HLTEle25WP85GsfSequence + process.HLTAK4PFJetsSequence + process.hltPFMETProducer + process.hltPFMET80Filter + process.HLTEndSequence ) diff --git a/HLTrigger/Configuration/test/OnMc_HLT_HIon.py b/HLTrigger/Configuration/test/OnMc_HLT_HIon.py index 4b01164a3b845..bc2aaa59513ba 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_HIon.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_HIon.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/HIon/V4 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/HIon/V5 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTHIon" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HIon/V4') + tableName = cms.string('/dev/CMSSW_7_4_0/HIon/V5') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -382,14 +382,22 @@ track_prob_min = cms.double( -1.0 ) ) process.streams = cms.PSet( A = cms.vstring( 'InitialPD', - 'Templates' ) ) + 'InitialPDForHI' ) ) process.datasets = cms.PSet( - InitialPD = cms.vstring( 'HLT_Ele27_eta2p1_WP75_Gsf_v1', - 'HLT_Mu50_v1', - 'HLT_PFJet260_v1', - 'HLT_Physics_v1' ), - Templates = cms.vstring( 'HLT_CaloJet260_v1', - 'HLT_Photon20_CaloIdVL_IsoL_v1' ) + InitialPD = cms.vstring( 'HLT_Physics_v1' ), + InitialPDForHI = cms.vstring( 'HLT_HIL1DoubleMu0_HighQ_v1', + 'HLT_HIL2DoubleMu0_NHitQ_v1', + 'HLT_HIL2DoubleMu0_v1', + 'HLT_HIL2DoubleMu3_v1', + 'HLT_HIL2Mu15_v1', + 'HLT_HIL2Mu3_NHitQ_v1', + 'HLT_HIL2Mu3_v1', + 'HLT_HIL2Mu7_v1', + 'HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1', + 'HLT_HIL3DoubleMuOpen_OS_v1', + 'HLT_HIL3DoubleMuOpen_SS_v1', + 'HLT_HIL3DoubleMuOpen_v1', + 'HLT_HIL3Mu3_v1' ) ) process.magfield = cms.ESSource( "XMLIdealGeometryESSource", @@ -2087,8 +2095,15 @@ setSigmaZ = cms.double( 0.0 ), maxRadius = cms.double( 2.0 ) ) -process.hltL1sL1SingleJet200 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleJet200" ), +process.hltPrePhysics = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltBoolEnd = cms.EDFilter( "HLTBool", + result = cms.bool( True ) +) +process.hltL1sL1DoubleMuOpenBptxAND = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_DoubleMuOpen_BptxAND" ), saveTags = cms.bool( True ), L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), L1UseL1TriggerObjectMaps = cms.bool( True ), @@ -2099,635 +2114,23 @@ L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), L1TechTriggerSeeding = cms.bool( False ) ) -process.hltPreCaloJet260 = cms.EDFilter( "HLTPrescaler", +process.hltPreHIL1DoubleMu0HighQ = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) -process.hltEcalDigis = cms.EDProducer( "EcalRawToDigi", - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), - FedLabel = cms.InputTag( "listfeds" ), - eventPut = cms.bool( True ), - srpUnpacking = cms.bool( True ), - syncCheck = cms.bool( True ), - headerUnpacking = cms.bool( True ), - feUnpacking = cms.bool( True ), - orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), - tccUnpacking = cms.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), - InputLabel = cms.InputTag( "rawDataCollector" ), - numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), - FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), - silentMode = cms.untracked.bool( True ), - DoRegional = cms.bool( False ), - forceToKeepFRData = cms.bool( False ), - memUnpacking = cms.bool( True ) -) -process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitProducer", - EEdigiCollection = cms.InputTag( 'hltEcalDigis','eeDigis' ), - EBdigiCollection = cms.InputTag( 'hltEcalDigis','ebDigis' ), - EEhitCollection = cms.string( "EcalUncalibRecHitsEE" ), - EBhitCollection = cms.string( "EcalUncalibRecHitsEB" ), - algo = cms.string( "EcalUncalibRecHitWorkerMultiFit" ), - algoPSet = cms.PSet( - outOfTimeThresholdGain61pEB = cms.double( 5.0 ), - eePulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EcalPulseShapeParameters = cms.PSet( - EcalPreMixStage2 = cms.bool( False ), - EECorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.72698, 0.62048, 0.55691, 0.51848, 0.49147, 0.47813, 0.47007, 0.46621, 0.46265 ), - EcalPreMixStage1 = cms.bool( False ), - EECorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.71217, 0.47464, 0.34056, 0.26282, 0.20287, 0.17734, 0.16256, 0.15618, 0.14443 ), - EBCorrNoiseMatrixG01 = cms.vdouble( 1.0, 0.73354, 0.64442, 0.58851, 0.55425, 0.53082, 0.51916, 0.51097, 0.50732, 0.50409 ), - EBCorrNoiseMatrixG06 = cms.vdouble( 1.0, 0.70946, 0.58021, 0.49846, 0.45006, 0.41366, 0.39699, 0.38478, 0.37847, 0.37055 ), - EBdigiCollection = cms.string( "" ), - EEPulseShapeCovariance = cms.vdouble( 3.941E-5, 3.333E-5, 0.0, -1.449E-5, -1.661E-5, -1.424E-5, -1.183E-5, -6.842E-6, -4.915E-6, -3.411E-6, 0.0, 0.0, 3.333E-5, 2.862E-5, 0.0, -1.244E-5, -1.431E-5, -1.233E-5, -1.032E-5, -5.883E-6, -4.154E-6, -2.902E-6, -2.128E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -1.449E-5, -1.244E-5, 0.0, 5.84E-6, 6.649E-6, 5.72E-6, 4.812E-6, 2.708E-6, 1.869E-6, 1.33E-6, 9.186E-7, 6.446E-7, -1.661E-5, -1.431E-5, 0.0, 6.649E-6, 7.966E-6, 6.898E-6, 5.794E-6, 3.157E-6, 2.184E-6, 1.567E-6, 1.084E-6, 7.575E-7, -1.424E-5, -1.233E-5, 0.0, 5.72E-6, 6.898E-6, 6.341E-6, 5.347E-6, 2.859E-6, 1.991E-6, 1.431E-6, 9.839E-7, 6.886E-7, -1.183E-5, -1.032E-5, 0.0, 4.812E-6, 5.794E-6, 5.347E-6, 4.854E-6, 2.628E-6, 1.809E-6, 1.289E-6, 9.02E-7, 6.146E-7, -6.842E-6, -5.883E-6, 0.0, 2.708E-6, 3.157E-6, 2.859E-6, 2.628E-6, 1.863E-6, 1.296E-6, 8.882E-7, 6.108E-7, 4.283E-7, -4.915E-6, -4.154E-6, 0.0, 1.869E-6, 2.184E-6, 1.991E-6, 1.809E-6, 1.296E-6, 1.217E-6, 8.669E-7, 5.751E-7, 3.882E-7, -3.411E-6, -2.902E-6, 0.0, 1.33E-6, 1.567E-6, 1.431E-6, 1.289E-6, 8.882E-7, 8.669E-7, 9.522E-7, 6.717E-7, 4.293E-7, 0.0, -2.128E-6, 0.0, 9.186E-7, 1.084E-6, 9.839E-7, 9.02E-7, 6.108E-7, 5.751E-7, 6.717E-7, 7.911E-7, 5.493E-7, 0.0, 0.0, 0.0, 6.446E-7, 7.575E-7, 6.886E-7, 6.146E-7, 4.283E-7, 3.882E-7, 4.293E-7, 5.493E-7, 7.027E-7 ), - EECorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71373, 0.44825, 0.30152, 0.21609, 0.14786, 0.11772, 0.10165, 0.09465, 0.08098 ), - ESdigiCollection = cms.string( "" ), - EEPulseShapeTemplate = cms.vdouble( 0.116442, 0.756246, 1.0, 0.897182, 0.686831, 0.491506, 0.344111, 0.245731, 0.174115, 0.123361, 0.0874288, 0.061957 ), - EBCorrNoiseMatrixG12 = cms.vdouble( 1.0, 0.71073, 0.55721, 0.46089, 0.40449, 0.35931, 0.33924, 0.32439, 0.31581, 0.30481 ), - EEdigiCollection = cms.string( "" ), - EBPulseShapeTemplate = cms.vdouble( 0.0113979, 0.758151, 1.0, 0.887744, 0.673548, 0.474332, 0.319561, 0.215144, 0.147464, 0.101087, 0.0693181, 0.0475044 ), - EBPulseShapeCovariance = cms.vdouble( 3.001E-6, 1.233E-5, 0.0, -4.416E-6, -4.571E-6, -3.614E-6, -2.636E-6, -1.286E-6, -8.41E-7, -5.296E-7, 0.0, 0.0, 1.233E-5, 6.154E-5, 0.0, -2.2E-5, -2.309E-5, -1.838E-5, -1.373E-5, -7.334E-6, -5.088E-6, -3.745E-6, -2.428E-6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, -4.416E-6, -2.2E-5, 0.0, 8.319E-6, 8.545E-6, 6.792E-6, 5.059E-6, 2.678E-6, 1.816E-6, 1.223E-6, 8.245E-7, 5.589E-7, -4.571E-6, -2.309E-5, 0.0, 8.545E-6, 9.182E-6, 7.219E-6, 5.388E-6, 2.853E-6, 1.944E-6, 1.324E-6, 9.083E-7, 6.335E-7, -3.614E-6, -1.838E-5, 0.0, 6.792E-6, 7.219E-6, 6.016E-6, 4.437E-6, 2.385E-6, 1.636E-6, 1.118E-6, 7.754E-7, 5.556E-7, -2.636E-6, -1.373E-5, 0.0, 5.059E-6, 5.388E-6, 4.437E-6, 3.602E-6, 1.917E-6, 1.322E-6, 9.079E-7, 6.529E-7, 4.752E-7, -1.286E-6, -7.334E-6, 0.0, 2.678E-6, 2.853E-6, 2.385E-6, 1.917E-6, 1.375E-6, 9.1E-7, 6.455E-7, 4.693E-7, 3.657E-7, -8.41E-7, -5.088E-6, 0.0, 1.816E-6, 1.944E-6, 1.636E-6, 1.322E-6, 9.1E-7, 9.115E-7, 6.062E-7, 4.436E-7, 3.422E-7, -5.296E-7, -3.745E-6, 0.0, 1.223E-6, 1.324E-6, 1.118E-6, 9.079E-7, 6.455E-7, 6.062E-7, 7.217E-7, 4.862E-7, 3.768E-7, 0.0, -2.428E-6, 0.0, 8.245E-7, 9.083E-7, 7.754E-7, 6.529E-7, 4.693E-7, 4.436E-7, 4.862E-7, 6.509E-7, 4.418E-7, 0.0, 0.0, 0.0, 5.589E-7, 6.335E-7, 5.556E-7, 4.752E-7, 3.657E-7, 3.422E-7, 3.768E-7, 4.418E-7, 6.142E-7 ), - UseLCcorrection = cms.untracked.bool( True ) - ), - EBtimeFitParameters = cms.vdouble( -2.015452, 3.130702, -12.3473, 41.88921, -82.83944, 91.01147, -50.35761, 11.05621 ), - activeBXs = cms.vint32( -5, -4, -3, -2, -1, 0, 1, 2, 3, 4 ), - amplitudeThresholdEE = cms.double( 10.0 ), - EBtimeConstantTerm = cms.double( 0.6 ), - EEtimeFitLimits_Lower = cms.double( 0.2 ), - outOfTimeThresholdGain61pEE = cms.double( 1000.0 ), - ebSpikeThreshold = cms.double( 1.042 ), - EBtimeNconst = cms.double( 28.5 ), - ampErrorCalculation = cms.bool( False ), - kPoorRecoFlagEB = cms.bool( True ), - ebPulseShape = cms.vdouble( 5.2E-5, -5.26E-5, 6.66E-5, 0.1168, 0.7575, 1.0, 0.8876, 0.6732, 0.4741, 0.3194 ), - EBtimeFitLimits_Lower = cms.double( 0.2 ), - kPoorRecoFlagEE = cms.bool( False ), - chi2ThreshEB_ = cms.double( 65.0 ), - EEtimeFitParameters = cms.vdouble( -2.390548, 3.553628, -17.62341, 67.67538, -133.213, 140.7432, -75.41106, 16.20277 ), - useLumiInfoRunHeader = cms.bool( False ), - outOfTimeThresholdGain12mEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12mEB = cms.double( 5.0 ), - EEtimeFitLimits_Upper = cms.double( 1.4 ), - prefitMaxChiSqEB = cms.double( 100.0 ), - EEamplitudeFitParameters = cms.vdouble( 1.89, 1.4 ), - prefitMaxChiSqEE = cms.double( 10.0 ), - EBamplitudeFitParameters = cms.vdouble( 1.138, 1.652 ), - EBtimeFitLimits_Upper = cms.double( 1.4 ), - timealgo = cms.string( "RatioMethod" ), - amplitudeThresholdEB = cms.double( 10.0 ), - outOfTimeThresholdGain12pEE = cms.double( 1000.0 ), - outOfTimeThresholdGain12pEB = cms.double( 5.0 ), - EEtimeNconst = cms.double( 31.8 ), - outOfTimeThresholdGain61mEB = cms.double( 5.0 ), - outOfTimeThresholdGain61mEE = cms.double( 1000.0 ), - EEtimeConstantTerm = cms.double( 1.0 ), - chi2ThreshEE_ = cms.double( 50.0 ), - doPrefitEE = cms.bool( True ), - doPrefitEB = cms.bool( True ) - ) -) -process.hltEcalDetIdToBeRecovered = cms.EDProducer( "EcalDetIdToBeRecoveredProducer", - ebIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), - ebDetIdToBeRecovered = cms.string( "ebDetId" ), - integrityTTIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityTTIdErrors' ), - eeIntegrityGainErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityGainErrors' ), - ebFEToBeRecovered = cms.string( "ebFE" ), - ebIntegrityGainErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityGainErrors' ), - eeDetIdToBeRecovered = cms.string( "eeDetId" ), - eeIntegrityGainSwitchErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityGainSwitchErrors' ), - eeIntegrityChIdErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityChIdErrors' ), - ebIntegrityGainSwitchErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityGainSwitchErrors' ), - ebSrFlagCollection = cms.InputTag( "hltEcalDigis" ), - eeSrFlagCollection = cms.InputTag( "hltEcalDigis" ), - integrityBlockSizeErrors = cms.InputTag( 'hltEcalDigis','EcalIntegrityBlockSizeErrors' ), - eeFEToBeRecovered = cms.string( "eeFE" ) -) -process.hltEcalRecHit = cms.EDProducer( "EcalRecHitProducer", - recoverEEVFE = cms.bool( False ), - EErechitCollection = cms.string( "EcalRecHitsEE" ), - recoverEBIsolatedChannels = cms.bool( False ), - recoverEBVFE = cms.bool( False ), - laserCorrection = cms.bool( True ), - EBLaserMIN = cms.double( 0.5 ), - killDeadChannels = cms.bool( True ), - dbStatusToBeExcludedEB = cms.vint32( 14, 78, 142 ), - EEuncalibRecHitCollection = cms.InputTag( 'hltEcalUncalibRecHit','EcalUncalibRecHitsEE' ), - EBLaserMAX = cms.double( 3.0 ), - EELaserMIN = cms.double( 0.5 ), - ebFEToBeRecovered = cms.InputTag( 'hltEcalDetIdToBeRecovered','ebFE' ), - EELaserMAX = cms.double( 8.0 ), - recoverEEIsolatedChannels = cms.bool( False ), - eeDetIdToBeRecovered = cms.InputTag( 'hltEcalDetIdToBeRecovered','eeDetId' ), - recoverEBFE = cms.bool( True ), - algo = cms.string( "EcalRecHitWorkerSimple" ), - ebDetIdToBeRecovered = cms.InputTag( 'hltEcalDetIdToBeRecovered','ebDetId' ), - singleChannelRecoveryThreshold = cms.double( 8.0 ), - ChannelStatusToBeExcluded = cms.vstring( ), - EBrechitCollection = cms.string( "EcalRecHitsEB" ), - singleChannelRecoveryMethod = cms.string( "NeuralNetworks" ), - recoverEEFE = cms.bool( True ), - triggerPrimitiveDigiCollection = cms.InputTag( 'hltEcalDigis','EcalTriggerPrimitives' ), - dbStatusToBeExcludedEE = cms.vint32( 14, 78, 142 ), - flagsMapDBReco = cms.PSet( - kGood = cms.vstring( 'kOk', - 'kDAC', - 'kNoLaser', - 'kNoisy' ), - kNeighboursRecovered = cms.vstring( 'kFixedG0', - 'kNonRespondingIsolated', - 'kDeadVFE' ), - kDead = cms.vstring( 'kNoDataNoTP' ), - kNoisy = cms.vstring( 'kNNoisy', - 'kFixedG6', - 'kFixedG1' ), - kTowerRecovered = cms.vstring( 'kDeadFE' ) - ), - EBuncalibRecHitCollection = cms.InputTag( 'hltEcalUncalibRecHit','EcalUncalibRecHitsEB' ), - algoRecover = cms.string( "EcalRecHitWorkerRecover" ), - eeFEToBeRecovered = cms.InputTag( 'hltEcalDetIdToBeRecovered','eeFE' ), - cleaningConfig = cms.PSet( - e6e2thresh = cms.double( 0.04 ), - tightenCrack_e6e2_double = cms.double( 3.0 ), - e4e1Threshold_endcap = cms.double( 0.3 ), - tightenCrack_e4e1_single = cms.double( 3.0 ), - tightenCrack_e1_double = cms.double( 2.0 ), - cThreshold_barrel = cms.double( 4.0 ), - e4e1Threshold_barrel = cms.double( 0.08 ), - tightenCrack_e1_single = cms.double( 2.0 ), - e4e1_b_barrel = cms.double( -0.024 ), - e4e1_a_barrel = cms.double( 0.04 ), - ignoreOutOfTimeThresh = cms.double( 1.0E9 ), - cThreshold_endcap = cms.double( 15.0 ), - e4e1_b_endcap = cms.double( -0.0125 ), - e4e1_a_endcap = cms.double( 0.02 ), - cThreshold_double = cms.double( 10.0 ) - ), - logWarningEtThreshold_EB_FE = cms.double( 50.0 ), - logWarningEtThreshold_EE_FE = cms.double( 50.0 ) -) -process.hltHcalDigis = cms.EDProducer( "HcalRawToDigi", - ExpectedOrbitMessageTime = cms.untracked.int32( -1 ), - FilterDataQuality = cms.bool( True ), - silent = cms.untracked.bool( True ), - HcalFirstFED = cms.untracked.int32( 700 ), - InputLabel = cms.InputTag( "rawDataCollector" ), - ComplainEmptyData = cms.untracked.bool( False ), - UnpackCalib = cms.untracked.bool( True ), - FEDs = cms.untracked.vint32( ), - UnpackerMode = cms.untracked.int32( 0 ), - UnpackTTP = cms.untracked.bool( False ), - lastSample = cms.int32( 9 ), - UnpackZDC = cms.untracked.bool( True ), - firstSample = cms.int32( 0 ) -) -process.hltHbhereco = cms.EDProducer( "HcalHitReconstructor", - digiTimeFromDB = cms.bool( True ), - mcOOTCorrectionName = cms.string( "" ), - S9S1stat = cms.PSet( ), - saturationParameters = cms.PSet( maxADCvalue = cms.int32( 127 ) ), - tsFromDB = cms.bool( True ), - samplesToAdd = cms.int32( 4 ), - mcOOTCorrectionCategory = cms.string( "MC" ), - dataOOTCorrectionName = cms.string( "" ), - puCorrMethod = cms.int32( 0 ), - correctionPhaseNS = cms.double( 13.0 ), - HFInWindowStat = cms.PSet( ), - digiLabel = cms.InputTag( "hltHcalDigis" ), - setHSCPFlags = cms.bool( False ), - firstAuxTS = cms.int32( 4 ), - digistat = cms.PSet( ), - hfTimingTrustParameters = cms.PSet( ), - PETstat = cms.PSet( ), - setSaturationFlags = cms.bool( False ), - setNegativeFlags = cms.bool( False ), - useLeakCorrection = cms.bool( False ), - setTimingTrustFlags = cms.bool( False ), - S8S1stat = cms.PSet( ), - correctForPhaseContainment = cms.bool( True ), - correctForTimeslew = cms.bool( True ), - setNoiseFlags = cms.bool( False ), - correctTiming = cms.bool( False ), - setPulseShapeFlags = cms.bool( False ), - Subdetector = cms.string( "HBHE" ), - dataOOTCorrectionCategory = cms.string( "Data" ), - dropZSmarkedPassed = cms.bool( True ), - recoParamsFromDB = cms.bool( True ), - firstSample = cms.int32( 4 ), - setTimingShapedCutsFlags = cms.bool( False ), - pulseJitter = cms.double( 1.0 ), - chargeMax = cms.double( 6.0 ), - negativeParameters = cms.PSet( - TS4TS5ChargeThreshold = cms.double( 70.0 ), - Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), - Last = cms.int32( 6 ), - MinimumChargeThreshold = cms.double( 20.0 ), - Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), - First = cms.int32( 4 ) - ), - timeMin = cms.double( -15.0 ), - ts4chi2 = cms.double( 15.0 ), - ts345chi2 = cms.double( 100.0 ), - applyTimeSlew = cms.bool( True ), - applyTimeConstraint = cms.bool( True ), - applyPulseJitter = cms.bool( False ), - timingshapedcutsParameters = cms.PSet( - ignorelowest = cms.bool( True ), - win_offset = cms.double( 0.0 ), - ignorehighest = cms.bool( False ), - win_gain = cms.double( 1.0 ), - tfilterEnvelope = cms.vdouble( 4.0, 12.04, 13.0, 10.56, 23.5, 8.82, 37.0, 7.38, 56.0, 6.3, 81.0, 5.64, 114.5, 5.44, 175.5, 5.38, 350.5, 5.14 ) - ), - ts3chi2 = cms.double( 5.0 ), - ts4Min = cms.double( 5.0 ), - pulseShapeParameters = cms.PSet( ), - noise = cms.double( 1.0 ), - applyPedConstraint = cms.bool( True ), - applyUnconstrainedFit = cms.bool( False ), - ts4Max = cms.double( 500.0 ), - meanTime = cms.double( -2.5 ), - flagParameters = cms.PSet( - nominalPedestal = cms.double( 3.0 ), - hitMultiplicityThreshold = cms.int32( 17 ), - hitEnergyMinimum = cms.double( 1.0 ), - pulseShapeParameterSets = cms.VPSet( - cms.PSet( pulseShapeParameters = cms.vdouble( 0.0, 100.0, -50.0, 0.0, -15.0, 0.15 ) ), - cms.PSet( pulseShapeParameters = cms.vdouble( 100.0, 2000.0, -50.0, 0.0, -5.0, 0.05 ) ), - cms.PSet( pulseShapeParameters = cms.vdouble( 2000.0, 1000000.0, -50.0, 0.0, 95.0, 0.0 ) ), - cms.PSet( pulseShapeParameters = cms.vdouble( -1000000.0, 1000000.0, 45.0, 0.1, 1000000.0, 0.0 ) ) - ) - ), - fitTimes = cms.int32( 1 ), - timeMax = cms.double( 10.0 ), - timeSigma = cms.double( 5.0 ), - pedSigma = cms.double( 0.5 ), - meanPed = cms.double( 0.0 ), - hscpParameters = cms.PSet( - slopeMax = cms.double( -0.6 ), - r1Max = cms.double( 1.0 ), - r1Min = cms.double( 0.15 ), - TimingEnergyThreshold = cms.double( 30.0 ), - slopeMin = cms.double( -1.5 ), - outerMin = cms.double( 0.0 ), - outerMax = cms.double( 0.1 ), - fracLeaderMin = cms.double( 0.4 ), - r2Min = cms.double( 0.1 ), - r2Max = cms.double( 0.5 ), - fracLeaderMax = cms.double( 0.7 ) - ) -) -process.hltHfreco = cms.EDProducer( "HcalHitReconstructor", - digiTimeFromDB = cms.bool( True ), - mcOOTCorrectionName = cms.string( "" ), - S9S1stat = cms.PSet( - longETParams = cms.vdouble( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ), - shortEnergyParams = cms.vdouble( 35.1773, 35.37, 35.7933, 36.4472, 37.3317, 38.4468, 39.7925, 41.3688, 43.1757, 45.2132, 47.4813, 49.98, 52.7093 ), - flagsToSkip = cms.int32( 24 ), - shortETParams = cms.vdouble( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ), - short_optimumSlope = cms.vdouble( -99999.0, 0.0164905, 0.0238698, 0.0321383, 0.041296, 0.0513428, 0.0622789, 0.0741041, 0.0868186, 0.100422, 0.135313, 0.136289, 0.0589927 ), - longEnergyParams = cms.vdouble( 43.5, 45.7, 48.32, 51.36, 54.82, 58.7, 63.0, 67.72, 72.86, 78.42, 84.4, 90.8, 97.62 ), - long_optimumSlope = cms.vdouble( -99999.0, 0.0164905, 0.0238698, 0.0321383, 0.041296, 0.0513428, 0.0622789, 0.0741041, 0.0868186, 0.100422, 0.135313, 0.136289, 0.0589927 ), - isS8S1 = cms.bool( False ), - HcalAcceptSeverityLevel = cms.int32( 9 ) - ), - saturationParameters = cms.PSet( maxADCvalue = cms.int32( 127 ) ), - tsFromDB = cms.bool( True ), - samplesToAdd = cms.int32( 2 ), - mcOOTCorrectionCategory = cms.string( "MC" ), - dataOOTCorrectionName = cms.string( "" ), - puCorrMethod = cms.int32( 0 ), - correctionPhaseNS = cms.double( 13.0 ), - HFInWindowStat = cms.PSet( - hflongEthresh = cms.double( 40.0 ), - hflongMinWindowTime = cms.vdouble( -10.0 ), - hfshortEthresh = cms.double( 40.0 ), - hflongMaxWindowTime = cms.vdouble( 10.0 ), - hfshortMaxWindowTime = cms.vdouble( 10.0 ), - hfshortMinWindowTime = cms.vdouble( -12.0 ) - ), - digiLabel = cms.InputTag( "hltHcalDigis" ), - setHSCPFlags = cms.bool( False ), - firstAuxTS = cms.int32( 1 ), - digistat = cms.PSet( - HFdigiflagFirstSample = cms.int32( 1 ), - HFdigiflagMinEthreshold = cms.double( 40.0 ), - HFdigiflagSamplesToAdd = cms.int32( 3 ), - HFdigiflagExpectedPeak = cms.int32( 2 ), - HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) - ), - hfTimingTrustParameters = cms.PSet( - hfTimingTrustLevel2 = cms.int32( 4 ), - hfTimingTrustLevel1 = cms.int32( 1 ) - ), - PETstat = cms.PSet( - longETParams = cms.vdouble( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ), - short_R_29 = cms.vdouble( 0.8 ), - shortEnergyParams = cms.vdouble( 35.1773, 35.37, 35.7933, 36.4472, 37.3317, 38.4468, 39.7925, 41.3688, 43.1757, 45.2132, 47.4813, 49.98, 52.7093 ), - flagsToSkip = cms.int32( 0 ), - short_R = cms.vdouble( 0.8 ), - shortETParams = cms.vdouble( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ), - long_R_29 = cms.vdouble( 0.8 ), - longEnergyParams = cms.vdouble( 43.5, 45.7, 48.32, 51.36, 54.82, 58.7, 63.0, 67.72, 72.86, 78.42, 84.4, 90.8, 97.62 ), - long_R = cms.vdouble( 0.98 ), - HcalAcceptSeverityLevel = cms.int32( 9 ) - ), - setSaturationFlags = cms.bool( False ), - setNegativeFlags = cms.bool( False ), - useLeakCorrection = cms.bool( False ), - setTimingTrustFlags = cms.bool( False ), - S8S1stat = cms.PSet( - longETParams = cms.vdouble( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ), - shortEnergyParams = cms.vdouble( 40.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0 ), - flagsToSkip = cms.int32( 16 ), - shortETParams = cms.vdouble( 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ), - short_optimumSlope = cms.vdouble( 0.3, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1 ), - longEnergyParams = cms.vdouble( 40.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0 ), - long_optimumSlope = cms.vdouble( 0.3, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1 ), - isS8S1 = cms.bool( True ), - HcalAcceptSeverityLevel = cms.int32( 9 ) - ), - correctForPhaseContainment = cms.bool( False ), - correctForTimeslew = cms.bool( False ), - setNoiseFlags = cms.bool( True ), - correctTiming = cms.bool( False ), - setPulseShapeFlags = cms.bool( False ), - Subdetector = cms.string( "HF" ), - dataOOTCorrectionCategory = cms.string( "Data" ), - dropZSmarkedPassed = cms.bool( True ), - recoParamsFromDB = cms.bool( True ), - firstSample = cms.int32( 2 ), - setTimingShapedCutsFlags = cms.bool( False ), - pulseJitter = cms.double( 1.0 ), - chargeMax = cms.double( 6.0 ), - negativeParameters = cms.PSet( - TS4TS5ChargeThreshold = cms.double( 70.0 ), - Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), - Last = cms.int32( 6 ), - MinimumChargeThreshold = cms.double( 20.0 ), - Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), - First = cms.int32( 4 ) - ), - timeMin = cms.double( -15.0 ), - ts4chi2 = cms.double( 15.0 ), - ts345chi2 = cms.double( 100.0 ), - applyTimeSlew = cms.bool( True ), - applyTimeConstraint = cms.bool( True ), - applyPulseJitter = cms.bool( False ), - timingshapedcutsParameters = cms.PSet( ), - ts3chi2 = cms.double( 5.0 ), - ts4Min = cms.double( 5.0 ), - pulseShapeParameters = cms.PSet( ), - noise = cms.double( 1.0 ), - applyPedConstraint = cms.bool( True ), - applyUnconstrainedFit = cms.bool( False ), - ts4Max = cms.double( 500.0 ), - meanTime = cms.double( -2.5 ), - flagParameters = cms.PSet( ), - fitTimes = cms.int32( 1 ), - timeMax = cms.double( 10.0 ), - timeSigma = cms.double( 5.0 ), - pedSigma = cms.double( 0.5 ), - meanPed = cms.double( 0.0 ), - hscpParameters = cms.PSet( ) -) -process.hltHoreco = cms.EDProducer( "HcalHitReconstructor", - digiTimeFromDB = cms.bool( True ), - mcOOTCorrectionName = cms.string( "" ), - S9S1stat = cms.PSet( ), - saturationParameters = cms.PSet( maxADCvalue = cms.int32( 127 ) ), - tsFromDB = cms.bool( True ), - samplesToAdd = cms.int32( 4 ), - mcOOTCorrectionCategory = cms.string( "MC" ), - dataOOTCorrectionName = cms.string( "" ), - puCorrMethod = cms.int32( 0 ), - correctionPhaseNS = cms.double( 13.0 ), - HFInWindowStat = cms.PSet( ), - digiLabel = cms.InputTag( "hltHcalDigis" ), - setHSCPFlags = cms.bool( False ), - firstAuxTS = cms.int32( 4 ), - digistat = cms.PSet( ), - hfTimingTrustParameters = cms.PSet( ), - PETstat = cms.PSet( ), - setSaturationFlags = cms.bool( False ), - setNegativeFlags = cms.bool( False ), - useLeakCorrection = cms.bool( False ), - setTimingTrustFlags = cms.bool( False ), - S8S1stat = cms.PSet( ), - correctForPhaseContainment = cms.bool( True ), - correctForTimeslew = cms.bool( True ), - setNoiseFlags = cms.bool( False ), - correctTiming = cms.bool( False ), - setPulseShapeFlags = cms.bool( False ), - Subdetector = cms.string( "HO" ), - dataOOTCorrectionCategory = cms.string( "Data" ), - dropZSmarkedPassed = cms.bool( True ), - recoParamsFromDB = cms.bool( True ), - firstSample = cms.int32( 4 ), - setTimingShapedCutsFlags = cms.bool( False ), - pulseJitter = cms.double( 1.0 ), - chargeMax = cms.double( 6.0 ), - negativeParameters = cms.PSet( - TS4TS5ChargeThreshold = cms.double( 70.0 ), - Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), - Last = cms.int32( 6 ), - MinimumChargeThreshold = cms.double( 20.0 ), - Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), - First = cms.int32( 4 ) - ), - timeMin = cms.double( -15.0 ), - ts4chi2 = cms.double( 15.0 ), - ts345chi2 = cms.double( 100.0 ), - applyTimeSlew = cms.bool( True ), - applyTimeConstraint = cms.bool( True ), - applyPulseJitter = cms.bool( False ), - timingshapedcutsParameters = cms.PSet( ), - ts3chi2 = cms.double( 5.0 ), - ts4Min = cms.double( 5.0 ), - pulseShapeParameters = cms.PSet( ), - noise = cms.double( 1.0 ), - applyPedConstraint = cms.bool( True ), - applyUnconstrainedFit = cms.bool( False ), - ts4Max = cms.double( 500.0 ), - meanTime = cms.double( -2.5 ), - flagParameters = cms.PSet( ), - fitTimes = cms.int32( 1 ), - timeMax = cms.double( 10.0 ), - timeSigma = cms.double( 5.0 ), - pedSigma = cms.double( 0.5 ), - meanPed = cms.double( 0.0 ), - hscpParameters = cms.PSet( ) -) -process.hltTowerMakerForAll = cms.EDProducer( "CaloTowersCreator", - EBSumThreshold = cms.double( 0.2 ), - MomHBDepth = cms.double( 0.2 ), - UseEtEBTreshold = cms.bool( False ), - hfInput = cms.InputTag( "hltHfreco" ), - AllowMissingInputs = cms.bool( False ), - MomEEDepth = cms.double( 0.0 ), - EESumThreshold = cms.double( 0.45 ), - HBGrid = cms.vdouble( ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - HBThreshold = cms.double( 0.7 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), - UseEcalRecoveredHits = cms.bool( False ), - MomConstrMethod = cms.int32( 1 ), - MomHEDepth = cms.double( 0.4 ), - HcalThreshold = cms.double( -1000.0 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), - UseSymEBTreshold = cms.bool( False ), - EEWeights = cms.vdouble( ), - EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), - HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HEDGrid = cms.vdouble( ), - EBWeight = cms.double( 1.0 ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), - HOWeight = cms.double( 1.0E-99 ), - HESWeight = cms.double( 1.0 ), - HESThreshold = cms.double( 0.8 ), - hbheInput = cms.InputTag( "hltHbhereco" ), - HF2Weight = cms.double( 1.0 ), - HF2Threshold = cms.double( 0.85 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EEThreshold = cms.double( 0.3 ), - HOThresholdPlus1 = cms.double( 3.5 ), - HOThresholdPlus2 = cms.double( 3.5 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HF1Threshold = cms.double( 0.5 ), - HOThresholdMinus1 = cms.double( 3.5 ), - HESGrid = cms.vdouble( ), - EcutTower = cms.double( -1000.0 ), - UseRejectedRecoveredEcalHits = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - HESWeights = cms.vdouble( ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), - HEDWeight = cms.double( 1.0 ), - UseSymEETreshold = cms.bool( False ), - HEDThreshold = cms.double( 0.8 ), - EBThreshold = cms.double( 0.07 ), - UseRejectedHitsOnly = cms.bool( False ), - UseHcalRecoveredHits = cms.bool( False ), - HOThresholdMinus2 = cms.double( 3.5 ), - HOThreshold0 = cms.double( 3.5 ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), - UseRejectedRecoveredHcalHits = cms.bool( False ), - MomEBDepth = cms.double( 0.3 ), - HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ) -) -process.hltAK4CaloJets = cms.EDProducer( "FastjetJetProducer", - Active_Area_Repeats = cms.int32( 5 ), - doAreaFastjet = cms.bool( False ), - voronoiRfact = cms.double( 0.9 ), - maxBadHcalCells = cms.uint32( 9999999 ), - doAreaDiskApprox = cms.bool( True ), - maxRecoveredEcalCells = cms.uint32( 9999999 ), - jetType = cms.string( "CaloJet" ), - minSeed = cms.uint32( 14327 ), - Ghost_EtaMax = cms.double( 6.0 ), - doRhoFastjet = cms.bool( False ), - jetAlgorithm = cms.string( "AntiKt" ), - nSigmaPU = cms.double( 1.0 ), - GhostArea = cms.double( 0.01 ), - Rho_EtaMax = cms.double( 4.4 ), - maxBadEcalCells = cms.uint32( 9999999 ), - useDeterministicSeed = cms.bool( True ), - doPVCorrection = cms.bool( False ), - maxRecoveredHcalCells = cms.uint32( 9999999 ), - rParam = cms.double( 0.4 ), - maxProblematicHcalCells = cms.uint32( 9999999 ), - doOutputJets = cms.bool( True ), - src = cms.InputTag( "hltTowerMakerForAll" ), - inputEtMin = cms.double( 0.3 ), - puPtMin = cms.double( 10.0 ), - srcPVs = cms.InputTag( "NotUsed" ), - jetPtMin = cms.double( 1.0 ), - radiusPU = cms.double( 0.4 ), - maxProblematicEcalCells = cms.uint32( 9999999 ), - doPUOffsetCorr = cms.bool( False ), - inputEMin = cms.double( 0.0 ), - useMassDropTagger = cms.bool( False ), - muMin = cms.double( -1.0 ), - subtractorName = cms.string( "" ), - muCut = cms.double( -1.0 ), - subjetPtMin = cms.double( -1.0 ), - useTrimming = cms.bool( False ), - muMax = cms.double( -1.0 ), - yMin = cms.double( -1.0 ), - useFiltering = cms.bool( False ), - rFilt = cms.double( -1.0 ), - yMax = cms.double( -1.0 ), - zcut = cms.double( -1.0 ), - MinVtxNdof = cms.int32( 5 ), - MaxVtxZ = cms.double( 15.0 ), - UseOnlyVertexTracks = cms.bool( False ), - dRMin = cms.double( -1.0 ), - nFilt = cms.int32( -1 ), - usePruning = cms.bool( False ), - maxDepth = cms.int32( -1 ), - yCut = cms.double( -1.0 ), - DzTrVtxMax = cms.double( 0.0 ), - UseOnlyOnePV = cms.bool( False ), - rcut_factor = cms.double( -1.0 ), - sumRecHits = cms.bool( False ), - trimPtFracMin = cms.double( -1.0 ), - dRMax = cms.double( -1.0 ), - DxyTrVtxMax = cms.double( 0.0 ), - useCMSBoostedTauSeedingAlgorithm = cms.bool( False ) -) -process.hltAK4CaloJetsIDPassed = cms.EDProducer( "HLTCaloJetIDProducer", - min_N90 = cms.int32( -2 ), - min_N90hits = cms.int32( 2 ), - min_EMF = cms.double( 1.0E-6 ), - jetsInput = cms.InputTag( "hltAK4CaloJets" ), - JetIDParams = cms.PSet( - useRecHits = cms.bool( True ), - hbheRecHitsColl = cms.InputTag( "hltHbhereco" ), - hoRecHitsColl = cms.InputTag( "hltHoreco" ), - hfRecHitsColl = cms.InputTag( "hltHfreco" ), - ebRecHitsColl = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEB' ), - eeRecHitsColl = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEE' ) - ), - max_EMF = cms.double( 999.0 ) -) -process.hltFixedGridRhoFastjetAllCalo = cms.EDProducer( "FixedGridRhoProducerFastjet", - gridSpacing = cms.double( 0.55 ), - maxRapidity = cms.double( 5.0 ), - pfCandidatesTag = cms.InputTag( "hltTowerMakerForAll" ) -) -process.hltAK4CaloJetsCorrected = cms.EDProducer( "CaloJetCorrectionProducer", - src = cms.InputTag( "hltAK4CaloJets" ), - correctors = cms.vstring( 'hltESPAK4CaloCorrection' ) -) -process.hltAK4CaloJetsCorrectedIDPassed = cms.EDProducer( "CaloJetCorrectionProducer", - src = cms.InputTag( "hltAK4CaloJetsIDPassed" ), - correctors = cms.vstring( 'hltESPAK4CaloCorrection' ) -) -process.hltSingleCaloJet260 = cms.EDFilter( "HLT1CaloJet", +process.hltL1fL1DoubleMu0HQL1Filtered0 = cms.EDFilter( "HLTMuonL1Filter", saveTags = cms.bool( True ), - MinPt = cms.double( 260.0 ), - MinN = cms.int32( 1 ), - MaxEta = cms.double( 5.0 ), - MinMass = cms.double( -1.0 ), - inputTag = cms.InputTag( "hltAK4CaloJetsCorrectedIDPassed" ), - MinE = cms.double( -1.0 ), - triggerType = cms.int32( 85 ) -) -process.hltBoolEnd = cms.EDFilter( "HLTBool", - result = cms.bool( True ) + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1DoubleMuOpenBptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "hltL1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) ) -process.hltL1sL1SingleIsoEG22er = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleIsoEG22er" ), +process.hltL1sL1SingleMu3BptxAND = cms.EDFilter( "HLTLevel1GTSeed", + L1SeedsLogicalExpression = cms.string( "L1_SingleMu3_BptxAND" ), saveTags = cms.bool( True ), L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), L1UseL1TriggerObjectMaps = cms.bool( True ), @@ -2738,5670 +2141,1703 @@ L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), L1TechTriggerSeeding = cms.bool( False ) ) -process.hltPreEle27eta2p1WP75Gsf = cms.EDFilter( "HLTPrescaler", +process.hltPreHIL2Mu3 = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) -process.hltEcalPreshowerDigis = cms.EDProducer( "ESRawToDigi", - sourceTag = cms.InputTag( "rawDataCollector" ), - debugMode = cms.untracked.bool( False ), - InstanceES = cms.string( "" ), - ESdigiCollection = cms.string( "" ), - LookupTable = cms.FileInPath( "EventFilter/ESDigiToRaw/data/ES_lookup_table.dat" ) -) -process.hltEcalPreshowerRecHit = cms.EDProducer( "ESRecHitProducer", - ESRecoAlgo = cms.int32( 0 ), - ESrechitCollection = cms.string( "EcalRecHitsES" ), - algo = cms.string( "ESRecHitWorker" ), - ESdigiCollection = cms.InputTag( "hltEcalPreshowerDigis" ) -) -process.hltRechitInRegionsECAL = cms.EDProducer( "EgammaHLTRechitInRegionsProducer", - l1LowerThr = cms.double( 5.0 ), - doIsolated = cms.bool( True ), - useUncalib = cms.bool( False ), - regionEtaMargin = cms.double( 0.14 ), - ecalhitLabels = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), - regionPhiMargin = cms.double( 0.4 ), - l1TagNonIsolated = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), - l1UpperThr = cms.double( 999.0 ), - l1LowerThrIgnoreIsolation = cms.double( 0.0 ), - productLabels = cms.vstring( 'EcalRecHitsEB', - 'EcalRecHitsEE' ), - l1TagIsolated = cms.InputTag( 'hltL1extraParticles','Isolated' ) -) -process.hltRechitInRegionsES = cms.EDProducer( "EgammaHLTRechitInRegionsProducer", - l1LowerThr = cms.double( 5.0 ), - doIsolated = cms.bool( True ), - useUncalib = cms.bool( False ), - regionEtaMargin = cms.double( 0.14 ), - ecalhitLabels = cms.VInputTag( 'hltEcalPreshowerRecHit:EcalRecHitsES' ), - regionPhiMargin = cms.double( 0.4 ), - l1TagNonIsolated = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), - l1UpperThr = cms.double( 999.0 ), - l1LowerThrIgnoreIsolation = cms.double( 0.0 ), - productLabels = cms.vstring( 'EcalRecHitsES' ), - l1TagIsolated = cms.InputTag( 'hltL1extraParticles','Isolated' ) -) -process.hltParticleFlowRecHitECALL1Seeded = cms.EDProducer( "PFRecHitProducer", - producers = cms.VPSet( - cms.PSet( src = cms.InputTag( 'hltRechitInRegionsECAL','EcalRecHitsEB' ), - qualityTests = cms.VPSet( - cms.PSet( threshold = cms.double( 0.08 ), - name = cms.string( "PFRecHitQTestThreshold" ) - ), - cms.PSet( timingCleaning = cms.bool( True ), - topologicalCleaning = cms.bool( True ), - cleaningThreshold = cms.double( 2.0 ), - skipTTRecoveredHits = cms.bool( True ), - name = cms.string( "PFRecHitQTestECAL" ) - ) - ), - name = cms.string( "PFEBRecHitCreator" ) - ), - cms.PSet( src = cms.InputTag( 'hltRechitInRegionsECAL','EcalRecHitsEE' ), - qualityTests = cms.VPSet( - cms.PSet( threshold = cms.double( 0.3 ), - name = cms.string( "PFRecHitQTestThreshold" ) - ), - cms.PSet( timingCleaning = cms.bool( True ), - topologicalCleaning = cms.bool( True ), - cleaningThreshold = cms.double( 2.0 ), - skipTTRecoveredHits = cms.bool( True ), - name = cms.string( "PFRecHitQTestECAL" ) - ) - ), - name = cms.string( "PFEERecHitCreator" ) - ) - ), - navigator = cms.PSet( - barrel = cms.PSet( ), - endcap = cms.PSet( ), - name = cms.string( "PFRecHitECALNavigator" ) - ) +process.hltHIL1SingleMu3Filtered = cms.EDFilter( "HLTMuonL1Filter", + saveTags = cms.bool( False ), + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1SingleMu3BptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 1 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "hltL1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) ) -process.hltParticleFlowRecHitPSL1Seeded = cms.EDProducer( "PFRecHitProducer", - producers = cms.VPSet( - cms.PSet( src = cms.InputTag( 'hltRechitInRegionsES','EcalRecHitsES' ), - qualityTests = cms.VPSet( - cms.PSet( threshold = cms.double( 7.0E-6 ), - name = cms.string( "PFRecHitQTestThreshold" ) - ) - ), - name = cms.string( "PFPSRecHitCreator" ) - ) - ), - navigator = cms.PSet( name = cms.string( "PFRecHitPreshowerNavigator" ) ) -) -process.hltParticleFlowClusterPSL1Seeded = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - minFracTot = cms.double( 1.0E-20 ), - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 6.0E-5 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 0.3 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "PS1" ), - recHitEnergyNorm = cms.double( 6.0E-5 ) - ), - cms.PSet( detector = cms.string( "PS2" ), - recHitEnergyNorm = cms.double( 6.0E-5 ) - ) - ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ) - ), - positionReCalc = cms.PSet( ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 6.0E-5 ), - detector = cms.string( "PS1" ), - gatheringThresholdPt = cms.double( 0.0 ) - ), - cms.PSet( gatheringThreshold = cms.double( 6.0E-5 ), - detector = cms.string( "PS2" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) - ), - useCornerCells = cms.bool( False ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 4 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 1.2E-4 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "PS1" ) - ), - cms.PSet( seedingThreshold = cms.double( 1.2E-4 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "PS2" ) - ) - ), - algoName = cms.string( "LocalMaximumSeedFinder" ) - ), - recHitsSource = cms.InputTag( "hltParticleFlowRecHitPSL1Seeded" ) -) -process.hltParticleFlowClusterECALUncorrectedL1Seeded = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.08 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( 9 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - minFracTot = cms.double( 1.0E-20 ), - positionCalcForConvergence = cms.PSet( - minFractionInCalc = cms.double( 0.0 ), - W0 = cms.double( 4.2 ), - minAllowedNormalization = cms.double( 0.0 ), - T0_EB = cms.double( 7.4 ), - X0 = cms.double( 0.89 ), - T0_ES = cms.double( 1.2 ), - T0_EE = cms.double( 3.1 ), - algoName = cms.string( "ECAL2DPositionCalcWithDepthCorr" ) - ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 1.5 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "ECAL_BARREL" ), - recHitEnergyNorm = cms.double( 0.08 ) - ), - cms.PSet( detector = cms.string( "ECAL_ENDCAP" ), - recHitEnergyNorm = cms.double( 0.3 ) - ) - ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ), - allCellsPositionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.08 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ) - ), - positionReCalc = cms.PSet( - minFractionInCalc = cms.double( 0.0 ), - W0 = cms.double( 4.2 ), - minAllowedNormalization = cms.double( 0.0 ), - T0_EB = cms.double( 7.4 ), - X0 = cms.double( 0.89 ), - T0_ES = cms.double( 1.2 ), - T0_EE = cms.double( 3.1 ), - algoName = cms.string( "ECAL2DPositionCalcWithDepthCorr" ) - ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 0.08 ), - detector = cms.string( "ECAL_BARREL" ), - gatheringThresholdPt = cms.double( 0.0 ) - ), - cms.PSet( gatheringThreshold = cms.double( 0.3 ), - detector = cms.string( "ECAL_ENDCAP" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) - ), - useCornerCells = cms.bool( True ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - cms.PSet( cleaningByDetector = cms.VPSet( - cms.PSet( doubleSpikeS6S2 = cms.double( 0.04 ), - fractionThresholdModifier = cms.double( 3.0 ), - doubleSpikeThresh = cms.double( 10.0 ), - minS4S1_b = cms.double( -0.024 ), - singleSpikeThresh = cms.double( 4.0 ), - detector = cms.string( "ECAL_BARREL" ), - minS4S1_a = cms.double( 0.04 ), - energyThresholdModifier = cms.double( 2.0 ) - ), - cms.PSet( doubleSpikeS6S2 = cms.double( -1.0 ), - fractionThresholdModifier = cms.double( 3.0 ), - doubleSpikeThresh = cms.double( 1.0E9 ), - minS4S1_b = cms.double( -0.0125 ), - singleSpikeThresh = cms.double( 15.0 ), - detector = cms.string( "ECAL_ENDCAP" ), - minS4S1_a = cms.double( 0.02 ), - energyThresholdModifier = cms.double( 2.0 ) - ) -), - algoName = cms.string( "SpikeAndDoubleSpikeCleaner" ) - ) - ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 8 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 0.6 ), - seedingThresholdPt = cms.double( 0.15 ), - detector = cms.string( "ECAL_ENDCAP" ) - ), - cms.PSet( seedingThreshold = cms.double( 0.23 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "ECAL_BARREL" ) - ) +process.hltMuonDTDigis = cms.EDProducer( "DTUnpackingModule", + useStandardFEDid = cms.bool( True ), + maxFEDid = cms.untracked.int32( 779 ), + inputLabel = cms.InputTag( "rawDataCollector" ), + minFEDid = cms.untracked.int32( 770 ), + dataType = cms.string( "DDU" ), + readOutParameters = cms.PSet( + debug = cms.untracked.bool( False ), + rosParameters = cms.PSet( + writeSC = cms.untracked.bool( True ), + readingDDU = cms.untracked.bool( True ), + performDataIntegrityMonitor = cms.untracked.bool( False ), + readDDUIDfromDDU = cms.untracked.bool( True ), + debug = cms.untracked.bool( False ), + localDAQ = cms.untracked.bool( False ) ), - algoName = cms.string( "LocalMaximumSeedFinder" ) - ), - recHitsSource = cms.InputTag( "hltParticleFlowRecHitECALL1Seeded" ) -) -process.hltParticleFlowClusterECALL1Seeded = cms.EDProducer( "CorrectedECALPFClusterProducer", - inputPS = cms.InputTag( "hltParticleFlowClusterPSL1Seeded" ), - minimumPSEnergy = cms.double( 0.0 ), - energyCorrector = cms.PSet( - applyCrackCorrections = cms.bool( False ), - algoName = cms.string( "PFClusterEMEnergyCorrector" ) - ), - inputECAL = cms.InputTag( "hltParticleFlowClusterECALUncorrectedL1Seeded" ) -) -process.hltParticleFlowSuperClusterECALL1Seeded = cms.EDProducer( "PFECALSuperClusterProducer", - PFSuperClusterCollectionEndcap = cms.string( "hltParticleFlowSuperClusterECALEndcap" ), - doSatelliteClusterMerge = cms.bool( False ), - BeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - PFBasicClusterCollectionBarrel = cms.string( "hltParticleFlowBasicClusterECALBarrel" ), - useRegression = cms.bool( False ), - satelliteMajorityFraction = cms.double( 0.5 ), - thresh_PFClusterEndcap = cms.double( 4.0 ), - ESAssociation = cms.InputTag( "hltParticleFlowClusterECALL1Seeded" ), - PFBasicClusterCollectionPreshower = cms.string( "hltParticleFlowBasicClusterECALPreshower" ), - use_preshower = cms.bool( True ), - thresh_PFClusterBarrel = cms.double( 4.0 ), - thresh_SCEt = cms.double( 4.0 ), - etawidth_SuperClusterEndcap = cms.double( 0.04 ), - phiwidth_SuperClusterEndcap = cms.double( 0.6 ), - verbose = cms.untracked.bool( False ), - useDynamicDPhiWindow = cms.bool( True ), - PFSuperClusterCollectionBarrel = cms.string( "hltParticleFlowSuperClusterECALBarrel" ), - regressionConfig = cms.PSet( - regressionKeyEE = cms.string( "pfscecal_EECorrection_offline" ), - ecalRecHitsEE = cms.InputTag( 'hltRechitInRegionsECAL','EcalRecHitsEE' ), - ecalRecHitsEB = cms.InputTag( 'hltRechitInRegionsECAL','EcalRecHitsEB' ), - regressionKeyEB = cms.string( "pfscecal_EBCorrection_offline" ), - vertexCollection = cms.InputTag( "offlinePrimaryVertices" ) + localDAQ = cms.untracked.bool( False ), + performDataIntegrityMonitor = cms.untracked.bool( False ) ), - applyCrackCorrections = cms.bool( False ), - satelliteClusterSeedThreshold = cms.double( 50.0 ), - etawidth_SuperClusterBarrel = cms.double( 0.04 ), - PFBasicClusterCollectionEndcap = cms.string( "hltParticleFlowBasicClusterECALEndcap" ), - PFClusters = cms.InputTag( "hltParticleFlowClusterECALL1Seeded" ), - thresh_PFClusterSeedBarrel = cms.double( 4.0 ), - ClusteringType = cms.string( "Mustache" ), - EnergyWeight = cms.string( "Raw" ), - thresh_PFClusterSeedEndcap = cms.double( 4.0 ), - phiwidth_SuperClusterBarrel = cms.double( 0.6 ), - thresh_PFClusterES = cms.double( 5.0 ), - seedThresholdIsET = cms.bool( True ), - PFSuperClusterCollectionEndcapWithPreshower = cms.string( "hltParticleFlowSuperClusterECALEndcapWithPreshower" ) -) -process.hltEgammaCandidates = cms.EDProducer( "EgammaHLTRecoEcalCandidateProducers", - scIslandEndcapProducer = cms.InputTag( 'hltParticleFlowSuperClusterECALL1Seeded','hltParticleFlowSuperClusterECALEndcapWithPreshower' ), - scHybridBarrelProducer = cms.InputTag( 'hltParticleFlowSuperClusterECALL1Seeded','hltParticleFlowSuperClusterECALBarrel' ), - recoEcalCandidateCollection = cms.string( "" ) -) -process.hltEGL1SingleIsoEG22erFilter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", - doIsolated = cms.bool( False ), - endcap_end = cms.double( 2.65 ), - saveTags = cms.bool( False ), - region_eta_size_ecap = cms.double( 1.0 ), - barrel_end = cms.double( 1.4791 ), - l1IsolatedTag = cms.InputTag( 'hltL1extraParticles','Isolated' ), - candIsolatedTag = cms.InputTag( "hltEgammaCandidates" ), - region_phi_size = cms.double( 1.044 ), - region_eta_size = cms.double( 0.522 ), - L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleIsoEG22er" ), - candNonIsolatedTag = cms.InputTag( "" ), - l1NonIsolatedTag = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), - ncandcut = cms.int32( 1 ) -) -process.hltEG27EtL1IsoEG22erFilter = cms.EDFilter( "HLTEgammaEtFilter", - saveTags = cms.bool( False ), - L1NonIsoCand = cms.InputTag( "" ), - relaxed = cms.untracked.bool( False ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - inputTag = cms.InputTag( "hltEGL1SingleIsoEG22erFilter" ), - etcutEB = cms.double( 27.0 ), - etcutEE = cms.double( 27.0 ), - ncandcut = cms.int32( 1 ) -) -process.hltEgammaClusterShape = cms.EDProducer( "EgammaHLTClusterShapeProducer", - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - ecalRechitEB = cms.InputTag( 'hltRechitInRegionsECAL','EcalRecHitsEB' ), - ecalRechitEE = cms.InputTag( 'hltRechitInRegionsECAL','EcalRecHitsEE' ), - isIeta = cms.bool( True ) -) -process.hltEle27WP75ClusterShapeFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( 0.031 ), - thrOverEEE = cms.double( -1.0 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( -1.0 ), - thrRegularEB = cms.double( 0.011 ), - lessThan = cms.bool( True ), - useEt = cms.bool( False ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( 'hltEgammaClusterShape','sigmaIEtaIEta5x5' ), - candTag = cms.InputTag( "hltEG27EtL1IsoEG22erFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltFixedGridRhoFastjetAllCaloForMuons = cms.EDProducer( "FixedGridRhoProducerFastjet", - gridSpacing = cms.double( 0.55 ), - maxRapidity = cms.double( 2.5 ), - pfCandidatesTag = cms.InputTag( "hltTowerMakerForAll" ) -) -process.hltEgammaHoverE = cms.EDProducer( "EgammaHLTBcHcalIsolationProducersRegional", - caloTowerProducer = cms.InputTag( "hltTowerMakerForAll" ), - effectiveAreaBarrel = cms.double( 0.105 ), - outerCone = cms.double( 0.14 ), - innerCone = cms.double( 0.0 ), - useSingleTower = cms.bool( False ), - rhoProducer = cms.InputTag( "hltFixedGridRhoFastjetAllCaloForMuons" ), - depth = cms.int32( -1 ), - doRhoCorrection = cms.bool( False ), - effectiveAreaEndcap = cms.double( 0.17 ), - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - rhoMax = cms.double( 9.9999999E7 ), - etMin = cms.double( 0.0 ), - rhoScale = cms.double( 1.0 ), - doEtSum = cms.bool( False ) -) -process.hltEle27WP75HcEFilter = cms.EDFilter( "HLTEgammaGenericQuadraticFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( 0.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( 0.0 ), - thrRegularEE = cms.double( 13.0 ), - thrOverEEE = cms.double( 0.01 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.01 ), - thrRegularEB = cms.double( 4.0 ), - lessThan = cms.bool( True ), - useEt = cms.bool( False ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaHoverE" ), - candTag = cms.InputTag( "hltEle27WP75ClusterShapeFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltEgammaEcalPFClusterIso = cms.EDProducer( "EgammaHLTEcalPFClusterIsolationProducer", - energyEndcap = cms.double( 0.0 ), - effectiveAreaBarrel = cms.double( 0.149 ), - etaStripBarrel = cms.double( 0.0 ), - rhoProducer = cms.InputTag( "hltFixedGridRhoFastjetAllCaloForMuons" ), - pfClusterProducer = cms.InputTag( "hltParticleFlowClusterECALL1Seeded" ), - etaStripEndcap = cms.double( 0.0 ), - drVetoBarrel = cms.double( 0.0 ), - drMax = cms.double( 0.3 ), - doRhoCorrection = cms.bool( True ), - energyBarrel = cms.double( 0.0 ), - effectiveAreaEndcap = cms.double( 0.097 ), - drVetoEndcap = cms.double( 0.0 ), - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - rhoMax = cms.double( 9.9999999E7 ), - rhoScale = cms.double( 1.0 ) -) -process.hltEle27WP75EcalIsoFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( -1.0 ), - thrOverEEE = cms.double( 0.14 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.21 ), - thrRegularEB = cms.double( -1.0 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaEcalPFClusterIso" ), - candTag = cms.InputTag( "hltEle27WP75HcEFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltRegionalTowerForEgamma = cms.EDProducer( "EgammaHLTCaloTowerProducer", - L1NonIsoCand = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), - EMin = cms.double( 0.8 ), - EtMin = cms.double( 0.5 ), - L1IsoCand = cms.InputTag( 'hltL1extraParticles','Isolated' ), - useTowersInCone = cms.double( 0.8 ), - towerCollection = cms.InputTag( "hltTowerMakerForAll" ) -) -process.hltParticleFlowRecHitHCALForEgamma = cms.EDProducer( "PFCTRecHitProducer", - ECAL_Compensate = cms.bool( False ), - ECAL_Dead_Code = cms.uint32( 10 ), - MinLongTiming_Cut = cms.double( -5.0 ), - ECAL_Compensation = cms.double( 0.5 ), - MaxLongTiming_Cut = cms.double( 5.0 ), - weight_HFhad = cms.double( 1.0 ), - ApplyPulseDPG = cms.bool( False ), - navigator = cms.PSet( name = cms.string( "PFRecHitCaloTowerNavigator" ) ), - ECAL_Threshold = cms.double( 10.0 ), - ApplyTimeDPG = cms.bool( False ), - caloTowers = cms.InputTag( "hltRegionalTowerForEgamma" ), - hcalRecHitsHBHE = cms.InputTag( "hltHbhereco" ), - LongFibre_Fraction = cms.double( 0.1 ), - MaxShortTiming_Cut = cms.double( 5.0 ), - HcalMaxAllowedHFLongShortSev = cms.int32( 9 ), - thresh_Barrel = cms.double( 0.4 ), - navigation_HF = cms.bool( True ), - HcalMaxAllowedHFInTimeWindowSev = cms.int32( 9 ), - HF_Calib_29 = cms.double( 1.07 ), - LongFibre_Cut = cms.double( 120.0 ), - EM_Depth = cms.double( 22.0 ), - weight_HFem = cms.double( 1.0 ), - LongShortFibre_Cut = cms.double( 1.0E9 ), - MinShortTiming_Cut = cms.double( -5.0 ), - HCAL_Calib = cms.bool( True ), - thresh_HF = cms.double( 0.4 ), - HcalMaxAllowedHFDigiTimeSev = cms.int32( 9 ), - thresh_Endcap = cms.double( 0.4 ), - HcalMaxAllowedChannelStatusSev = cms.int32( 9 ), - hcalRecHitsHF = cms.InputTag( "hltHfreco" ), - ShortFibre_Cut = cms.double( 60.0 ), - ApplyLongShortDPG = cms.bool( True ), - HF_Calib = cms.bool( True ), - HAD_Depth = cms.double( 47.0 ), - ShortFibre_Fraction = cms.double( 0.01 ), - HCAL_Calib_29 = cms.double( 1.35 ) -) -process.hltParticleFlowClusterHCALForEgamma = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( 5 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - minFracTot = cms.double( 1.0E-20 ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 10.0 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "HCAL_BARREL1" ), - recHitEnergyNorm = cms.double( 0.8 ) - ), - cms.PSet( detector = cms.string( "HCAL_ENDCAP" ), - recHitEnergyNorm = cms.double( 0.8 ) - ) + dqmOnly = cms.bool( False ) +) +process.hltDt1DRecHits = cms.EDProducer( "DTRecHitProducer", + debug = cms.untracked.bool( False ), + recAlgoConfig = cms.PSet( + tTrigMode = cms.string( "DTTTrigSyncFromDB" ), + minTime = cms.double( -3.0 ), + stepTwoFromDigi = cms.bool( False ), + doVdriftCorr = cms.bool( True ), + debug = cms.untracked.bool( False ), + maxTime = cms.double( 420.0 ), + tTrigModeConfig = cms.PSet( + vPropWire = cms.double( 24.4 ), + doTOFCorrection = cms.bool( True ), + tofCorrType = cms.int32( 0 ), + wirePropCorrType = cms.int32( 0 ), + tTrigLabel = cms.string( "" ), + doWirePropCorrection = cms.bool( True ), + doT0Correction = cms.bool( True ), + debug = cms.untracked.bool( False ) ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ), - allCellsPositionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ) + useUncertDB = cms.bool( True ) ), - positionReCalc = cms.PSet( ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 0.8 ), - detector = cms.string( "HCAL_BARREL1" ), - gatheringThresholdPt = cms.double( 0.0 ) + dtDigiLabel = cms.InputTag( "hltMuonDTDigis" ), + recAlgo = cms.string( "DTLinearDriftFromDBAlgo" ) +) +process.hltDt4DSegments = cms.EDProducer( "DTRecSegment4DProducer", + debug = cms.untracked.bool( False ), + Reco4DAlgoName = cms.string( "DTCombinatorialPatternReco4D" ), + recHits2DLabel = cms.InputTag( "dt2DSegments" ), + recHits1DLabel = cms.InputTag( "hltDt1DRecHits" ), + Reco4DAlgoConfig = cms.PSet( + segmCleanerMode = cms.int32( 2 ), + Reco2DAlgoName = cms.string( "DTCombinatorialPatternReco" ), + recAlgoConfig = cms.PSet( + tTrigMode = cms.string( "DTTTrigSyncFromDB" ), + minTime = cms.double( -3.0 ), + stepTwoFromDigi = cms.bool( False ), + doVdriftCorr = cms.bool( True ), + debug = cms.untracked.bool( False ), + maxTime = cms.double( 420.0 ), + tTrigModeConfig = cms.PSet( + vPropWire = cms.double( 24.4 ), + doTOFCorrection = cms.bool( True ), + tofCorrType = cms.int32( 0 ), + wirePropCorrType = cms.int32( 0 ), + tTrigLabel = cms.string( "" ), + doWirePropCorrection = cms.bool( True ), + doT0Correction = cms.bool( True ), + debug = cms.untracked.bool( False ) ), - cms.PSet( gatheringThreshold = cms.double( 0.8 ), - detector = cms.string( "HCAL_ENDCAP" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) + useUncertDB = cms.bool( True ) ), - useCornerCells = cms.bool( True ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - cms.PSet( algoName = cms.string( "RBXAndHPDCleaner" ) ) - ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 4 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 0.8 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "HCAL_BARREL1" ) + nSharedHitsMax = cms.int32( 2 ), + hit_afterT0_resolution = cms.double( 0.03 ), + Reco2DAlgoConfig = cms.PSet( + segmCleanerMode = cms.int32( 2 ), + recAlgoConfig = cms.PSet( + tTrigMode = cms.string( "DTTTrigSyncFromDB" ), + minTime = cms.double( -3.0 ), + stepTwoFromDigi = cms.bool( False ), + doVdriftCorr = cms.bool( True ), + debug = cms.untracked.bool( False ), + maxTime = cms.double( 420.0 ), + tTrigModeConfig = cms.PSet( + vPropWire = cms.double( 24.4 ), + doTOFCorrection = cms.bool( True ), + tofCorrType = cms.int32( 0 ), + wirePropCorrType = cms.int32( 0 ), + tTrigLabel = cms.string( "" ), + doWirePropCorrection = cms.bool( True ), + doT0Correction = cms.bool( True ), + debug = cms.untracked.bool( False ) + ), + useUncertDB = cms.bool( True ) ), - cms.PSet( seedingThreshold = cms.double( 1.1 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "HCAL_ENDCAP" ) - ) + nSharedHitsMax = cms.int32( 2 ), + AlphaMaxPhi = cms.double( 1.0 ), + hit_afterT0_resolution = cms.double( 0.03 ), + MaxAllowedHits = cms.uint32( 50 ), + performT0_vdriftSegCorrection = cms.bool( False ), + AlphaMaxTheta = cms.double( 0.9 ), + debug = cms.untracked.bool( False ), + recAlgo = cms.string( "DTLinearDriftFromDBAlgo" ), + nUnSharedHitsMin = cms.int32( 2 ), + performT0SegCorrection = cms.bool( False ), + perform_delta_rejecting = cms.bool( False ) ), - algoName = cms.string( "LocalMaximumSeedFinder" ) - ), - recHitsSource = cms.InputTag( "hltParticleFlowRecHitHCALForEgamma" ) -) -process.hltEgammaHcalPFClusterIso = cms.EDProducer( "EgammaHLTHcalPFClusterIsolationProducer", - energyEndcap = cms.double( 0.0 ), - useHF = cms.bool( False ), - effectiveAreaBarrel = cms.double( 0.06 ), - etaStripBarrel = cms.double( 0.0 ), - pfClusterProducerHFHAD = cms.InputTag( "hltParticleFlowClusterHFHADForEgamma" ), - rhoProducer = cms.InputTag( "hltFixedGridRhoFastjetAllCaloForMuons" ), - etaStripEndcap = cms.double( 0.0 ), - drVetoBarrel = cms.double( 0.0 ), - pfClusterProducerHCAL = cms.InputTag( "hltParticleFlowClusterHCALForEgamma" ), - drMax = cms.double( 0.3 ), - doRhoCorrection = cms.bool( True ), - energyBarrel = cms.double( 0.0 ), - effectiveAreaEndcap = cms.double( 0.089 ), - drVetoEndcap = cms.double( 0.0 ), - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - rhoMax = cms.double( 9.9999999E7 ), - pfClusterProducerHFEM = cms.InputTag( "hltParticleFlowClusterHFEMForEgamma" ), - rhoScale = cms.double( 1.0 ) -) -process.hltEle27WP75HcalIsoFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( -1.0 ), - thrOverEEE = cms.double( 0.21 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.11 ), - thrRegularEB = cms.double( -1.0 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaHcalPFClusterIso" ), - candTag = cms.InputTag( "hltEle27WP75EcalIsoFilter" ), - nonIsoTag = cms.InputTag( "" ) + performT0_vdriftSegCorrection = cms.bool( False ), + debug = cms.untracked.bool( False ), + recAlgo = cms.string( "DTLinearDriftFromDBAlgo" ), + nUnSharedHitsMin = cms.int32( 2 ), + AllDTRecHits = cms.bool( True ), + performT0SegCorrection = cms.bool( False ), + perform_delta_rejecting = cms.bool( False ) + ) ) -process.hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", - UseQualityInfo = cms.bool( False ), - UsePilotBlade = cms.bool( False ), - UsePhase1 = cms.bool( False ), - InputLabel = cms.InputTag( "rawDataCollector" ), - IncludeErrors = cms.bool( False ), - ErrorList = cms.vint32( ), - Regions = cms.PSet( ), - Timing = cms.untracked.bool( False ), - UserErrorList = cms.vint32( ) +process.hltMuonCSCDigis = cms.EDProducer( "CSCDCCUnpacker", + PrintEventNumber = cms.untracked.bool( False ), + SuppressZeroLCT = cms.untracked.bool( True ), + UseExaminer = cms.bool( True ), + Debug = cms.untracked.bool( False ), + ErrorMask = cms.uint32( 0x0 ), + InputObjects = cms.InputTag( "rawDataCollector" ), + ExaminerMask = cms.uint32( 0x1febf3f6 ), + runDQM = cms.untracked.bool( False ), + UnpackStatusDigis = cms.bool( False ), + VisualFEDInspect = cms.untracked.bool( False ), + FormatedEventDump = cms.untracked.bool( False ), + UseFormatStatus = cms.bool( True ), + UseSelectiveUnpacking = cms.bool( True ), + VisualFEDShort = cms.untracked.bool( False ) ) -process.hltSiPixelClusters = cms.EDProducer( "SiPixelClusterProducer", - src = cms.InputTag( "hltSiPixelDigis" ), - ChannelThreshold = cms.int32( 1000 ), - maxNumberOfClusters = cms.int32( 20000 ), - VCaltoElectronGain = cms.int32( 65 ), - MissCalibrate = cms.untracked.bool( True ), - SplitClusters = cms.bool( False ), - VCaltoElectronOffset = cms.int32( -414 ), - payloadType = cms.string( "HLT" ), - SeedThreshold = cms.int32( 1000 ), - ClusterThreshold = cms.double( 4000.0 ) -) -process.hltSiPixelClustersCache = cms.EDProducer( "SiPixelClusterShapeCacheProducer", - src = cms.InputTag( "hltSiPixelClusters" ), - onDemand = cms.bool( False ) -) -process.hltSiPixelRecHits = cms.EDProducer( "SiPixelRecHitConverter", - VerboseLevel = cms.untracked.int32( 0 ), - src = cms.InputTag( "hltSiPixelClusters" ), - CPE = cms.string( "hltESPPixelCPEGeneric" ) -) -process.hltSiStripExcludedFEDListProducer = cms.EDProducer( "SiStripExcludedFEDListProducer", - ProductLabel = cms.InputTag( "rawDataCollector" ) -) -process.hltSiStripRawToClustersFacility = cms.EDProducer( "SiStripClusterizerFromRaw", - ProductLabel = cms.InputTag( "rawDataCollector" ), - DoAPVEmulatorCheck = cms.bool( False ), - Algorithms = cms.PSet( - SiStripFedZeroSuppressionMode = cms.uint32( 4 ), - CommonModeNoiseSubtractionMode = cms.string( "Median" ), - PedestalSubtractionFedMode = cms.bool( True ), - TruncateInSuppressor = cms.bool( True ), - doAPVRestore = cms.bool( False ), - useCMMeanMap = cms.bool( False ) - ), - Clusterizer = cms.PSet( - ChannelThreshold = cms.double( 2.0 ), - MaxSequentialBad = cms.uint32( 1 ), - MaxSequentialHoles = cms.uint32( 0 ), - Algorithm = cms.string( "ThreeThresholdAlgorithm" ), - MaxAdjacentBad = cms.uint32( 0 ), - QualityLabel = cms.string( "" ), - SeedThreshold = cms.double( 3.0 ), - ClusterThreshold = cms.double( 5.0 ), - setDetId = cms.bool( True ), - RemoveApvShots = cms.bool( True ) - ), - onDemand = cms.bool( True ) -) -process.hltSiStripClusters = cms.EDProducer( "MeasurementTrackerEventProducer", - inactivePixelDetectorLabels = cms.VInputTag( ), - stripClusterProducer = cms.string( "hltSiStripRawToClustersFacility" ), - pixelClusterProducer = cms.string( "hltSiPixelClusters" ), - switchOffPixelsIfEmpty = cms.bool( True ), - inactiveStripDetectorLabels = cms.VInputTag( 'hltSiStripExcludedFEDListProducer' ), - skipClusters = cms.InputTag( "" ), - measurementTracker = cms.string( "hltESPMeasurementTracker" ) -) -process.hltMixedLayerPairs = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2', - 'BPix1+BPix3', - 'BPix2+BPix3', - 'BPix1+FPix1_pos', - 'BPix1+FPix1_neg', - 'BPix1+FPix2_pos', - 'BPix1+FPix2_neg', - 'BPix2+FPix1_pos', - 'BPix2+FPix1_neg', - 'BPix2+FPix2_pos', - 'BPix2+FPix2_neg', - 'FPix1_pos+FPix2_pos', - 'FPix1_neg+FPix2_neg', - 'FPix2_pos+TEC1_pos', - 'FPix2_pos+TEC2_pos', - 'TEC1_pos+TEC2_pos', - 'TEC2_pos+TEC3_pos', - 'FPix2_neg+TEC1_neg', - 'FPix2_neg+TEC2_neg', - 'TEC1_neg+TEC2_neg', - 'TEC2_neg+TEC3_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( - useRingSlector = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - minRing = cms.int32( 1 ), - maxRing = cms.int32( 1 ) - ), - MTID = cms.PSet( ), - FPix = cms.PSet( - useErrorsFromParam = cms.bool( True ), - hitErrorRPhi = cms.double( 0.0051 ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - useErrorsFromParam = cms.bool( True ), - hitErrorRPhi = cms.double( 0.0027 ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ) - ), - TIB = cms.PSet( ) -) -process.hltEgammaElectronPixelSeeds = cms.EDProducer( "ElectronSeedProducer", - endcapSuperClusters = cms.InputTag( 'hltParticleFlowSuperClusterECALL1Seeded','hltParticleFlowSuperClusterECALEndcapWithPreshower' ), - SeedConfiguration = cms.PSet( - searchInTIDTEC = cms.bool( True ), - HighPtThreshold = cms.double( 35.0 ), - r2MinF = cms.double( -0.15 ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitPairGenerator" ), - useOnDemandTracker = cms.untracked.int32( 0 ), - SeedingLayers = cms.InputTag( "hltMixedLayerPairs" ) - ), - DeltaPhi1Low = cms.double( 0.23 ), - DeltaPhi1High = cms.double( 0.08 ), - ePhiMin1 = cms.double( -0.08 ), - LowPtThreshold = cms.double( 3.0 ), - RegionPSet = cms.PSet( - deltaPhiRegion = cms.double( 0.4 ), - originHalfLength = cms.double( 15.0 ), - useZInVertex = cms.bool( True ), - deltaEtaRegion = cms.double( 0.1 ), - ptMin = cms.double( 1.5 ), - originRadius = cms.double( 0.2 ), - VertexProducer = cms.InputTag( "dummyVertices" ) - ), - dynamicPhiRoad = cms.bool( False ), - ePhiMax1 = cms.double( 0.04 ), - measurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - SizeWindowENeg = cms.double( 0.675 ), - nSigmasDeltaZ1 = cms.double( 5.0 ), - rMaxI = cms.double( 0.2 ), - preFilteredSeeds = cms.bool( True ), - r2MaxF = cms.double( 0.15 ), - pPhiMin1 = cms.double( -0.04 ), - initialSeeds = cms.InputTag( "noSeedsHere" ), - pPhiMax1 = cms.double( 0.08 ), - SCEtCut = cms.double( 3.0 ), - z2MaxB = cms.double( 0.09 ), - fromTrackerSeeds = cms.bool( True ), - hcalRecHits = cms.InputTag( "hltHbhereco" ), - z2MinB = cms.double( -0.09 ), - rMinI = cms.double( -0.2 ), - hOverEConeSize = cms.double( 0.0 ), - hOverEHBMinE = cms.double( 999999.0 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - applyHOverECut = cms.bool( False ), - hOverEHFMinE = cms.double( 999999.0 ), - measurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - PhiMin2B = cms.double( -0.004 ), - PhiMin2F = cms.double( -0.004 ), - PhiMax2B = cms.double( 0.004 ), - PhiMax2F = cms.double( 0.004 ), - DeltaPhi2B = cms.double( 0.004 ), - DeltaPhi2F = cms.double( 0.004 ) - ), - barrelSuperClusters = cms.InputTag( 'hltParticleFlowSuperClusterECALL1Seeded','hltParticleFlowSuperClusterECALBarrel' ) -) -process.hltEle27WP75PixelMatchFilter = cms.EDFilter( "HLTElectronPixelMatchFilter", - saveTags = cms.bool( False ), - s2_threshold = cms.double( 0.4 ), - npixelmatchcut = cms.double( 1.0 ), - tanhSO10InterThres = cms.double( 1.0 ), - pixelVeto = cms.bool( False ), - doIsolated = cms.bool( True ), - s_a_phi1B = cms.double( 0.0069 ), - s_a_phi1F = cms.double( 0.0076 ), - s_a_phi1I = cms.double( 0.0088 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - candTag = cms.InputTag( "hltEle27WP75HcalIsoFilter" ), - tanhSO10ForwardThres = cms.double( 1.0 ), - L1IsoPixelSeedsTag = cms.InputTag( "hltEgammaElectronPixelSeeds" ), - L1NonIsoCand = cms.InputTag( "" ), - ncandcut = cms.int32( 1 ), - tanhSO10BarrelThres = cms.double( 0.35 ), - s_a_rF = cms.double( 0.04 ), - L1NonIsoPixelSeedsTag = cms.InputTag( "" ), - s_a_rI = cms.double( 0.027 ), - s_a_phi2I = cms.double( 7.0E-4 ), - useS = cms.bool( False ), - s_a_phi2B = cms.double( 3.7E-4 ), - s_a_zB = cms.double( 0.012 ), - s_a_phi2F = cms.double( 0.00906 ) -) -process.hltEgammaCkfTrackCandidatesForGSF = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltEgammaElectronPixelSeeds" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - cleanTrajectoryAfterInOut = cms.bool( True ), - useHitsSplitting = cms.bool( True ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( True ), - maxNSeeds = cms.uint32( 1000000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetTrajectoryBuilderForElectrons" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) -) -process.hltEgammaGsfTracks = cms.EDProducer( "GsfTrackProducer", - src = cms.InputTag( "hltEgammaCkfTrackCandidatesForGSF" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - producer = cms.string( "" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPGsfElectronFittingSmoother" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "hltESPMeasurementTracker" ), - GeometricInnerState = cms.bool( True ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - AlgorithmName = cms.string( "gsf" ), - Propagator = cms.string( "hltESPFwdElectronPropagator" ) -) -process.hltEgammaGsfElectrons = cms.EDProducer( "EgammaHLTPixelMatchElectronProducers", - BSProducer = cms.InputTag( "hltOnlineBeamSpot" ), - UseGsfTracks = cms.bool( True ), - TrackProducer = cms.InputTag( "" ), - GsfTrackProducer = cms.InputTag( "hltEgammaGsfTracks" ) -) -process.hltEgammaGsfTrackVars = cms.EDProducer( "EgammaHLTGsfTrackVarProducer", - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - beamSpotProducer = cms.InputTag( "hltOnlineBeamSpot" ), - upperTrackNrToRemoveCut = cms.int32( 9999 ), - lowerTrackNrToRemoveCut = cms.int32( -1 ), - inputCollection = cms.InputTag( "hltEgammaGsfTracks" ) -) -process.hltEle27WP75GsfOneOEMinusOneOPFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( 0.032 ), - thrOverEEE = cms.double( -1.0 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( -1.0 ), - thrRegularEB = cms.double( 0.032 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( 'hltEgammaGsfTrackVars','OneOESuperMinusOneOP' ), - candTag = cms.InputTag( "hltEle27WP75PixelMatchFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltEle27WP75GsfChi2Filter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( 2.8 ), - thrOverEEE = cms.double( -1.0 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( -1.0 ), - thrRegularEB = cms.double( 3.0 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( 'hltEgammaGsfTrackVars','Chi2' ), - candTag = cms.InputTag( "hltEle27WP75GsfOneOEMinusOneOPFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltEle27WP75GsfDetaFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( 0.0065 ), - thrOverEEE = cms.double( -1.0 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( -1.0 ), - thrRegularEB = cms.double( 0.0035 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( 'hltEgammaGsfTrackVars','Deta' ), - candTag = cms.InputTag( "hltEle27WP75GsfChi2Filter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltEle27WP75GsfDphiFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( 0.035 ), - thrOverEEE = cms.double( -1.0 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( -1.0 ), - thrRegularEB = cms.double( 0.021 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( 'hltEgammaGsfTrackVars','Dphi' ), - candTag = cms.InputTag( "hltEle27WP75GsfDetaFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltElectronsVertex = cms.EDProducer( "VertexFromTrackProducer", - verbose = cms.untracked.bool( False ), - useTriggerFilterElectrons = cms.bool( False ), - beamSpotLabel = cms.InputTag( "hltOnlineBeamSpot" ), - isRecoCandidate = cms.bool( True ), - trackLabel = cms.InputTag( "hltEgammaGsfElectrons" ), - useTriggerFilterMuons = cms.bool( False ), - useBeamSpot = cms.bool( True ), - vertexLabel = cms.InputTag( "None" ), - triggerFilterElectronsSrc = cms.InputTag( "None" ), - triggerFilterMuonsSrc = cms.InputTag( "None" ), - useVertex = cms.bool( False ) -) -process.hltPixelLayerTriplets = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2+BPix3', - 'BPix1+BPix2+FPix1_pos', - 'BPix1+BPix2+FPix1_neg', - 'BPix1+FPix1_pos+FPix2_pos', - 'BPix1+FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - useErrorsFromParam = cms.bool( True ), - hitErrorRPhi = cms.double( 0.0051 ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - useErrorsFromParam = cms.bool( True ), - hitErrorRPhi = cms.double( 0.0027 ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ) - ), - TIB = cms.PSet( ) -) -process.hltPixelTracksElectrons = cms.EDProducer( "PixelTrackProducer", - useFilterWithES = cms.bool( False ), - FilterPSet = cms.PSet( - chi2 = cms.double( 1000.0 ), - nSigmaTipMaxTolerance = cms.double( 0.0 ), - ComponentName = cms.string( "PixelTrackFilterByKinematics" ), - nSigmaInvPtTolerance = cms.double( 0.0 ), - ptMin = cms.double( 0.1 ), - tipMax = cms.double( 1.0 ) - ), - passLabel = cms.string( "Pixel triplet primary tracks with vertex constraint" ), - FitterPSet = cms.PSet( - ComponentName = cms.string( "PixelFitterByHelixProjections" ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - fixImpactParameter = cms.double( 0.0 ) - ), - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "GlobalTrackingRegionWithVerticesProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.2 ), - ptMin = cms.double( 0.9 ), - originHalfLength = cms.double( 0.3 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - useFixedError = cms.bool( True ), - sigmaZVertex = cms.double( 3.0 ), - fixedError = cms.double( 0.2 ), - VertexCollection = cms.InputTag( "hltElectronsVertex" ), - useFoundVertices = cms.bool( True ), - nSigmaZ = cms.double( 4.0 ), - useFakeVertices = cms.bool( True ) - ) - ), - CleanerPSet = cms.PSet( ComponentName = cms.string( "PixelTrackCleanerBySharedHits" ) ), - OrderedHitsFactoryPSet = cms.PSet( - ComponentName = cms.string( "StandardHitTripletGenerator" ), - GeneratorPSet = cms.PSet( - useBending = cms.bool( True ), - useFixedPreFiltering = cms.bool( False ), - maxElement = cms.uint32( 100000 ), - phiPreFiltering = cms.double( 0.3 ), - extraHitRPhitolerance = cms.double( 0.06 ), - useMultScattering = cms.bool( True ), - SeedComparitorPSet = cms.PSet( - ComponentName = cms.string( "LowPtClusterShapeSeedComparitor" ), - clusterShapeCacheSrc = cms.InputTag( "hltSiPixelClustersCache" ) - ), - extraHitRZtolerance = cms.double( 0.06 ), - ComponentName = cms.string( "PixelTripletHLTGenerator" ) - ), - SeedingLayers = cms.InputTag( "hltPixelLayerTriplets" ) - ) -) -process.hltPixelVerticesElectrons = cms.EDProducer( "PixelVertexProducer", - WtAverage = cms.bool( True ), - Method2 = cms.bool( True ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - PVcomparer = cms.PSet( refToPSet_ = cms.string( "HLTPSetPvClusterComparer" ) ), - Verbosity = cms.int32( 0 ), - UseError = cms.bool( True ), - TrackCollection = cms.InputTag( "hltPixelTracksElectrons" ), - PtMin = cms.double( 1.0 ), - NTrkMin = cms.int32( 2 ), - ZOffset = cms.double( 5.0 ), - Finder = cms.string( "DivisiveVertexFinder" ), - ZSeparation = cms.double( 0.05 ) -) -process.hltIter0ElectronsPixelSeedsFromPixelTracks = cms.EDProducer( "SeedGeneratorFromProtoTracksEDProducer", - useEventsWithNoVertex = cms.bool( True ), - originHalfLength = cms.double( 0.3 ), - useProtoTrackKinematics = cms.bool( False ), - usePV = cms.bool( True ), - InputVertexCollection = cms.InputTag( "hltPixelVerticesElectrons" ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - InputCollection = cms.InputTag( "hltPixelTracksElectrons" ), - originRadius = cms.double( 0.1 ) -) -process.hltIter0ElectronsCkfTrackCandidates = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter0ElectronsPixelSeedsFromPixelTracks" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter0PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) -) -process.hltIter0ElectronsCtfWithMaterialTracks = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter0ElectronsCkfTrackCandidates" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -process.hltIter0ElectronsTrackSelectionHighPurity = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.4, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.35, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter0ElectronsCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesElectrons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.4, 4.0 ), - d0_par1 = cms.vdouble( 0.3, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter1ElectronsClustersRefRemoval = cms.EDProducer( "TrackClusterRemover", - minNumberOfLayersWithMeasBeforeFiltering = cms.int32( 0 ), - maxChi2 = cms.double( 9.0 ), - trajectories = cms.InputTag( "hltIter0ElectronsTrackSelectionHighPurity" ), - oldClusterRemovalInfo = cms.InputTag( "" ), - stripClusters = cms.InputTag( "hltSiStripRawToClustersFacility" ), - overrideTrkQuals = cms.InputTag( "" ), - pixelClusters = cms.InputTag( "hltSiPixelClusters" ), - TrackQuality = cms.string( "highPurity" ) -) -process.hltIter1ElectronsMaskedMeasurementTrackerEvent = cms.EDProducer( "MaskedMeasurementTrackerEventProducer", - clustersToSkip = cms.InputTag( "hltIter1ElectronsClustersRefRemoval" ), - OnDemand = cms.bool( False ), - src = cms.InputTag( "hltSiStripClusters" ) -) -process.hltIter1ElectronsPixelLayerTriplets = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2+BPix3', - 'BPix1+BPix2+FPix1_pos', - 'BPix1+BPix2+FPix1_neg', - 'BPix1+FPix1_pos+FPix2_pos', - 'BPix1+FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter1ElectronsClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0051 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter1ElectronsClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0027 ) - ), - TIB = cms.PSet( ) -) -process.hltIter1ElectronsPixelSeeds = cms.EDProducer( "SeedGeneratorFromRegionHitsEDProducer", - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "CandidateSeededTrackingRegionsProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.05 ), - ptMin = cms.double( 0.5 ), - input = cms.InputTag( "hltEgammaCandidates" ), - maxNRegions = cms.int32( 10 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - vertexCollection = cms.InputTag( "hltPixelVerticesElectrons" ), - zErrorBeamSpot = cms.double( 24.2 ), - deltaEta = cms.double( 0.5 ), - deltaPhi = cms.double( 0.5 ), - nSigmaZVertex = cms.double( 3.0 ), - nSigmaZBeamSpot = cms.double( 4.0 ), - mode = cms.string( "VerticesFixed" ), - maxNVertices = cms.int32( 3 ), - zErrorVetex = cms.double( 0.2 ) - ) - ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ), - ClusterCheckPSet = cms.PSet( - PixelClusterCollectionLabel = cms.InputTag( "hltSiPixelClusters" ), - MaxNumberOfCosmicClusters = cms.uint32( 50000 ), - doClusterCheck = cms.bool( False ), - ClusterCollectionLabel = cms.InputTag( "hltSiStripClusters" ), - MaxNumberOfPixelClusters = cms.uint32( 10000 ) - ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitTripletGenerator" ), - GeneratorPSet = cms.PSet( - useBending = cms.bool( True ), - useFixedPreFiltering = cms.bool( False ), - maxElement = cms.uint32( 100000 ), - phiPreFiltering = cms.double( 0.3 ), - extraHitRPhitolerance = cms.double( 0.032 ), - useMultScattering = cms.bool( True ), - ComponentName = cms.string( "PixelTripletHLTGenerator" ), - extraHitRZtolerance = cms.double( 0.037 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) - ), - SeedingLayers = cms.InputTag( "hltIter1ElectronsPixelLayerTriplets" ) - ), - SeedCreatorPSet = cms.PSet( - ComponentName = cms.string( "SeedFromConsecutiveHitsTripletOnlyCreator" ), - propagator = cms.string( "PropagatorWithMaterialParabolicMf" ), - SeedMomentumForBOFF = cms.double( 5.0 ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - TTRHBuilder = cms.string( "(unused)" ) -) -process.hltIter1ElectronsCkfTrackCandidates = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter1ElectronsPixelSeeds" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter1ElectronsMaskedMeasurementTrackerEvent" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter1PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) -) -process.hltIter1ElectronsCtfWithMaterialTracks = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter1ElectronsCkfTrackCandidates" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter1ElectronsMaskedMeasurementTrackerEvent" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -process.hltIter1ElectronsTrackSelectionHighPurityLoose = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.9, 3.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.8, 3.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter1ElectronsCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesElectrons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.9, 3.0 ), - d0_par1 = cms.vdouble( 0.85, 3.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter1ElectronsTrackSelectionHighPurityTight = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 5 ), - chi2n_par = cms.double( 0.4 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 1.0, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 1.0, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter1ElectronsCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesElectrons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 1.0, 4.0 ), - d0_par1 = cms.vdouble( 1.0, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter1ElectronsTrackSelectionHighPurity = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter1ElectronsTrackSelectionHighPurityLoose','hltIter1ElectronsTrackSelectionHighPurityTight' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter1ElectronsTrackSelectionHighPurityLoose','hltIter1ElectronsTrackSelectionHighPurityTight' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltIter1MergedForElectrons = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter0ElectronsTrackSelectionHighPurity','hltIter1ElectronsTrackSelectionHighPurity' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter0ElectronsTrackSelectionHighPurity','hltIter1ElectronsTrackSelectionHighPurity' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltIter2ElectronsClustersRefRemoval = cms.EDProducer( "TrackClusterRemover", - minNumberOfLayersWithMeasBeforeFiltering = cms.int32( 0 ), - maxChi2 = cms.double( 16.0 ), - trajectories = cms.InputTag( "hltIter1ElectronsTrackSelectionHighPurity" ), - oldClusterRemovalInfo = cms.InputTag( "hltIter1ElectronsClustersRefRemoval" ), - stripClusters = cms.InputTag( "hltSiStripRawToClustersFacility" ), - overrideTrkQuals = cms.InputTag( "" ), - pixelClusters = cms.InputTag( "hltSiPixelClusters" ), - TrackQuality = cms.string( "highPurity" ) -) -process.hltIter2ElectronsMaskedMeasurementTrackerEvent = cms.EDProducer( "MaskedMeasurementTrackerEventProducer", - clustersToSkip = cms.InputTag( "hltIter2ElectronsClustersRefRemoval" ), - OnDemand = cms.bool( False ), - src = cms.InputTag( "hltSiStripClusters" ) -) -process.hltIter2ElectronsPixelLayerPairs = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2', - 'BPix1+BPix3', - 'BPix2+BPix3', - 'BPix1+FPix1_pos', - 'BPix1+FPix1_neg', - 'BPix1+FPix2_pos', - 'BPix1+FPix2_neg', - 'BPix2+FPix1_pos', - 'BPix2+FPix1_neg', - 'BPix2+FPix2_pos', - 'BPix2+FPix2_neg', - 'FPix1_pos+FPix2_pos', - 'FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter2ElectronsClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0051 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter2ElectronsClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0027 ) - ), - TIB = cms.PSet( ) -) -process.hltIter2ElectronsPixelSeeds = cms.EDProducer( "SeedGeneratorFromRegionHitsEDProducer", - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "CandidateSeededTrackingRegionsProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.05 ), - ptMin = cms.double( 1.2 ), - deltaEta = cms.double( 0.5 ), - deltaPhi = cms.double( 0.5 ), - vertexCollection = cms.InputTag( "hltPixelVerticesElectrons" ), - input = cms.InputTag( "hltEgammaCandidates" ), - mode = cms.string( "VerticesFixed" ), - maxNRegions = cms.int32( 10 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - maxNVertices = cms.int32( 3 ), - zErrorBeamSpot = cms.double( 24.2 ), - nSigmaZVertex = cms.double( 3.0 ), - nSigmaZBeamSpot = cms.double( 4.0 ), - zErrorVetex = cms.double( 0.2 ) - ) - ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ), - ClusterCheckPSet = cms.PSet( - PixelClusterCollectionLabel = cms.InputTag( "hltSiPixelClusters" ), - MaxNumberOfCosmicClusters = cms.uint32( 50000 ), - doClusterCheck = cms.bool( False ), - ClusterCollectionLabel = cms.InputTag( "hltSiStripClusters" ), - MaxNumberOfPixelClusters = cms.uint32( 10000 ) - ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitPairGenerator" ), - GeneratorPSet = cms.PSet( - maxElement = cms.uint32( 100000 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) - ), - SeedingLayers = cms.InputTag( "hltIter2ElectronsPixelLayerPairs" ) - ), - SeedCreatorPSet = cms.PSet( - ComponentName = cms.string( "SeedFromConsecutiveHitsCreator" ), - propagator = cms.string( "PropagatorWithMaterialParabolicMf" ), - SeedMomentumForBOFF = cms.double( 5.0 ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - TTRHBuilder = cms.string( "(unused)" ) -) -process.hltIter2ElectronsCkfTrackCandidates = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter2ElectronsPixelSeeds" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter2ElectronsMaskedMeasurementTrackerEvent" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter2PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) -) -process.hltIter2ElectronsCtfWithMaterialTracks = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter2ElectronsCkfTrackCandidates" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter2ElectronsMaskedMeasurementTrackerEvent" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -process.hltIter2ElectronsTrackSelectionHighPurity = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.4, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.35, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter2ElectronsCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesElectrons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.4, 4.0 ), - d0_par1 = cms.vdouble( 0.3, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter2MergedForElectrons = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter1MergedForElectrons','hltIter2ElectronsTrackSelectionHighPurity' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter1MergedForElectrons','hltIter2ElectronsTrackSelectionHighPurity' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltEgammaEleGsfTrackIso = cms.EDProducer( "EgammaHLTElectronTrackIsolationProducers", - egTrkIsoStripEndcap = cms.double( 0.03 ), - egTrkIsoVetoConeSizeBarrel = cms.double( 0.03 ), - useGsfTrack = cms.bool( True ), - useSCRefs = cms.bool( True ), - trackProducer = cms.InputTag( "hltIter2MergedForElectrons" ), - egTrkIsoStripBarrel = cms.double( 0.03 ), - electronProducer = cms.InputTag( "hltEgammaGsfElectrons" ), - egTrkIsoConeSize = cms.double( 0.3 ), - egTrkIsoRSpan = cms.double( 999999.0 ), - egTrkIsoVetoConeSizeEndcap = cms.double( 0.03 ), - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - beamSpotProducer = cms.InputTag( "hltOnlineBeamSpot" ), - egTrkIsoPtMin = cms.double( 1.0 ), - egTrkIsoZSpan = cms.double( 0.15 ) -) -process.hltEle27WP75GsfTrackIsoFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( True ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( -1.0 ), - thrOverEEE = cms.double( 0.05 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.05 ), - thrRegularEB = cms.double( -1.0 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaEleGsfTrackIso" ), - candTag = cms.InputTag( "hltEle27WP75GsfDphiFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltL1sL1SingleMu16ORSingleMu25 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleMu16 OR L1_SingleMu25" ), - saveTags = cms.bool( True ), - L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), - L1UseL1TriggerObjectMaps = cms.bool( True ), - L1UseAliasesForSeeding = cms.bool( True ), - L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), - L1CollectionsTag = cms.InputTag( "hltL1extraParticles" ), - L1NrBxInEvent = cms.int32( 3 ), - L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), - L1TechTriggerSeeding = cms.bool( False ) -) -process.hltPreMu50 = cms.EDFilter( "HLTPrescaler", - L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), - offset = cms.uint32( 0 ) -) -process.hltL1fL1sMu16orMu25L1Filtered0 = cms.EDFilter( "HLTMuonL1Filter", - saveTags = cms.bool( False ), - CSCTFtag = cms.InputTag( "unused" ), - PreviousCandTag = cms.InputTag( "hltL1sL1SingleMu16ORSingleMu25" ), - MinPt = cms.double( 0.0 ), - MinN = cms.int32( 1 ), - MaxEta = cms.double( 2.5 ), - SelectQualities = cms.vint32( ), - CandTag = cms.InputTag( "hltL1extraParticles" ), - ExcludeSingleSegmentCSC = cms.bool( False ) -) -process.hltMuonDTDigis = cms.EDProducer( "DTUnpackingModule", - useStandardFEDid = cms.bool( True ), - maxFEDid = cms.untracked.int32( 779 ), - inputLabel = cms.InputTag( "rawDataCollector" ), - minFEDid = cms.untracked.int32( 770 ), - dataType = cms.string( "DDU" ), - readOutParameters = cms.PSet( - debug = cms.untracked.bool( False ), - rosParameters = cms.PSet( - writeSC = cms.untracked.bool( True ), - readingDDU = cms.untracked.bool( True ), - performDataIntegrityMonitor = cms.untracked.bool( False ), - readDDUIDfromDDU = cms.untracked.bool( True ), - debug = cms.untracked.bool( False ), - localDAQ = cms.untracked.bool( False ) - ), - localDAQ = cms.untracked.bool( False ), - performDataIntegrityMonitor = cms.untracked.bool( False ) - ), - dqmOnly = cms.bool( False ) -) -process.hltDt1DRecHits = cms.EDProducer( "DTRecHitProducer", - debug = cms.untracked.bool( False ), - recAlgoConfig = cms.PSet( - tTrigMode = cms.string( "DTTTrigSyncFromDB" ), - minTime = cms.double( -3.0 ), - stepTwoFromDigi = cms.bool( False ), - doVdriftCorr = cms.bool( True ), - debug = cms.untracked.bool( False ), - maxTime = cms.double( 420.0 ), - tTrigModeConfig = cms.PSet( - vPropWire = cms.double( 24.4 ), - doTOFCorrection = cms.bool( True ), - tofCorrType = cms.int32( 0 ), - wirePropCorrType = cms.int32( 0 ), - tTrigLabel = cms.string( "" ), - doWirePropCorrection = cms.bool( True ), - doT0Correction = cms.bool( True ), - debug = cms.untracked.bool( False ) - ), - useUncertDB = cms.bool( True ) - ), - dtDigiLabel = cms.InputTag( "hltMuonDTDigis" ), - recAlgo = cms.string( "DTLinearDriftFromDBAlgo" ) -) -process.hltDt4DSegments = cms.EDProducer( "DTRecSegment4DProducer", - debug = cms.untracked.bool( False ), - Reco4DAlgoName = cms.string( "DTCombinatorialPatternReco4D" ), - recHits2DLabel = cms.InputTag( "dt2DSegments" ), - recHits1DLabel = cms.InputTag( "hltDt1DRecHits" ), - Reco4DAlgoConfig = cms.PSet( - segmCleanerMode = cms.int32( 2 ), - Reco2DAlgoName = cms.string( "DTCombinatorialPatternReco" ), - recAlgoConfig = cms.PSet( - tTrigMode = cms.string( "DTTTrigSyncFromDB" ), - minTime = cms.double( -3.0 ), - stepTwoFromDigi = cms.bool( False ), - doVdriftCorr = cms.bool( True ), - debug = cms.untracked.bool( False ), - maxTime = cms.double( 420.0 ), - tTrigModeConfig = cms.PSet( - vPropWire = cms.double( 24.4 ), - doTOFCorrection = cms.bool( True ), - tofCorrType = cms.int32( 0 ), - wirePropCorrType = cms.int32( 0 ), - tTrigLabel = cms.string( "" ), - doWirePropCorrection = cms.bool( True ), - doT0Correction = cms.bool( True ), - debug = cms.untracked.bool( False ) - ), - useUncertDB = cms.bool( True ) - ), - nSharedHitsMax = cms.int32( 2 ), - hit_afterT0_resolution = cms.double( 0.03 ), - Reco2DAlgoConfig = cms.PSet( - segmCleanerMode = cms.int32( 2 ), - recAlgoConfig = cms.PSet( - tTrigMode = cms.string( "DTTTrigSyncFromDB" ), - minTime = cms.double( -3.0 ), - stepTwoFromDigi = cms.bool( False ), - doVdriftCorr = cms.bool( True ), - debug = cms.untracked.bool( False ), - maxTime = cms.double( 420.0 ), - tTrigModeConfig = cms.PSet( - vPropWire = cms.double( 24.4 ), - doTOFCorrection = cms.bool( True ), - tofCorrType = cms.int32( 0 ), - wirePropCorrType = cms.int32( 0 ), - tTrigLabel = cms.string( "" ), - doWirePropCorrection = cms.bool( True ), - doT0Correction = cms.bool( True ), - debug = cms.untracked.bool( False ) - ), - useUncertDB = cms.bool( True ) - ), - nSharedHitsMax = cms.int32( 2 ), - AlphaMaxPhi = cms.double( 1.0 ), - hit_afterT0_resolution = cms.double( 0.03 ), - MaxAllowedHits = cms.uint32( 50 ), - performT0_vdriftSegCorrection = cms.bool( False ), - AlphaMaxTheta = cms.double( 0.9 ), - debug = cms.untracked.bool( False ), - recAlgo = cms.string( "DTLinearDriftFromDBAlgo" ), - nUnSharedHitsMin = cms.int32( 2 ), - performT0SegCorrection = cms.bool( False ), - perform_delta_rejecting = cms.bool( False ) - ), - performT0_vdriftSegCorrection = cms.bool( False ), - debug = cms.untracked.bool( False ), - recAlgo = cms.string( "DTLinearDriftFromDBAlgo" ), - nUnSharedHitsMin = cms.int32( 2 ), - AllDTRecHits = cms.bool( True ), - performT0SegCorrection = cms.bool( False ), - perform_delta_rejecting = cms.bool( False ) - ) -) -process.hltMuonCSCDigis = cms.EDProducer( "CSCDCCUnpacker", - PrintEventNumber = cms.untracked.bool( False ), - SuppressZeroLCT = cms.untracked.bool( True ), - UseExaminer = cms.bool( True ), - Debug = cms.untracked.bool( False ), - ErrorMask = cms.uint32( 0x0 ), - InputObjects = cms.InputTag( "rawDataCollector" ), - ExaminerMask = cms.uint32( 0x1febf3f6 ), - runDQM = cms.untracked.bool( False ), - UnpackStatusDigis = cms.bool( False ), - VisualFEDInspect = cms.untracked.bool( False ), - FormatedEventDump = cms.untracked.bool( False ), - UseFormatStatus = cms.bool( True ), - UseSelectiveUnpacking = cms.bool( True ), - VisualFEDShort = cms.untracked.bool( False ) -) -process.hltCsc2DRecHits = cms.EDProducer( "CSCRecHitDProducer", - XTasymmetry_ME1b = cms.double( 0.0 ), - XTasymmetry_ME1a = cms.double( 0.0 ), - ConstSyst_ME1a = cms.double( 0.022 ), - ConstSyst_ME1b = cms.double( 0.007 ), - XTasymmetry_ME41 = cms.double( 0.0 ), - CSCStripxtalksOffset = cms.double( 0.03 ), - CSCUseCalibrations = cms.bool( True ), - CSCUseTimingCorrections = cms.bool( True ), - CSCNoOfTimeBinsForDynamicPedestal = cms.int32( 2 ), - XTasymmetry_ME22 = cms.double( 0.0 ), - UseFivePoleFit = cms.bool( True ), - XTasymmetry_ME21 = cms.double( 0.0 ), - ConstSyst_ME21 = cms.double( 0.0 ), - CSCDebug = cms.untracked.bool( False ), - ConstSyst_ME22 = cms.double( 0.0 ), - CSCUseGasGainCorrections = cms.bool( False ), - XTasymmetry_ME31 = cms.double( 0.0 ), - readBadChambers = cms.bool( True ), - NoiseLevel_ME13 = cms.double( 8.0 ), - NoiseLevel_ME12 = cms.double( 9.0 ), - NoiseLevel_ME32 = cms.double( 9.0 ), - NoiseLevel_ME31 = cms.double( 9.0 ), - XTasymmetry_ME32 = cms.double( 0.0 ), - ConstSyst_ME41 = cms.double( 0.0 ), - CSCStripClusterSize = cms.untracked.int32( 3 ), - CSCStripClusterChargeCut = cms.double( 25.0 ), - CSCStripPeakThreshold = cms.double( 10.0 ), - readBadChannels = cms.bool( False ), - UseParabolaFit = cms.bool( False ), - XTasymmetry_ME13 = cms.double( 0.0 ), - XTasymmetry_ME12 = cms.double( 0.0 ), - wireDigiTag = cms.InputTag( 'hltMuonCSCDigis','MuonCSCWireDigi' ), - ConstSyst_ME12 = cms.double( 0.0 ), - ConstSyst_ME13 = cms.double( 0.0 ), - ConstSyst_ME32 = cms.double( 0.0 ), - ConstSyst_ME31 = cms.double( 0.0 ), - UseAverageTime = cms.bool( False ), - NoiseLevel_ME1a = cms.double( 7.0 ), - NoiseLevel_ME1b = cms.double( 8.0 ), - CSCWireClusterDeltaT = cms.int32( 1 ), - CSCUseStaticPedestals = cms.bool( False ), - stripDigiTag = cms.InputTag( 'hltMuonCSCDigis','MuonCSCStripDigi' ), - CSCstripWireDeltaTime = cms.int32( 8 ), - NoiseLevel_ME21 = cms.double( 9.0 ), - NoiseLevel_ME22 = cms.double( 9.0 ), - NoiseLevel_ME41 = cms.double( 9.0 ) -) -process.hltCscSegments = cms.EDProducer( "CSCSegmentProducer", - inputObjects = cms.InputTag( "hltCsc2DRecHits" ), - algo_psets = cms.VPSet( - cms.PSet( chamber_types = cms.vstring( 'ME1/a', - 'ME1/b', - 'ME1/2', - 'ME1/3', - 'ME2/1', - 'ME2/2', - 'ME3/1', - 'ME3/2', - 'ME4/1', - 'ME4/2' ), - algo_name = cms.string( "CSCSegAlgoST" ), - parameters_per_chamber_type = cms.vint32( 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 ), - algo_psets = cms.VPSet( - cms.PSet( maxRatioResidualPrune = cms.double( 3.0 ), - yweightPenalty = cms.double( 1.5 ), - maxRecHitsInCluster = cms.int32( 20 ), - dPhiFineMax = cms.double( 0.025 ), - preClusteringUseChaining = cms.bool( True ), - ForceCovariance = cms.bool( False ), - hitDropLimit6Hits = cms.double( 0.3333 ), - NormChi2Cut2D = cms.double( 20.0 ), - BPMinImprovement = cms.double( 10000.0 ), - Covariance = cms.double( 0.0 ), - tanPhiMax = cms.double( 0.5 ), - SeedBig = cms.double( 0.0015 ), - onlyBestSegment = cms.bool( False ), - dRPhiFineMax = cms.double( 8.0 ), - SeedSmall = cms.double( 2.0E-4 ), - curvePenalty = cms.double( 2.0 ), - dXclusBoxMax = cms.double( 4.0 ), - BrutePruning = cms.bool( True ), - curvePenaltyThreshold = cms.double( 0.85 ), - CorrectTheErrors = cms.bool( True ), - hitDropLimit4Hits = cms.double( 0.6 ), - useShowering = cms.bool( False ), - CSCDebug = cms.untracked.bool( False ), - tanThetaMax = cms.double( 1.2 ), - NormChi2Cut3D = cms.double( 10.0 ), - minHitsPerSegment = cms.int32( 3 ), - ForceCovarianceAll = cms.bool( False ), - yweightPenaltyThreshold = cms.double( 1.0 ), - prePrunLimit = cms.double( 3.17 ), - hitDropLimit5Hits = cms.double( 0.8 ), - preClustering = cms.bool( True ), - prePrun = cms.bool( True ), - maxDPhi = cms.double( 999.0 ), - maxDTheta = cms.double( 999.0 ), - Pruning = cms.bool( True ), - dYclusBoxMax = cms.double( 8.0 ) - ), - cms.PSet( maxRatioResidualPrune = cms.double( 3.0 ), - yweightPenalty = cms.double( 1.5 ), - maxRecHitsInCluster = cms.int32( 24 ), - dPhiFineMax = cms.double( 0.025 ), - preClusteringUseChaining = cms.bool( True ), - ForceCovariance = cms.bool( False ), - hitDropLimit6Hits = cms.double( 0.3333 ), - NormChi2Cut2D = cms.double( 20.0 ), - BPMinImprovement = cms.double( 10000.0 ), - Covariance = cms.double( 0.0 ), - tanPhiMax = cms.double( 0.5 ), - SeedBig = cms.double( 0.0015 ), - onlyBestSegment = cms.bool( False ), - dRPhiFineMax = cms.double( 8.0 ), - SeedSmall = cms.double( 2.0E-4 ), - curvePenalty = cms.double( 2.0 ), - dXclusBoxMax = cms.double( 4.0 ), - BrutePruning = cms.bool( True ), - curvePenaltyThreshold = cms.double( 0.85 ), - CorrectTheErrors = cms.bool( True ), - hitDropLimit4Hits = cms.double( 0.6 ), - useShowering = cms.bool( False ), - CSCDebug = cms.untracked.bool( False ), - tanThetaMax = cms.double( 1.2 ), - NormChi2Cut3D = cms.double( 10.0 ), - minHitsPerSegment = cms.int32( 3 ), - ForceCovarianceAll = cms.bool( False ), - yweightPenaltyThreshold = cms.double( 1.0 ), - prePrunLimit = cms.double( 3.17 ), - hitDropLimit5Hits = cms.double( 0.8 ), - preClustering = cms.bool( True ), - prePrun = cms.bool( True ), - maxDPhi = cms.double( 999.0 ), - maxDTheta = cms.double( 999.0 ), - Pruning = cms.bool( True ), - dYclusBoxMax = cms.double( 8.0 ) - ) - ) - ) - ), - algo_type = cms.int32( 1 ) -) -process.hltMuonRPCDigis = cms.EDProducer( "RPCUnpackingModule", - InputLabel = cms.InputTag( "rawDataCollector" ), - doSynchro = cms.bool( False ) -) -process.hltRpcRecHits = cms.EDProducer( "RPCRecHitProducer", - recAlgoConfig = cms.PSet( ), - deadvecfile = cms.FileInPath( "RecoLocalMuon/RPCRecHit/data/RPCDeadVec.dat" ), - rpcDigiLabel = cms.InputTag( "hltMuonRPCDigis" ), - maskvecfile = cms.FileInPath( "RecoLocalMuon/RPCRecHit/data/RPCMaskVec.dat" ), - recAlgo = cms.string( "RPCRecHitStandardAlgo" ), - deadSource = cms.string( "File" ), - maskSource = cms.string( "File" ) -) -process.hltL2OfflineMuonSeeds = cms.EDProducer( "MuonSeedGenerator", - SMB_21 = cms.vdouble( 1.043, -0.124, 0.0, 0.183, 0.0, 0.0 ), - SMB_20 = cms.vdouble( 1.011, -0.052, 0.0, 0.188, 0.0, 0.0 ), - SMB_22 = cms.vdouble( 1.474, -0.758, 0.0, 0.185, 0.0, 0.0 ), - OL_2213 = cms.vdouble( 0.117, 0.0, 0.0, 0.044, 0.0, 0.0 ), - SME_11 = cms.vdouble( 3.295, -1.527, 0.112, 0.378, 0.02, 0.0 ), - SME_13 = cms.vdouble( -1.286, 1.711, 0.0, 0.356, 0.0, 0.0 ), - SME_12 = cms.vdouble( 0.102, 0.599, 0.0, 0.38, 0.0, 0.0 ), - DT_34_2_scale = cms.vdouble( -11.901897, 0.0 ), - OL_1213_0_scale = cms.vdouble( -4.488158, 0.0 ), - OL_1222_0_scale = cms.vdouble( -5.810449, 0.0 ), - DT_13 = cms.vdouble( 0.315, 0.068, -0.127, 0.051, -0.002, 0.0 ), - DT_12 = cms.vdouble( 0.183, 0.054, -0.087, 0.028, 0.002, 0.0 ), - DT_14 = cms.vdouble( 0.359, 0.052, -0.107, 0.072, -0.004, 0.0 ), - CSC_13_3_scale = cms.vdouble( -1.701268, 0.0 ), - DT_24_2_scale = cms.vdouble( -6.63094, 0.0 ), - CSC_23 = cms.vdouble( -0.081, 0.113, -0.029, 0.015, 0.008, 0.0 ), - CSC_24 = cms.vdouble( 0.004, 0.021, -0.002, 0.053, 0.0, 0.0 ), - OL_2222 = cms.vdouble( 0.107, 0.0, 0.0, 0.04, 0.0, 0.0 ), - DT_14_2_scale = cms.vdouble( -4.808546, 0.0 ), - SMB_10 = cms.vdouble( 1.387, -0.038, 0.0, 0.19, 0.0, 0.0 ), - SMB_11 = cms.vdouble( 1.247, 0.72, -0.802, 0.229, -0.075, 0.0 ), - SMB_12 = cms.vdouble( 2.128, -0.956, 0.0, 0.199, 0.0, 0.0 ), - SME_21 = cms.vdouble( -0.529, 1.194, -0.358, 0.472, 0.086, 0.0 ), - SME_22 = cms.vdouble( -1.207, 1.491, -0.251, 0.189, 0.243, 0.0 ), - DT_13_2_scale = cms.vdouble( -4.257687, 0.0 ), - CSC_34 = cms.vdouble( 0.062, -0.067, 0.019, 0.021, 0.003, 0.0 ), - SME_22_0_scale = cms.vdouble( -3.457901, 0.0 ), - DT_24_1_scale = cms.vdouble( -7.490909, 0.0 ), - OL_1232_0_scale = cms.vdouble( -5.964634, 0.0 ), - DT_23_1_scale = cms.vdouble( -5.320346, 0.0 ), - SME_13_0_scale = cms.vdouble( 0.104905, 0.0 ), - SMB_22_0_scale = cms.vdouble( 1.346681, 0.0 ), - CSC_12_1_scale = cms.vdouble( -6.434242, 0.0 ), - DT_34 = cms.vdouble( 0.044, 0.004, -0.013, 0.029, 0.003, 0.0 ), - SME_32 = cms.vdouble( -0.901, 1.333, -0.47, 0.41, 0.073, 0.0 ), - SME_31 = cms.vdouble( -1.594, 1.482, -0.317, 0.487, 0.097, 0.0 ), - CSC_13_2_scale = cms.vdouble( -6.077936, 0.0 ), - crackEtas = cms.vdouble( 0.2, 1.6, 1.7 ), - SME_11_0_scale = cms.vdouble( 1.325085, 0.0 ), - SMB_20_0_scale = cms.vdouble( 1.486168, 0.0 ), - DT_13_1_scale = cms.vdouble( -4.520923, 0.0 ), - CSC_24_1_scale = cms.vdouble( -6.055701, 0.0 ), - CSC_01_1_scale = cms.vdouble( -1.915329, 0.0 ), - DT_23 = cms.vdouble( 0.13, 0.023, -0.057, 0.028, 0.004, 0.0 ), - DT_24 = cms.vdouble( 0.176, 0.014, -0.051, 0.051, 0.003, 0.0 ), - SMB_12_0_scale = cms.vdouble( 2.283221, 0.0 ), - deltaPhiSearchWindow = cms.double( 0.25 ), - SMB_30_0_scale = cms.vdouble( -3.629838, 0.0 ), - SME_42 = cms.vdouble( -0.003, 0.005, 0.005, 0.608, 0.076, 0.0 ), - SME_41 = cms.vdouble( -0.003, 0.005, 0.005, 0.608, 0.076, 0.0 ), - deltaEtaSearchWindow = cms.double( 0.2 ), - CSC_12_2_scale = cms.vdouble( -1.63622, 0.0 ), - DT_34_1_scale = cms.vdouble( -13.783765, 0.0 ), - CSC_34_1_scale = cms.vdouble( -11.520507, 0.0 ), - OL_2213_0_scale = cms.vdouble( -7.239789, 0.0 ), - SMB_32_0_scale = cms.vdouble( -3.054156, 0.0 ), - CSC_12_3_scale = cms.vdouble( -1.63622, 0.0 ), - deltaEtaCrackSearchWindow = cms.double( 0.25 ), - SME_21_0_scale = cms.vdouble( -0.040862, 0.0 ), - OL_1232 = cms.vdouble( 0.184, 0.0, 0.0, 0.066, 0.0, 0.0 ), - DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), - SMB_10_0_scale = cms.vdouble( 2.448566, 0.0 ), - EnableDTMeasurement = cms.bool( True ), - CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), - CSC_23_2_scale = cms.vdouble( -6.079917, 0.0 ), - scaleDT = cms.bool( True ), - DT_12_2_scale = cms.vdouble( -3.518165, 0.0 ), - OL_1222 = cms.vdouble( 0.848, -0.591, 0.0, 0.062, 0.0, 0.0 ), - CSC_23_1_scale = cms.vdouble( -19.084285, 0.0 ), - OL_1213 = cms.vdouble( 0.96, -0.737, 0.0, 0.052, 0.0, 0.0 ), - CSC_02 = cms.vdouble( 0.612, -0.207, 0.0, 0.067, -0.001, 0.0 ), - CSC_03 = cms.vdouble( 0.787, -0.338, 0.029, 0.101, -0.008, 0.0 ), - CSC_01 = cms.vdouble( 0.166, 0.0, 0.0, 0.031, 0.0, 0.0 ), - SMB_32 = cms.vdouble( 0.67, -0.327, 0.0, 0.22, 0.0, 0.0 ), - SMB_30 = cms.vdouble( 0.505, -0.022, 0.0, 0.215, 0.0, 0.0 ), - SMB_31 = cms.vdouble( 0.549, -0.145, 0.0, 0.207, 0.0, 0.0 ), - crackWindow = cms.double( 0.04 ), - CSC_14_3_scale = cms.vdouble( -1.969563, 0.0 ), - SMB_31_0_scale = cms.vdouble( -3.323768, 0.0 ), - DT_12_1_scale = cms.vdouble( -3.692398, 0.0 ), - SMB_21_0_scale = cms.vdouble( 1.58384, 0.0 ), - DT_23_2_scale = cms.vdouble( -5.117625, 0.0 ), - SME_12_0_scale = cms.vdouble( 2.279181, 0.0 ), - DT_14_1_scale = cms.vdouble( -5.644816, 0.0 ), - beamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), - SMB_11_0_scale = cms.vdouble( 2.56363, 0.0 ), - EnableCSCMeasurement = cms.bool( True ), - CSC_14 = cms.vdouble( 0.606, -0.181, -0.002, 0.111, -0.003, 0.0 ), - OL_2222_0_scale = cms.vdouble( -7.667231, 0.0 ), - CSC_13 = cms.vdouble( 0.901, -1.302, 0.533, 0.045, 0.005, 0.0 ), - CSC_12 = cms.vdouble( -0.161, 0.254, -0.047, 0.042, -0.007, 0.0 ) -) -process.hltL2MuonSeeds = cms.EDProducer( "L2MuonSeedGenerator", - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'SteppingHelixPropagatorAny' ), - RPCLayers = cms.bool( True ), - UseMuonNavigation = cms.untracked.bool( True ) - ), - InputObjects = cms.InputTag( "hltL1extraParticles" ), - L1MaxEta = cms.double( 2.5 ), - OfflineSeedLabel = cms.untracked.InputTag( "hltL2OfflineMuonSeeds" ), - L1MinPt = cms.double( 0.0 ), - L1MinQuality = cms.uint32( 1 ), - GMTReadoutCollection = cms.InputTag( "hltGtDigis" ), - UseUnassociatedL1 = cms.bool( False ), - UseOfflineSeed = cms.untracked.bool( True ), - Propagator = cms.string( "SteppingHelixPropagatorAny" ) -) -process.hltL2Muons = cms.EDProducer( "L2MuonProducer", - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPFastSteppingHelixPropagatorAny', - 'hltESPFastSteppingHelixPropagatorOpposite' ), - RPCLayers = cms.bool( True ), - UseMuonNavigation = cms.untracked.bool( True ) - ), - InputObjects = cms.InputTag( "hltL2MuonSeeds" ), - SeedTransformerParameters = cms.PSet( - Fitter = cms.string( "hltESPKFFittingSmootherForL2Muon" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - NMinRecHits = cms.uint32( 2 ), - UseSubRecHits = cms.bool( False ), - Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - RescaleError = cms.double( 100.0 ) - ), - L2TrajBuilderParameters = cms.PSet( - DoRefit = cms.bool( False ), - SeedPropagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - FilterParameters = cms.PSet( - NumberOfSigma = cms.double( 3.0 ), - FitDirection = cms.string( "insideOut" ), - DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), - MaxChi2 = cms.double( 1000.0 ), - MuonTrajectoryUpdatorParameters = cms.PSet( - MaxChi2 = cms.double( 25.0 ), - RescaleErrorFactor = cms.double( 100.0 ), - Granularity = cms.int32( 0 ), - ExcludeRPCFromFit = cms.bool( False ), - UseInvalidHits = cms.bool( True ), - RescaleError = cms.bool( False ) - ), - EnableRPCMeasurement = cms.bool( True ), - CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), - EnableDTMeasurement = cms.bool( True ), - RPCRecSegmentLabel = cms.InputTag( "hltRpcRecHits" ), - Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - EnableCSCMeasurement = cms.bool( True ) - ), - NavigationType = cms.string( "Standard" ), - SeedTransformerParameters = cms.PSet( - Fitter = cms.string( "hltESPKFFittingSmootherForL2Muon" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - NMinRecHits = cms.uint32( 2 ), - UseSubRecHits = cms.bool( False ), - Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - RescaleError = cms.double( 100.0 ) - ), - DoBackwardFilter = cms.bool( True ), - SeedPosition = cms.string( "in" ), - BWFilterParameters = cms.PSet( - NumberOfSigma = cms.double( 3.0 ), - CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), - FitDirection = cms.string( "outsideIn" ), - DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), - MaxChi2 = cms.double( 100.0 ), - MuonTrajectoryUpdatorParameters = cms.PSet( - MaxChi2 = cms.double( 25.0 ), - RescaleErrorFactor = cms.double( 100.0 ), - Granularity = cms.int32( 0 ), - ExcludeRPCFromFit = cms.bool( False ), - UseInvalidHits = cms.bool( True ), - RescaleError = cms.bool( False ) - ), - EnableRPCMeasurement = cms.bool( True ), - BWSeedType = cms.string( "fromGenerator" ), - EnableDTMeasurement = cms.bool( True ), - RPCRecSegmentLabel = cms.InputTag( "hltRpcRecHits" ), - Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - EnableCSCMeasurement = cms.bool( True ) - ), - DoSeedRefit = cms.bool( False ) - ), - DoSeedRefit = cms.bool( False ), - TrackLoaderParameters = cms.PSet( - Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), - DoSmoothing = cms.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MuonUpdatorAtVertexParameters = cms.PSet( - MaxChi2 = cms.double( 1000000.0 ), - BeamSpotPosition = cms.vdouble( 0.0, 0.0, 0.0 ), - Propagator = cms.string( "hltESPFastSteppingHelixPropagatorOpposite" ), - BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) - ), - VertexConstraint = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - MuonTrajectoryBuilder = cms.string( "Exhaustive" ) -) -process.hltL2MuonCandidates = cms.EDProducer( "L2MuonCandidateProducer", - InputObjects = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) -) -process.hltL2fL1sMu16orMu25L1f0L2Filtered16Q = cms.EDFilter( "HLTMuonL2PreFilter", - saveTags = cms.bool( True ), - MaxDr = cms.double( 9999.0 ), - CutOnChambers = cms.bool( False ), - PreviousCandTag = cms.InputTag( "hltL1fL1sMu16orMu25L1Filtered0" ), - MinPt = cms.double( 16.0 ), - MinN = cms.int32( 1 ), - SeedMapTag = cms.InputTag( "hltL2Muons" ), - MaxEta = cms.double( 2.5 ), - MinNhits = cms.vint32( 0, 1, 0, 1 ), - MinDxySig = cms.double( -1.0 ), - MinNchambers = cms.vint32( 0 ), - AbsEtaBins = cms.vdouble( 0.9, 1.5, 2.1, 5.0 ), - MaxDz = cms.double( 9999.0 ), - CandTag = cms.InputTag( "hltL2MuonCandidates" ), - BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), - MinDr = cms.double( -1.0 ), - NSigmaPt = cms.double( 0.0 ), - MinNstations = cms.vint32( 0, 2, 0, 2 ) -) -process.hltL3TrajSeedOIState = cms.EDProducer( "TSGFromL2Muon", - TkSeedGenerator = cms.PSet( - propagatorCompatibleName = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), - option = cms.uint32( 3 ), - maxChi2 = cms.double( 40.0 ), - errorMatrixPset = cms.PSet( - atIP = cms.bool( True ), - action = cms.string( "use" ), - errorMatrixValuesPSet = cms.PSet( - pf3_V12 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V13 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V11 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - pf3_V14 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V15 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), - pf3_V33 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - zAxis = cms.vdouble( -3.14159, 3.14159 ), - pf3_V44 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), - pf3_V22 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - pf3_V23 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V45 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V55 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - pf3_V34 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V35 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V25 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V24 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ) - ) - ), - propagatorName = cms.string( "hltESPSteppingHelixPropagatorAlong" ), - manySeeds = cms.bool( False ), - copyMuonRecHit = cms.bool( False ), - ComponentName = cms.string( "TSGForRoadSearch" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ) - ), - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPSteppingHelixPropagatorOpposite', - 'hltESPSteppingHelixPropagatorAlong' ), - RPCLayers = cms.bool( True ), - UseMuonNavigation = cms.untracked.bool( True ) - ), - MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), - MuonTrackingRegionBuilder = cms.PSet( ), - PCut = cms.double( 2.5 ), - TrackerSeedCleaner = cms.PSet( ), - PtCut = cms.double( 1.0 ) -) -process.hltL3TrackCandidateFromL2OIState = cms.EDProducer( "CkfTrajectoryMaker", - src = cms.InputTag( "hltL3TrajSeedOIState" ), - reverseTrajectories = cms.bool( True ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - trackCandidateAlso = cms.bool( True ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilderSeedHit" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "hltESPMuonCkfTrajectoryBuilderSeedHit" ), - maxNSeeds = cms.uint32( 100000 ) -) -process.hltL3TkTracksFromL2OIState = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltL3TrackCandidateFromL2OIState" ), - SimpleMagneticField = cms.string( "" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPKFFittingSmoother" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( False ), - Propagator = cms.string( "PropagatorWithMaterial" ) -) -process.hltL3MuonsOIState = cms.EDProducer( "L3MuonProducer", - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', - 'SteppingHelixPropagatorAny', - 'hltESPSmartPropagator', - 'hltESPSteppingHelixPropagatorOpposite' ), - RPCLayers = cms.bool( True ), - UseMuonNavigation = cms.untracked.bool( True ) - ), - L3TrajBuilderParameters = cms.PSet( - ScaleTECyFactor = cms.double( -1.0 ), - GlbRefitterParameters = cms.PSet( - TrackerSkipSection = cms.int32( -1 ), - DoPredictionsOnly = cms.bool( False ), - PropDirForCosmics = cms.bool( False ), - HitThreshold = cms.int32( 1 ), - MuonHitsOption = cms.int32( 1 ), - Chi2CutRPC = cms.double( 1.0 ), - Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), - DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - RefitDirection = cms.string( "insideOut" ), - CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), - Chi2CutCSC = cms.double( 150.0 ), - Chi2CutDT = cms.double( 10.0 ), - RefitRPCHits = cms.bool( True ), - SkipStation = cms.int32( -1 ), - Propagator = cms.string( "hltESPSmartPropagatorAny" ), - TrackerSkipSystem = cms.int32( -1 ), - DYTthrs = cms.vint32( 30, 15 ) - ), - ScaleTECxFactor = cms.double( -1.0 ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - MuonTrackingRegionBuilder = cms.PSet( - EtaR_UpperLimit_Par1 = cms.double( 0.25 ), - EtaR_UpperLimit_Par2 = cms.double( 0.15 ), - OnDemand = cms.double( -1.0 ), - Rescale_Dz = cms.double( 3.0 ), - vertexCollection = cms.InputTag( "pixelVertices" ), - Rescale_phi = cms.double( 3.0 ), - Eta_fixed = cms.double( 0.2 ), - DeltaZ_Region = cms.double( 15.9 ), - MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - PhiR_UpperLimit_Par2 = cms.double( 0.2 ), - Eta_min = cms.double( 0.05 ), - Phi_fixed = cms.double( 0.2 ), - DeltaR = cms.double( 0.2 ), - EscapePt = cms.double( 1.5 ), - UseFixedRegion = cms.bool( False ), - PhiR_UpperLimit_Par1 = cms.double( 0.6 ), - Rescale_eta = cms.double( 3.0 ), - Phi_min = cms.double( 0.05 ), - UseVertex = cms.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) - ), - RefitRPCHits = cms.bool( True ), - PCut = cms.double( 2.5 ), - TrackTransformer = cms.PSet( - DoPredictionsOnly = cms.bool( False ), - Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - RefitDirection = cms.string( "insideOut" ), - RefitRPCHits = cms.bool( True ), - Propagator = cms.string( "hltESPSmartPropagatorAny" ) - ), - GlobalMuonTrackMatcher = cms.PSet( - Pt_threshold1 = cms.double( 0.0 ), - DeltaDCut_3 = cms.double( 15.0 ), - MinP = cms.double( 2.5 ), - MinPt = cms.double( 1.0 ), - Chi2Cut_1 = cms.double( 50.0 ), - Pt_threshold2 = cms.double( 9.99999999E8 ), - LocChi2Cut = cms.double( 0.001 ), - Eta_threshold = cms.double( 1.2 ), - Quality_3 = cms.double( 7.0 ), - Quality_2 = cms.double( 15.0 ), - Chi2Cut_2 = cms.double( 50.0 ), - Chi2Cut_3 = cms.double( 200.0 ), - DeltaDCut_1 = cms.double( 40.0 ), - DeltaRCut_2 = cms.double( 0.2 ), - DeltaRCut_3 = cms.double( 1.0 ), - DeltaDCut_2 = cms.double( 10.0 ), - DeltaRCut_1 = cms.double( 0.1 ), - Propagator = cms.string( "hltESPSmartPropagator" ), - Quality_1 = cms.double( 20.0 ) - ), - PtCut = cms.double( 1.0 ), - TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), - tkTrajLabel = cms.InputTag( "hltL3TkTracksFromL2OIState" ), - tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - tkTrajMaxChi2 = cms.double( 9999.0 ), - tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), - tkTrajVertex = cms.InputTag( "pixelVertices" ), - tkTrajUseVertex = cms.bool( False ) - ), - TrackLoaderParameters = cms.PSet( - PutTkTrackIntoEvent = cms.untracked.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - SmoothTkTrack = cms.untracked.bool( False ), - MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), - Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), - MuonUpdatorAtVertexParameters = cms.PSet( - MaxChi2 = cms.double( 1000000.0 ), - Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), - BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) - ), - VertexConstraint = cms.bool( False ), - DoSmoothing = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) -) -process.hltL3TrajSeedOIHit = cms.EDProducer( "TSGFromL2Muon", - TkSeedGenerator = cms.PSet( - PSetNames = cms.vstring( 'skipTSG', - 'iterativeTSG' ), - L3TkCollectionA = cms.InputTag( "hltL3MuonsOIState" ), - iterativeTSG = cms.PSet( - ErrorRescaling = cms.double( 3.0 ), - beamSpot = cms.InputTag( "unused" ), - MaxChi2 = cms.double( 40.0 ), - errorMatrixPset = cms.PSet( - atIP = cms.bool( True ), - action = cms.string( "use" ), - errorMatrixValuesPSet = cms.PSet( - pf3_V12 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V13 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V11 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - pf3_V14 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V15 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), - pf3_V33 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - zAxis = cms.vdouble( -3.14159, 3.14159 ), - pf3_V44 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), - pf3_V22 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - pf3_V23 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V45 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V55 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) - ), - pf3_V34 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V35 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V25 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ), - pf3_V24 = cms.PSet( - action = cms.string( "scale" ), - values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) - ) - ) - ), - UpdateState = cms.bool( True ), - MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - SelectState = cms.bool( False ), - SigmaZ = cms.double( 25.0 ), - ResetMethod = cms.string( "matrix" ), - ComponentName = cms.string( "TSGFromPropagation" ), - UseVertexState = cms.bool( True ), - Propagator = cms.string( "hltESPSmartPropagatorAnyOpposite" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ) - ), - skipTSG = cms.PSet( ), - ComponentName = cms.string( "DualByL2TSG" ) - ), - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'PropagatorWithMaterial', - 'hltESPSmartPropagatorAnyOpposite' ), - RPCLayers = cms.bool( True ), - UseMuonNavigation = cms.untracked.bool( True ) - ), - MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), - MuonTrackingRegionBuilder = cms.PSet( ), - PCut = cms.double( 2.5 ), - TrackerSeedCleaner = cms.PSet( - cleanerFromSharedHits = cms.bool( True ), - ptCleaner = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - directionCleaner = cms.bool( True ) - ), - PtCut = cms.double( 1.0 ) -) -process.hltL3TrackCandidateFromL2OIHit = cms.EDProducer( "CkfTrajectoryMaker", - src = cms.InputTag( "hltL3TrajSeedOIHit" ), - reverseTrajectories = cms.bool( True ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - trackCandidateAlso = cms.bool( True ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "hltESPMuonCkfTrajectoryBuilder" ), - maxNSeeds = cms.uint32( 100000 ) -) -process.hltL3TkTracksFromL2OIHit = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltL3TrackCandidateFromL2OIHit" ), - SimpleMagneticField = cms.string( "" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPKFFittingSmoother" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( False ), - Propagator = cms.string( "PropagatorWithMaterial" ) -) -process.hltL3MuonsOIHit = cms.EDProducer( "L3MuonProducer", - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', - 'SteppingHelixPropagatorAny', - 'hltESPSmartPropagator', - 'hltESPSteppingHelixPropagatorOpposite' ), - RPCLayers = cms.bool( True ), - UseMuonNavigation = cms.untracked.bool( True ) - ), - L3TrajBuilderParameters = cms.PSet( - ScaleTECyFactor = cms.double( -1.0 ), - GlbRefitterParameters = cms.PSet( - TrackerSkipSection = cms.int32( -1 ), - DoPredictionsOnly = cms.bool( False ), - PropDirForCosmics = cms.bool( False ), - HitThreshold = cms.int32( 1 ), - MuonHitsOption = cms.int32( 1 ), - Chi2CutRPC = cms.double( 1.0 ), - Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), - DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - RefitDirection = cms.string( "insideOut" ), - CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), - Chi2CutCSC = cms.double( 150.0 ), - Chi2CutDT = cms.double( 10.0 ), - RefitRPCHits = cms.bool( True ), - SkipStation = cms.int32( -1 ), - Propagator = cms.string( "hltESPSmartPropagatorAny" ), - TrackerSkipSystem = cms.int32( -1 ), - DYTthrs = cms.vint32( 30, 15 ) - ), - ScaleTECxFactor = cms.double( -1.0 ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - MuonTrackingRegionBuilder = cms.PSet( - EtaR_UpperLimit_Par1 = cms.double( 0.25 ), - EtaR_UpperLimit_Par2 = cms.double( 0.15 ), - OnDemand = cms.double( -1.0 ), - Rescale_Dz = cms.double( 3.0 ), - vertexCollection = cms.InputTag( "pixelVertices" ), - Rescale_phi = cms.double( 3.0 ), - Eta_fixed = cms.double( 0.2 ), - DeltaZ_Region = cms.double( 15.9 ), - MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - PhiR_UpperLimit_Par2 = cms.double( 0.2 ), - Eta_min = cms.double( 0.05 ), - Phi_fixed = cms.double( 0.2 ), - DeltaR = cms.double( 0.2 ), - EscapePt = cms.double( 1.5 ), - UseFixedRegion = cms.bool( False ), - PhiR_UpperLimit_Par1 = cms.double( 0.6 ), - Rescale_eta = cms.double( 3.0 ), - Phi_min = cms.double( 0.05 ), - UseVertex = cms.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) - ), - RefitRPCHits = cms.bool( True ), - PCut = cms.double( 2.5 ), - TrackTransformer = cms.PSet( - DoPredictionsOnly = cms.bool( False ), - Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - RefitDirection = cms.string( "insideOut" ), - RefitRPCHits = cms.bool( True ), - Propagator = cms.string( "hltESPSmartPropagatorAny" ) - ), - GlobalMuonTrackMatcher = cms.PSet( - Pt_threshold1 = cms.double( 0.0 ), - DeltaDCut_3 = cms.double( 15.0 ), - MinP = cms.double( 2.5 ), - MinPt = cms.double( 1.0 ), - Chi2Cut_1 = cms.double( 50.0 ), - Pt_threshold2 = cms.double( 9.99999999E8 ), - LocChi2Cut = cms.double( 0.001 ), - Eta_threshold = cms.double( 1.2 ), - Quality_3 = cms.double( 7.0 ), - Quality_2 = cms.double( 15.0 ), - Chi2Cut_2 = cms.double( 50.0 ), - Chi2Cut_3 = cms.double( 200.0 ), - DeltaDCut_1 = cms.double( 40.0 ), - DeltaRCut_2 = cms.double( 0.2 ), - DeltaRCut_3 = cms.double( 1.0 ), - DeltaDCut_2 = cms.double( 10.0 ), - DeltaRCut_1 = cms.double( 0.1 ), - Propagator = cms.string( "hltESPSmartPropagator" ), - Quality_1 = cms.double( 20.0 ) - ), - PtCut = cms.double( 1.0 ), - TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), - tkTrajLabel = cms.InputTag( "hltL3TkTracksFromL2OIHit" ), - tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - tkTrajMaxChi2 = cms.double( 9999.0 ), - tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), - tkTrajVertex = cms.InputTag( "pixelVertices" ), - tkTrajUseVertex = cms.bool( False ) - ), - TrackLoaderParameters = cms.PSet( - PutTkTrackIntoEvent = cms.untracked.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - SmoothTkTrack = cms.untracked.bool( False ), - MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), - Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), - MuonUpdatorAtVertexParameters = cms.PSet( - MaxChi2 = cms.double( 1000000.0 ), - Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), - BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) - ), - VertexConstraint = cms.bool( False ), - DoSmoothing = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) -) -process.hltL3TkFromL2OICombination = cms.EDProducer( "L3TrackCombiner", - labels = cms.VInputTag( 'hltL3MuonsOIState','hltL3MuonsOIHit' ) -) -process.hltPixelLayerPairs = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2', - 'BPix1+BPix3', - 'BPix2+BPix3', - 'BPix1+FPix1_pos', - 'BPix1+FPix1_neg', - 'BPix1+FPix2_pos', - 'BPix1+FPix2_neg', - 'BPix2+FPix1_pos', - 'BPix2+FPix1_neg', - 'BPix2+FPix2_pos', - 'BPix2+FPix2_neg', - 'FPix1_pos+FPix2_pos', - 'FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - useErrorsFromParam = cms.bool( True ), - hitErrorRPhi = cms.double( 0.0051 ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - useErrorsFromParam = cms.bool( True ), - hitErrorRPhi = cms.double( 0.0027 ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ) - ), - TIB = cms.PSet( ) +process.hltCsc2DRecHits = cms.EDProducer( "CSCRecHitDProducer", + XTasymmetry_ME1b = cms.double( 0.0 ), + XTasymmetry_ME1a = cms.double( 0.0 ), + ConstSyst_ME1a = cms.double( 0.022 ), + ConstSyst_ME1b = cms.double( 0.007 ), + XTasymmetry_ME41 = cms.double( 0.0 ), + CSCStripxtalksOffset = cms.double( 0.03 ), + CSCUseCalibrations = cms.bool( True ), + CSCUseTimingCorrections = cms.bool( True ), + CSCNoOfTimeBinsForDynamicPedestal = cms.int32( 2 ), + XTasymmetry_ME22 = cms.double( 0.0 ), + UseFivePoleFit = cms.bool( True ), + XTasymmetry_ME21 = cms.double( 0.0 ), + ConstSyst_ME21 = cms.double( 0.0 ), + CSCDebug = cms.untracked.bool( False ), + ConstSyst_ME22 = cms.double( 0.0 ), + CSCUseGasGainCorrections = cms.bool( False ), + XTasymmetry_ME31 = cms.double( 0.0 ), + readBadChambers = cms.bool( True ), + NoiseLevel_ME13 = cms.double( 8.0 ), + NoiseLevel_ME12 = cms.double( 9.0 ), + NoiseLevel_ME32 = cms.double( 9.0 ), + NoiseLevel_ME31 = cms.double( 9.0 ), + XTasymmetry_ME32 = cms.double( 0.0 ), + ConstSyst_ME41 = cms.double( 0.0 ), + CSCStripClusterSize = cms.untracked.int32( 3 ), + CSCStripClusterChargeCut = cms.double( 25.0 ), + CSCStripPeakThreshold = cms.double( 10.0 ), + readBadChannels = cms.bool( False ), + UseParabolaFit = cms.bool( False ), + XTasymmetry_ME13 = cms.double( 0.0 ), + XTasymmetry_ME12 = cms.double( 0.0 ), + wireDigiTag = cms.InputTag( 'hltMuonCSCDigis','MuonCSCWireDigi' ), + ConstSyst_ME12 = cms.double( 0.0 ), + ConstSyst_ME13 = cms.double( 0.0 ), + ConstSyst_ME32 = cms.double( 0.0 ), + ConstSyst_ME31 = cms.double( 0.0 ), + UseAverageTime = cms.bool( False ), + NoiseLevel_ME1a = cms.double( 7.0 ), + NoiseLevel_ME1b = cms.double( 8.0 ), + CSCWireClusterDeltaT = cms.int32( 1 ), + CSCUseStaticPedestals = cms.bool( False ), + stripDigiTag = cms.InputTag( 'hltMuonCSCDigis','MuonCSCStripDigi' ), + CSCstripWireDeltaTime = cms.int32( 8 ), + NoiseLevel_ME21 = cms.double( 9.0 ), + NoiseLevel_ME22 = cms.double( 9.0 ), + NoiseLevel_ME41 = cms.double( 9.0 ) ) -process.hltL3TrajSeedIOHit = cms.EDProducer( "TSGFromL2Muon", - TkSeedGenerator = cms.PSet( - PSetNames = cms.vstring( 'skipTSG', - 'iterativeTSG' ), - L3TkCollectionA = cms.InputTag( "hltL3TkFromL2OICombination" ), - iterativeTSG = cms.PSet( - firstTSG = cms.PSet( - ComponentName = cms.string( "TSGFromOrderedHits" ), - OrderedHitsFactoryPSet = cms.PSet( - ComponentName = cms.string( "StandardHitTripletGenerator" ), - GeneratorPSet = cms.PSet( - useBending = cms.bool( True ), - useFixedPreFiltering = cms.bool( False ), - maxElement = cms.uint32( 0 ), - phiPreFiltering = cms.double( 0.3 ), - extraHitRPhitolerance = cms.double( 0.06 ), - useMultScattering = cms.bool( True ), - ComponentName = cms.string( "PixelTripletHLTGenerator" ), - extraHitRZtolerance = cms.double( 0.06 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) - ), - SeedingLayers = cms.InputTag( "hltPixelLayerTriplets" ) - ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - PSetNames = cms.vstring( 'firstTSG', - 'secondTSG' ), - ComponentName = cms.string( "CombinedTSG" ), - thirdTSG = cms.PSet( - PSetNames = cms.vstring( 'endcapTSG', - 'barrelTSG' ), - barrelTSG = cms.PSet( ), - endcapTSG = cms.PSet( - ComponentName = cms.string( "TSGFromOrderedHits" ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitPairGenerator" ), - useOnDemandTracker = cms.untracked.int32( 0 ), - SeedingLayers = cms.InputTag( "hltMixedLayerPairs" ) - ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - etaSeparation = cms.double( 2.0 ), - ComponentName = cms.string( "DualByEtaTSG" ) - ), - secondTSG = cms.PSet( - ComponentName = cms.string( "TSGFromOrderedHits" ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitPairGenerator" ), - useOnDemandTracker = cms.untracked.int32( 0 ), - SeedingLayers = cms.InputTag( "hltPixelLayerPairs" ) +process.hltCscSegments = cms.EDProducer( "CSCSegmentProducer", + inputObjects = cms.InputTag( "hltCsc2DRecHits" ), + algo_psets = cms.VPSet( + cms.PSet( chamber_types = cms.vstring( 'ME1/a', + 'ME1/b', + 'ME1/2', + 'ME1/3', + 'ME2/1', + 'ME2/2', + 'ME3/1', + 'ME3/2', + 'ME4/1', + 'ME4/2' ), + algo_name = cms.string( "CSCSegAlgoST" ), + parameters_per_chamber_type = cms.vint32( 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 ), + algo_psets = cms.VPSet( + cms.PSet( maxRatioResidualPrune = cms.double( 3.0 ), + yweightPenalty = cms.double( 1.5 ), + maxRecHitsInCluster = cms.int32( 20 ), + dPhiFineMax = cms.double( 0.025 ), + preClusteringUseChaining = cms.bool( True ), + ForceCovariance = cms.bool( False ), + hitDropLimit6Hits = cms.double( 0.3333 ), + NormChi2Cut2D = cms.double( 20.0 ), + BPMinImprovement = cms.double( 10000.0 ), + Covariance = cms.double( 0.0 ), + tanPhiMax = cms.double( 0.5 ), + SeedBig = cms.double( 0.0015 ), + onlyBestSegment = cms.bool( False ), + dRPhiFineMax = cms.double( 8.0 ), + SeedSmall = cms.double( 2.0E-4 ), + curvePenalty = cms.double( 2.0 ), + dXclusBoxMax = cms.double( 4.0 ), + BrutePruning = cms.bool( True ), + curvePenaltyThreshold = cms.double( 0.85 ), + CorrectTheErrors = cms.bool( True ), + hitDropLimit4Hits = cms.double( 0.6 ), + useShowering = cms.bool( False ), + CSCDebug = cms.untracked.bool( False ), + tanThetaMax = cms.double( 1.2 ), + NormChi2Cut3D = cms.double( 10.0 ), + minHitsPerSegment = cms.int32( 3 ), + ForceCovarianceAll = cms.bool( False ), + yweightPenaltyThreshold = cms.double( 1.0 ), + prePrunLimit = cms.double( 3.17 ), + hitDropLimit5Hits = cms.double( 0.8 ), + preClustering = cms.bool( True ), + prePrun = cms.bool( True ), + maxDPhi = cms.double( 999.0 ), + maxDTheta = cms.double( 999.0 ), + Pruning = cms.bool( True ), + dYclusBoxMax = cms.double( 8.0 ) ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + cms.PSet( maxRatioResidualPrune = cms.double( 3.0 ), + yweightPenalty = cms.double( 1.5 ), + maxRecHitsInCluster = cms.int32( 24 ), + dPhiFineMax = cms.double( 0.025 ), + preClusteringUseChaining = cms.bool( True ), + ForceCovariance = cms.bool( False ), + hitDropLimit6Hits = cms.double( 0.3333 ), + NormChi2Cut2D = cms.double( 20.0 ), + BPMinImprovement = cms.double( 10000.0 ), + Covariance = cms.double( 0.0 ), + tanPhiMax = cms.double( 0.5 ), + SeedBig = cms.double( 0.0015 ), + onlyBestSegment = cms.bool( False ), + dRPhiFineMax = cms.double( 8.0 ), + SeedSmall = cms.double( 2.0E-4 ), + curvePenalty = cms.double( 2.0 ), + dXclusBoxMax = cms.double( 4.0 ), + BrutePruning = cms.bool( True ), + curvePenaltyThreshold = cms.double( 0.85 ), + CorrectTheErrors = cms.bool( True ), + hitDropLimit4Hits = cms.double( 0.6 ), + useShowering = cms.bool( False ), + CSCDebug = cms.untracked.bool( False ), + tanThetaMax = cms.double( 1.2 ), + NormChi2Cut3D = cms.double( 10.0 ), + minHitsPerSegment = cms.int32( 3 ), + ForceCovarianceAll = cms.bool( False ), + yweightPenaltyThreshold = cms.double( 1.0 ), + prePrunLimit = cms.double( 3.17 ), + hitDropLimit5Hits = cms.double( 0.8 ), + preClustering = cms.bool( True ), + prePrun = cms.bool( True ), + maxDPhi = cms.double( 999.0 ), + maxDTheta = cms.double( 999.0 ), + Pruning = cms.bool( True ), + dYclusBoxMax = cms.double( 8.0 ) + ) ) - ), - skipTSG = cms.PSet( ), - ComponentName = cms.string( "DualByL2TSG" ) + ) ), + algo_type = cms.int32( 1 ) +) +process.hltMuonRPCDigis = cms.EDProducer( "RPCUnpackingModule", + InputLabel = cms.InputTag( "rawDataCollector" ), + doSynchro = cms.bool( False ) +) +process.hltRpcRecHits = cms.EDProducer( "RPCRecHitProducer", + recAlgoConfig = cms.PSet( ), + deadvecfile = cms.FileInPath( "RecoLocalMuon/RPCRecHit/data/RPCDeadVec.dat" ), + rpcDigiLabel = cms.InputTag( "hltMuonRPCDigis" ), + maskvecfile = cms.FileInPath( "RecoLocalMuon/RPCRecHit/data/RPCMaskVec.dat" ), + recAlgo = cms.string( "RPCRecHitStandardAlgo" ), + deadSource = cms.string( "File" ), + maskSource = cms.string( "File" ) +) +process.hltL2OfflineMuonSeeds = cms.EDProducer( "MuonSeedGenerator", + SMB_21 = cms.vdouble( 1.043, -0.124, 0.0, 0.183, 0.0, 0.0 ), + SMB_20 = cms.vdouble( 1.011, -0.052, 0.0, 0.188, 0.0, 0.0 ), + SMB_22 = cms.vdouble( 1.474, -0.758, 0.0, 0.185, 0.0, 0.0 ), + OL_2213 = cms.vdouble( 0.117, 0.0, 0.0, 0.044, 0.0, 0.0 ), + SME_11 = cms.vdouble( 3.295, -1.527, 0.112, 0.378, 0.02, 0.0 ), + SME_13 = cms.vdouble( -1.286, 1.711, 0.0, 0.356, 0.0, 0.0 ), + SME_12 = cms.vdouble( 0.102, 0.599, 0.0, 0.38, 0.0, 0.0 ), + DT_34_2_scale = cms.vdouble( -11.901897, 0.0 ), + OL_1213_0_scale = cms.vdouble( -4.488158, 0.0 ), + OL_1222_0_scale = cms.vdouble( -5.810449, 0.0 ), + DT_13 = cms.vdouble( 0.315, 0.068, -0.127, 0.051, -0.002, 0.0 ), + DT_12 = cms.vdouble( 0.183, 0.054, -0.087, 0.028, 0.002, 0.0 ), + DT_14 = cms.vdouble( 0.359, 0.052, -0.107, 0.072, -0.004, 0.0 ), + CSC_13_3_scale = cms.vdouble( -1.701268, 0.0 ), + DT_24_2_scale = cms.vdouble( -6.63094, 0.0 ), + CSC_23 = cms.vdouble( -0.081, 0.113, -0.029, 0.015, 0.008, 0.0 ), + CSC_24 = cms.vdouble( 0.004, 0.021, -0.002, 0.053, 0.0, 0.0 ), + OL_2222 = cms.vdouble( 0.107, 0.0, 0.0, 0.04, 0.0, 0.0 ), + DT_14_2_scale = cms.vdouble( -4.808546, 0.0 ), + SMB_10 = cms.vdouble( 1.387, -0.038, 0.0, 0.19, 0.0, 0.0 ), + SMB_11 = cms.vdouble( 1.247, 0.72, -0.802, 0.229, -0.075, 0.0 ), + SMB_12 = cms.vdouble( 2.128, -0.956, 0.0, 0.199, 0.0, 0.0 ), + SME_21 = cms.vdouble( -0.529, 1.194, -0.358, 0.472, 0.086, 0.0 ), + SME_22 = cms.vdouble( -1.207, 1.491, -0.251, 0.189, 0.243, 0.0 ), + DT_13_2_scale = cms.vdouble( -4.257687, 0.0 ), + CSC_34 = cms.vdouble( 0.062, -0.067, 0.019, 0.021, 0.003, 0.0 ), + SME_22_0_scale = cms.vdouble( -3.457901, 0.0 ), + DT_24_1_scale = cms.vdouble( -7.490909, 0.0 ), + OL_1232_0_scale = cms.vdouble( -5.964634, 0.0 ), + DT_23_1_scale = cms.vdouble( -5.320346, 0.0 ), + SME_13_0_scale = cms.vdouble( 0.104905, 0.0 ), + SMB_22_0_scale = cms.vdouble( 1.346681, 0.0 ), + CSC_12_1_scale = cms.vdouble( -6.434242, 0.0 ), + DT_34 = cms.vdouble( 0.044, 0.004, -0.013, 0.029, 0.003, 0.0 ), + SME_32 = cms.vdouble( -0.901, 1.333, -0.47, 0.41, 0.073, 0.0 ), + SME_31 = cms.vdouble( -1.594, 1.482, -0.317, 0.487, 0.097, 0.0 ), + CSC_13_2_scale = cms.vdouble( -6.077936, 0.0 ), + crackEtas = cms.vdouble( 0.2, 1.6, 1.7 ), + SME_11_0_scale = cms.vdouble( 1.325085, 0.0 ), + SMB_20_0_scale = cms.vdouble( 1.486168, 0.0 ), + DT_13_1_scale = cms.vdouble( -4.520923, 0.0 ), + CSC_24_1_scale = cms.vdouble( -6.055701, 0.0 ), + CSC_01_1_scale = cms.vdouble( -1.915329, 0.0 ), + DT_23 = cms.vdouble( 0.13, 0.023, -0.057, 0.028, 0.004, 0.0 ), + DT_24 = cms.vdouble( 0.176, 0.014, -0.051, 0.051, 0.003, 0.0 ), + SMB_12_0_scale = cms.vdouble( 2.283221, 0.0 ), + deltaPhiSearchWindow = cms.double( 0.25 ), + SMB_30_0_scale = cms.vdouble( -3.629838, 0.0 ), + SME_42 = cms.vdouble( -0.003, 0.005, 0.005, 0.608, 0.076, 0.0 ), + SME_41 = cms.vdouble( -0.003, 0.005, 0.005, 0.608, 0.076, 0.0 ), + deltaEtaSearchWindow = cms.double( 0.2 ), + CSC_12_2_scale = cms.vdouble( -1.63622, 0.0 ), + DT_34_1_scale = cms.vdouble( -13.783765, 0.0 ), + CSC_34_1_scale = cms.vdouble( -11.520507, 0.0 ), + OL_2213_0_scale = cms.vdouble( -7.239789, 0.0 ), + SMB_32_0_scale = cms.vdouble( -3.054156, 0.0 ), + CSC_12_3_scale = cms.vdouble( -1.63622, 0.0 ), + deltaEtaCrackSearchWindow = cms.double( 0.25 ), + SME_21_0_scale = cms.vdouble( -0.040862, 0.0 ), + OL_1232 = cms.vdouble( 0.184, 0.0, 0.0, 0.066, 0.0, 0.0 ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + SMB_10_0_scale = cms.vdouble( 2.448566, 0.0 ), + EnableDTMeasurement = cms.bool( True ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + CSC_23_2_scale = cms.vdouble( -6.079917, 0.0 ), + scaleDT = cms.bool( True ), + DT_12_2_scale = cms.vdouble( -3.518165, 0.0 ), + OL_1222 = cms.vdouble( 0.848, -0.591, 0.0, 0.062, 0.0, 0.0 ), + CSC_23_1_scale = cms.vdouble( -19.084285, 0.0 ), + OL_1213 = cms.vdouble( 0.96, -0.737, 0.0, 0.052, 0.0, 0.0 ), + CSC_02 = cms.vdouble( 0.612, -0.207, 0.0, 0.067, -0.001, 0.0 ), + CSC_03 = cms.vdouble( 0.787, -0.338, 0.029, 0.101, -0.008, 0.0 ), + CSC_01 = cms.vdouble( 0.166, 0.0, 0.0, 0.031, 0.0, 0.0 ), + SMB_32 = cms.vdouble( 0.67, -0.327, 0.0, 0.22, 0.0, 0.0 ), + SMB_30 = cms.vdouble( 0.505, -0.022, 0.0, 0.215, 0.0, 0.0 ), + SMB_31 = cms.vdouble( 0.549, -0.145, 0.0, 0.207, 0.0, 0.0 ), + crackWindow = cms.double( 0.04 ), + CSC_14_3_scale = cms.vdouble( -1.969563, 0.0 ), + SMB_31_0_scale = cms.vdouble( -3.323768, 0.0 ), + DT_12_1_scale = cms.vdouble( -3.692398, 0.0 ), + SMB_21_0_scale = cms.vdouble( 1.58384, 0.0 ), + DT_23_2_scale = cms.vdouble( -5.117625, 0.0 ), + SME_12_0_scale = cms.vdouble( 2.279181, 0.0 ), + DT_14_1_scale = cms.vdouble( -5.644816, 0.0 ), + beamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + SMB_11_0_scale = cms.vdouble( 2.56363, 0.0 ), + EnableCSCMeasurement = cms.bool( True ), + CSC_14 = cms.vdouble( 0.606, -0.181, -0.002, 0.111, -0.003, 0.0 ), + OL_2222_0_scale = cms.vdouble( -7.667231, 0.0 ), + CSC_13 = cms.vdouble( 0.901, -1.302, 0.533, 0.045, 0.005, 0.0 ), + CSC_12 = cms.vdouble( -0.161, 0.254, -0.047, 0.042, -0.007, 0.0 ) +) +process.hltL2MuonSeeds = cms.EDProducer( "L2MuonSeedGenerator", ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'PropagatorWithMaterial' ), + Propagators = cms.untracked.vstring( 'SteppingHelixPropagatorAny' ), RPCLayers = cms.bool( True ), UseMuonNavigation = cms.untracked.bool( True ) ), - MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), - MuonTrackingRegionBuilder = cms.PSet( - EtaR_UpperLimit_Par1 = cms.double( 0.25 ), - EtaR_UpperLimit_Par2 = cms.double( 0.15 ), - OnDemand = cms.double( -1.0 ), - Rescale_Dz = cms.double( 3.0 ), - vertexCollection = cms.InputTag( "pixelVertices" ), - Rescale_phi = cms.double( 3.0 ), - Eta_fixed = cms.double( 0.2 ), - DeltaZ_Region = cms.double( 15.9 ), - MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - PhiR_UpperLimit_Par2 = cms.double( 0.2 ), - Eta_min = cms.double( 0.1 ), - Phi_fixed = cms.double( 0.2 ), - DeltaR = cms.double( 0.2 ), - EscapePt = cms.double( 1.5 ), - UseFixedRegion = cms.bool( False ), - PhiR_UpperLimit_Par1 = cms.double( 0.6 ), - Rescale_eta = cms.double( 3.0 ), - Phi_min = cms.double( 0.1 ), - UseVertex = cms.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) - ), - PCut = cms.double( 2.5 ), - TrackerSeedCleaner = cms.PSet( - cleanerFromSharedHits = cms.bool( True ), - ptCleaner = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - directionCleaner = cms.bool( True ) - ), - PtCut = cms.double( 1.0 ) -) -process.hltL3TrackCandidateFromL2IOHit = cms.EDProducer( "CkfTrajectoryMaker", - src = cms.InputTag( "hltL3TrajSeedIOHit" ), - reverseTrajectories = cms.bool( False ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - trackCandidateAlso = cms.bool( True ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "hltESPMuonCkfTrajectoryBuilder" ), - maxNSeeds = cms.uint32( 100000 ) -) -process.hltL3TkTracksFromL2IOHit = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltL3TrackCandidateFromL2IOHit" ), - SimpleMagneticField = cms.string( "" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPKFFittingSmoother" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( False ), - Propagator = cms.string( "PropagatorWithMaterial" ) + InputObjects = cms.InputTag( "hltL1extraParticles" ), + L1MaxEta = cms.double( 2.5 ), + OfflineSeedLabel = cms.untracked.InputTag( "hltL2OfflineMuonSeeds" ), + L1MinPt = cms.double( 0.0 ), + L1MinQuality = cms.uint32( 1 ), + GMTReadoutCollection = cms.InputTag( "hltGtDigis" ), + UseUnassociatedL1 = cms.bool( False ), + UseOfflineSeed = cms.untracked.bool( True ), + Propagator = cms.string( "SteppingHelixPropagatorAny" ) ) -process.hltL3MuonsIOHit = cms.EDProducer( "L3MuonProducer", +process.hltL2Muons = cms.EDProducer( "L2MuonProducer", ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', - 'SteppingHelixPropagatorAny', - 'hltESPSmartPropagator', - 'hltESPSteppingHelixPropagatorOpposite' ), + Propagators = cms.untracked.vstring( 'hltESPFastSteppingHelixPropagatorAny', + 'hltESPFastSteppingHelixPropagatorOpposite' ), RPCLayers = cms.bool( True ), UseMuonNavigation = cms.untracked.bool( True ) ), - L3TrajBuilderParameters = cms.PSet( - ScaleTECyFactor = cms.double( -1.0 ), - GlbRefitterParameters = cms.PSet( - TrackerSkipSection = cms.int32( -1 ), - DoPredictionsOnly = cms.bool( False ), - PropDirForCosmics = cms.bool( False ), - HitThreshold = cms.int32( 1 ), - MuonHitsOption = cms.int32( 1 ), - Chi2CutRPC = cms.double( 1.0 ), - Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + InputObjects = cms.InputTag( "hltL2MuonSeeds" ), + SeedTransformerParameters = cms.PSet( + Fitter = cms.string( "hltESPKFFittingSmootherForL2Muon" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + NMinRecHits = cms.uint32( 2 ), + UseSubRecHits = cms.bool( False ), + Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), + RescaleError = cms.double( 100.0 ) + ), + L2TrajBuilderParameters = cms.PSet( + DoRefit = cms.bool( False ), + SeedPropagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), + FilterParameters = cms.PSet( + NumberOfSigma = cms.double( 3.0 ), + FitDirection = cms.string( "insideOut" ), DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - RefitDirection = cms.string( "insideOut" ), + MaxChi2 = cms.double( 1000.0 ), + MuonTrajectoryUpdatorParameters = cms.PSet( + MaxChi2 = cms.double( 25.0 ), + RescaleErrorFactor = cms.double( 100.0 ), + Granularity = cms.int32( 0 ), + ExcludeRPCFromFit = cms.bool( False ), + UseInvalidHits = cms.bool( True ), + RescaleError = cms.bool( False ) + ), + EnableRPCMeasurement = cms.bool( True ), CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), - Chi2CutCSC = cms.double( 150.0 ), - Chi2CutDT = cms.double( 10.0 ), - RefitRPCHits = cms.bool( True ), - SkipStation = cms.int32( -1 ), - Propagator = cms.string( "hltESPSmartPropagatorAny" ), - TrackerSkipSystem = cms.int32( -1 ), - DYTthrs = cms.vint32( 30, 15 ) - ), - ScaleTECxFactor = cms.double( -1.0 ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - MuonTrackingRegionBuilder = cms.PSet( - EtaR_UpperLimit_Par1 = cms.double( 0.25 ), - EtaR_UpperLimit_Par2 = cms.double( 0.15 ), - OnDemand = cms.double( -1.0 ), - Rescale_Dz = cms.double( 3.0 ), - vertexCollection = cms.InputTag( "pixelVertices" ), - Rescale_phi = cms.double( 3.0 ), - Eta_fixed = cms.double( 0.2 ), - DeltaZ_Region = cms.double( 15.9 ), - MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), - PhiR_UpperLimit_Par2 = cms.double( 0.2 ), - Eta_min = cms.double( 0.05 ), - Phi_fixed = cms.double( 0.2 ), - DeltaR = cms.double( 0.2 ), - EscapePt = cms.double( 1.5 ), - UseFixedRegion = cms.bool( False ), - PhiR_UpperLimit_Par1 = cms.double( 0.6 ), - Rescale_eta = cms.double( 3.0 ), - Phi_min = cms.double( 0.05 ), - UseVertex = cms.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + EnableDTMeasurement = cms.bool( True ), + RPCRecSegmentLabel = cms.InputTag( "hltRpcRecHits" ), + Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), + EnableCSCMeasurement = cms.bool( True ) ), - RefitRPCHits = cms.bool( True ), - PCut = cms.double( 2.5 ), - TrackTransformer = cms.PSet( - DoPredictionsOnly = cms.bool( False ), - Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), - TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + NavigationType = cms.string( "Standard" ), + SeedTransformerParameters = cms.PSet( + Fitter = cms.string( "hltESPKFFittingSmootherForL2Muon" ), MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), - RefitDirection = cms.string( "insideOut" ), - RefitRPCHits = cms.bool( True ), - Propagator = cms.string( "hltESPSmartPropagatorAny" ) + NMinRecHits = cms.uint32( 2 ), + UseSubRecHits = cms.bool( False ), + Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), + RescaleError = cms.double( 100.0 ) ), - GlobalMuonTrackMatcher = cms.PSet( - Pt_threshold1 = cms.double( 0.0 ), - DeltaDCut_3 = cms.double( 15.0 ), - MinP = cms.double( 2.5 ), - MinPt = cms.double( 1.0 ), - Chi2Cut_1 = cms.double( 50.0 ), - Pt_threshold2 = cms.double( 9.99999999E8 ), - LocChi2Cut = cms.double( 0.001 ), - Eta_threshold = cms.double( 1.2 ), - Quality_3 = cms.double( 7.0 ), - Quality_2 = cms.double( 15.0 ), - Chi2Cut_2 = cms.double( 50.0 ), - Chi2Cut_3 = cms.double( 200.0 ), - DeltaDCut_1 = cms.double( 40.0 ), - DeltaRCut_2 = cms.double( 0.2 ), - DeltaRCut_3 = cms.double( 1.0 ), - DeltaDCut_2 = cms.double( 10.0 ), - DeltaRCut_1 = cms.double( 0.1 ), - Propagator = cms.string( "hltESPSmartPropagator" ), - Quality_1 = cms.double( 20.0 ) + DoBackwardFilter = cms.bool( True ), + SeedPosition = cms.string( "in" ), + BWFilterParameters = cms.PSet( + NumberOfSigma = cms.double( 3.0 ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + FitDirection = cms.string( "outsideIn" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + MaxChi2 = cms.double( 100.0 ), + MuonTrajectoryUpdatorParameters = cms.PSet( + MaxChi2 = cms.double( 25.0 ), + RescaleErrorFactor = cms.double( 100.0 ), + Granularity = cms.int32( 0 ), + ExcludeRPCFromFit = cms.bool( False ), + UseInvalidHits = cms.bool( True ), + RescaleError = cms.bool( False ) + ), + EnableRPCMeasurement = cms.bool( True ), + BWSeedType = cms.string( "fromGenerator" ), + EnableDTMeasurement = cms.bool( True ), + RPCRecSegmentLabel = cms.InputTag( "hltRpcRecHits" ), + Propagator = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), + EnableCSCMeasurement = cms.bool( True ) ), - PtCut = cms.double( 1.0 ), - TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), - tkTrajLabel = cms.InputTag( "hltL3TkTracksFromL2IOHit" ), - tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - tkTrajMaxChi2 = cms.double( 9999.0 ), - tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), - tkTrajVertex = cms.InputTag( "pixelVertices" ), - tkTrajUseVertex = cms.bool( False ) + DoSeedRefit = cms.bool( False ) ), + DoSeedRefit = cms.bool( False ), TrackLoaderParameters = cms.PSet( - PutTkTrackIntoEvent = cms.untracked.bool( False ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - SmoothTkTrack = cms.untracked.bool( False ), - MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + DoSmoothing = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), MuonUpdatorAtVertexParameters = cms.PSet( MaxChi2 = cms.double( 1000000.0 ), - Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPosition = cms.vdouble( 0.0, 0.0, 0.0 ), + Propagator = cms.string( "hltESPFastSteppingHelixPropagatorOpposite" ), BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) ), - VertexConstraint = cms.bool( False ), - DoSmoothing = cms.bool( True ), + VertexConstraint = cms.bool( True ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) ), - MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) + MuonTrajectoryBuilder = cms.string( "Exhaustive" ) ) -process.hltL3TrajectorySeed = cms.EDProducer( "L3MuonTrajectorySeedCombiner", - labels = cms.VInputTag( 'hltL3TrajSeedIOHit','hltL3TrajSeedOIState','hltL3TrajSeedOIHit' ) -) -process.hltL3TrackCandidateFromL2 = cms.EDProducer( "L3TrackCandCombiner", - labels = cms.VInputTag( 'hltL3TrackCandidateFromL2IOHit','hltL3TrackCandidateFromL2OIHit','hltL3TrackCandidateFromL2OIState' ) -) -process.hltL3TkTracksMergeStep1 = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltL3TkTracksFromL2OIState','hltL3TkTracksFromL2OIHit' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 100.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltL3TkTracksFromL2OIState','hltL3TkTracksFromL2OIHit' ), - LostHitPenalty = cms.double( 0.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltL3TkTracksFromL2 = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltL3TkTracksMergeStep1','hltL3TkTracksFromL2IOHit' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 100.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltL3TkTracksMergeStep1','hltL3TkTracksFromL2IOHit' ), - LostHitPenalty = cms.double( 0.0 ), - newQuality = cms.string( "confirmed" ) +process.hltL2MuonCandidates = cms.EDProducer( "L2MuonCandidateProducer", + InputObjects = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) +) +process.hltHIL2Mu3L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) ) -process.hltL3MuonsLinksCombination = cms.EDProducer( "L3TrackLinksCombiner", - labels = cms.VInputTag( 'hltL3MuonsOIState','hltL3MuonsOIHit','hltL3MuonsIOHit' ) +process.hltPreHIL2Mu7 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) ) -process.hltL3Muons = cms.EDProducer( "L3TrackCombiner", - labels = cms.VInputTag( 'hltL3MuonsOIState','hltL3MuonsOIHit','hltL3MuonsIOHit' ) +process.hltHIL2Mu7L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 7.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) ) -process.hltL3MuonCandidates = cms.EDProducer( "L3MuonCandidateProducer", - InputLinksObjects = cms.InputTag( "hltL3MuonsLinksCombination" ), - InputObjects = cms.InputTag( "hltL3Muons" ), - MuonPtOption = cms.string( "Tracker" ) +process.hltPreHIL2Mu15 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) ) -process.hltL3fL1sMu16orMu25L1f0L2f16QL3Filtered50Q = cms.EDFilter( "HLTMuonL3PreFilter", - MaxNormalizedChi2 = cms.double( 20.0 ), +process.hltHIL2Mu15L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", saveTags = cms.bool( True ), - PreviousCandTag = cms.InputTag( "hltL2fL1sMu16orMu25L1f0L2Filtered16Q" ), - MinNmuonHits = cms.int32( 0 ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 15.0 ), MinN = cms.int32( 1 ), - MinTrackPt = cms.double( 0.0 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), MaxEta = cms.double( 2.5 ), - MaxDXYBeamSpot = cms.double( 0.1 ), - MinNhits = cms.int32( 0 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2Mu3NHitQ = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIL2Mu3N1HitQL2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIL1SingleMu3Filtered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 1 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 1 ), MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2DoubleMu0 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIDoubleMuLevel1PathL1OpenFiltered = cms.EDFilter( "HLTMuonL1Filter", + saveTags = cms.bool( True ), + CSCTFtag = cms.InputTag( "unused" ), + PreviousCandTag = cms.InputTag( "hltL1sL1DoubleMuOpenBptxAND" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + MaxEta = cms.double( 2.5 ), + SelectQualities = cms.vint32( ), + CandTag = cms.InputTag( "hltL1extraParticles" ), + ExcludeSingleSegmentCSC = cms.bool( False ) +) +process.hltHIL2DoubleMu0L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), MaxDz = cms.double( 9999.0 ), - MaxPtDifference = cms.double( 9999.0 ), - MaxDr = cms.double( 2.0 ), - CandTag = cms.InputTag( "hltL3MuonCandidates" ), - MinDXYBeamSpot = cms.double( -1.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2DoubleMu0NHitQ = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIL2DoubleMu0L2N1HitsFiltered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 1 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) +) +process.hltPreHIL2DoubleMu3 = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIL2DoubleMu3L2Filtered = cms.EDFilter( "HLTMuonL2PreFilter", + saveTags = cms.bool( True ), + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 3.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 3.0 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), - MinPt = cms.double( 50.0 ) + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) ) -process.hltPrePFJet260 = cms.EDFilter( "HLTPrescaler", +process.hltPreHIL3Mu3 = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) -process.hltSingleCaloJet210 = cms.EDFilter( "HLT1CaloJet", - saveTags = cms.bool( True ), - MinPt = cms.double( 210.0 ), - MinN = cms.int32( 1 ), - MaxEta = cms.double( 5.0 ), - MinMass = cms.double( -1.0 ), - inputTag = cms.InputTag( "hltAK4CaloJetsCorrectedIDPassed" ), - MinE = cms.double( -1.0 ), - triggerType = cms.int32( 85 ) -) -process.hltTowerMakerForPF = cms.EDProducer( "CaloTowersCreator", - EBSumThreshold = cms.double( 0.2 ), - MomHBDepth = cms.double( 0.2 ), - UseEtEBTreshold = cms.bool( False ), - hfInput = cms.InputTag( "hltHfreco" ), - AllowMissingInputs = cms.bool( False ), - MomEEDepth = cms.double( 0.0 ), - EESumThreshold = cms.double( 0.45 ), - HBGrid = cms.vdouble( ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - HBThreshold = cms.double( 0.4 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), - UseEcalRecoveredHits = cms.bool( False ), - MomConstrMethod = cms.int32( 1 ), - MomHEDepth = cms.double( 0.4 ), - HcalThreshold = cms.double( -1000.0 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), - UseSymEBTreshold = cms.bool( False ), - EEWeights = cms.vdouble( ), - EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), - HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HEDGrid = cms.vdouble( ), - EBWeight = cms.double( 1.0 ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), - HOWeight = cms.double( 1.0 ), - HESWeight = cms.double( 1.0 ), - HESThreshold = cms.double( 0.4 ), - hbheInput = cms.InputTag( "hltHbhereco" ), - HF2Weight = cms.double( 1.0 ), - HF2Threshold = cms.double( 1.8 ), - HcalAcceptSeverityLevel = cms.uint32( 11 ), - EEThreshold = cms.double( 0.3 ), - HOThresholdPlus1 = cms.double( 1.1 ), - HOThresholdPlus2 = cms.double( 1.1 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HF1Threshold = cms.double( 1.2 ), - HOThresholdMinus1 = cms.double( 1.1 ), - HESGrid = cms.vdouble( ), - EcutTower = cms.double( -1000.0 ), - UseRejectedRecoveredEcalHits = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - HESWeights = cms.vdouble( ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), - HEDWeight = cms.double( 1.0 ), - UseSymEETreshold = cms.bool( False ), - HEDThreshold = cms.double( 0.4 ), - EBThreshold = cms.double( 0.07 ), - UseRejectedHitsOnly = cms.bool( False ), - UseHcalRecoveredHits = cms.bool( True ), - HOThresholdMinus2 = cms.double( 1.1 ), - HOThreshold0 = cms.double( 1.1 ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), - UseRejectedRecoveredHcalHits = cms.bool( False ), - MomEBDepth = cms.double( 0.3 ), - HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ) -) -process.hltAK4CaloJetsPF = cms.EDProducer( "FastjetJetProducer", - Active_Area_Repeats = cms.int32( 5 ), - doAreaFastjet = cms.bool( False ), - voronoiRfact = cms.double( -9.0 ), - maxBadHcalCells = cms.uint32( 9999999 ), - doAreaDiskApprox = cms.bool( False ), - maxRecoveredEcalCells = cms.uint32( 9999999 ), - jetType = cms.string( "CaloJet" ), - minSeed = cms.uint32( 0 ), - Ghost_EtaMax = cms.double( 6.0 ), - doRhoFastjet = cms.bool( False ), - jetAlgorithm = cms.string( "AntiKt" ), - nSigmaPU = cms.double( 1.0 ), - GhostArea = cms.double( 0.01 ), - Rho_EtaMax = cms.double( 4.4 ), - maxBadEcalCells = cms.uint32( 9999999 ), - useDeterministicSeed = cms.bool( True ), - doPVCorrection = cms.bool( False ), - maxRecoveredHcalCells = cms.uint32( 9999999 ), - rParam = cms.double( 0.4 ), - maxProblematicHcalCells = cms.uint32( 9999999 ), - doOutputJets = cms.bool( True ), - src = cms.InputTag( "hltTowerMakerForPF" ), - inputEtMin = cms.double( 0.3 ), - puPtMin = cms.double( 10.0 ), - srcPVs = cms.InputTag( "NotUsed" ), - jetPtMin = cms.double( 1.0 ), - radiusPU = cms.double( 0.4 ), - maxProblematicEcalCells = cms.uint32( 9999999 ), - doPUOffsetCorr = cms.bool( False ), - inputEMin = cms.double( 0.0 ), - useMassDropTagger = cms.bool( False ), - muMin = cms.double( -1.0 ), - subtractorName = cms.string( "" ), - muCut = cms.double( -1.0 ), - subjetPtMin = cms.double( -1.0 ), - useTrimming = cms.bool( False ), - muMax = cms.double( -1.0 ), - yMin = cms.double( -1.0 ), - useFiltering = cms.bool( False ), - rFilt = cms.double( -1.0 ), - yMax = cms.double( -1.0 ), - zcut = cms.double( -1.0 ), - MinVtxNdof = cms.int32( 5 ), - MaxVtxZ = cms.double( 15.0 ), - UseOnlyVertexTracks = cms.bool( False ), - dRMin = cms.double( -1.0 ), - nFilt = cms.int32( -1 ), - usePruning = cms.bool( False ), - maxDepth = cms.int32( -1 ), - yCut = cms.double( -1.0 ), - DzTrVtxMax = cms.double( 0.0 ), - UseOnlyOnePV = cms.bool( False ), - rcut_factor = cms.double( -1.0 ), - sumRecHits = cms.bool( False ), - trimPtFracMin = cms.double( -1.0 ), - dRMax = cms.double( -1.0 ), - DxyTrVtxMax = cms.double( 0.0 ), - useCMSBoostedTauSeedingAlgorithm = cms.bool( False ) -) -process.hltAK4CaloJetsPFEt5 = cms.EDFilter( "EtMinCaloJetSelector", - filter = cms.bool( False ), - src = cms.InputTag( "hltAK4CaloJetsPF" ), - etMin = cms.double( 5.0 ) -) -process.hltPixelTracks = cms.EDProducer( "PixelTrackProducer", - useFilterWithES = cms.bool( False ), - FilterPSet = cms.PSet( - chi2 = cms.double( 1000.0 ), - nSigmaTipMaxTolerance = cms.double( 0.0 ), - ComponentName = cms.string( "PixelTrackFilterByKinematics" ), - nSigmaInvPtTolerance = cms.double( 0.0 ), - ptMin = cms.double( 0.1 ), - tipMax = cms.double( 1.0 ) - ), - passLabel = cms.string( "Pixel triplet primary tracks with vertex constraint" ), - FitterPSet = cms.PSet( - ComponentName = cms.string( "PixelFitterByHelixProjections" ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - fixImpactParameter = cms.double( 0.0 ) - ), - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "GlobalRegionProducerFromBeamSpot" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.2 ), - ptMin = cms.double( 0.9 ), - originHalfLength = cms.double( 24.0 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) - ) - ), - CleanerPSet = cms.PSet( ComponentName = cms.string( "PixelTrackCleanerBySharedHits" ) ), - OrderedHitsFactoryPSet = cms.PSet( - ComponentName = cms.string( "StandardHitTripletGenerator" ), - GeneratorPSet = cms.PSet( - useBending = cms.bool( True ), - useFixedPreFiltering = cms.bool( False ), - maxElement = cms.uint32( 100000 ), - phiPreFiltering = cms.double( 0.3 ), - extraHitRPhitolerance = cms.double( 0.06 ), - useMultScattering = cms.bool( True ), - SeedComparitorPSet = cms.PSet( - ComponentName = cms.string( "LowPtClusterShapeSeedComparitor" ), - clusterShapeCacheSrc = cms.InputTag( "hltSiPixelClustersCache" ) - ), - extraHitRZtolerance = cms.double( 0.06 ), - ComponentName = cms.string( "PixelTripletHLTGenerator" ) - ), - SeedingLayers = cms.InputTag( "hltPixelLayerTriplets" ) - ) +process.hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", + UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), + InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), + ErrorList = cms.vint32( ), + Regions = cms.PSet( ), + Timing = cms.untracked.bool( False ), + UserErrorList = cms.vint32( ) +) +process.hltHISiPixelClusters = cms.EDProducer( "SiPixelClusterProducer", + src = cms.InputTag( "hltSiPixelDigis" ), + ChannelThreshold = cms.int32( 1000 ), + maxNumberOfClusters = cms.int32( -1 ), + VCaltoElectronGain = cms.int32( 65 ), + MissCalibrate = cms.untracked.bool( True ), + SplitClusters = cms.bool( False ), + VCaltoElectronOffset = cms.int32( -414 ), + payloadType = cms.string( "HLT" ), + SeedThreshold = cms.int32( 1000 ), + ClusterThreshold = cms.double( 4000.0 ) ) -process.hltPixelVertices = cms.EDProducer( "PixelVertexProducer", - WtAverage = cms.bool( True ), - Method2 = cms.bool( True ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - PVcomparer = cms.PSet( refToPSet_ = cms.string( "HLTPSetPvClusterComparerForIT" ) ), - Verbosity = cms.int32( 0 ), - UseError = cms.bool( True ), - TrackCollection = cms.InputTag( "hltPixelTracks" ), - PtMin = cms.double( 1.0 ), - NTrkMin = cms.int32( 2 ), - ZOffset = cms.double( 5.0 ), - Finder = cms.string( "DivisiveVertexFinder" ), - ZSeparation = cms.double( 0.05 ) -) -process.hltTrimmedPixelVertices = cms.EDProducer( "PixelVertexCollectionTrimmer", - minSumPt2 = cms.double( 0.0 ), - PVcomparer = cms.PSet( refToPSet_ = cms.string( "HLTPSetPvClusterComparerForIT" ) ), - maxVtx = cms.uint32( 100 ), - fractionSumPt2 = cms.double( 0.3 ), - src = cms.InputTag( "hltPixelVertices" ) -) -process.hltIter0PFLowPixelSeedsFromPixelTracks = cms.EDProducer( "SeedGeneratorFromProtoTracksEDProducer", - useEventsWithNoVertex = cms.bool( True ), - originHalfLength = cms.double( 0.3 ), - useProtoTrackKinematics = cms.bool( False ), - usePV = cms.bool( False ), - InputVertexCollection = cms.InputTag( "hltTrimmedPixelVertices" ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - InputCollection = cms.InputTag( "hltPixelTracks" ), - originRadius = cms.double( 0.1 ) -) -process.hltIter0PFlowCkfTrackCandidates = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter0PFLowPixelSeedsFromPixelTracks" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter0PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) +process.hltHISiPixelClustersCache = cms.EDProducer( "SiPixelClusterShapeCacheProducer", + src = cms.InputTag( "hltHISiPixelClusters" ), + onDemand = cms.bool( False ) ) -process.hltIter0PFlowCtfWithMaterialTracks = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter0PFlowCkfTrackCandidates" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIter0" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -process.hltIter0PFlowTrackSelectionHighPurity = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.4, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.35, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter0PFlowCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltTrimmedPixelVertices" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.4, 4.0 ), - d0_par1 = cms.vdouble( 0.3, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltTrackIter0RefsForJets4Iter1 = cms.EDProducer( "ChargedRefCandidateProducer", - src = cms.InputTag( "hltIter0PFlowTrackSelectionHighPurity" ), - particleType = cms.string( "pi+" ) -) -process.hltAK4Iter0TrackJets4Iter1 = cms.EDProducer( "FastjetJetProducer", - Active_Area_Repeats = cms.int32( 5 ), - doAreaFastjet = cms.bool( False ), - voronoiRfact = cms.double( 0.9 ), - maxBadHcalCells = cms.uint32( 9999999 ), - doAreaDiskApprox = cms.bool( False ), - maxRecoveredEcalCells = cms.uint32( 9999999 ), - jetType = cms.string( "TrackJet" ), - minSeed = cms.uint32( 14327 ), - Ghost_EtaMax = cms.double( 6.0 ), - doRhoFastjet = cms.bool( False ), - jetAlgorithm = cms.string( "AntiKt" ), - nSigmaPU = cms.double( 1.0 ), - GhostArea = cms.double( 0.01 ), - Rho_EtaMax = cms.double( 4.4 ), - maxBadEcalCells = cms.uint32( 9999999 ), - useDeterministicSeed = cms.bool( True ), - doPVCorrection = cms.bool( False ), - maxRecoveredHcalCells = cms.uint32( 9999999 ), - rParam = cms.double( 0.4 ), - maxProblematicHcalCells = cms.uint32( 9999999 ), - doOutputJets = cms.bool( True ), - src = cms.InputTag( "hltTrackIter0RefsForJets4Iter1" ), - inputEtMin = cms.double( 0.1 ), - puPtMin = cms.double( 0.0 ), - srcPVs = cms.InputTag( "hltTrimmedPixelVertices" ), - jetPtMin = cms.double( 1.0 ), - radiusPU = cms.double( 0.4 ), - maxProblematicEcalCells = cms.uint32( 9999999 ), - doPUOffsetCorr = cms.bool( False ), - inputEMin = cms.double( 0.0 ), - useMassDropTagger = cms.bool( False ), - muMin = cms.double( -1.0 ), - subtractorName = cms.string( "" ), - muCut = cms.double( -1.0 ), - subjetPtMin = cms.double( -1.0 ), - useTrimming = cms.bool( False ), - muMax = cms.double( -1.0 ), - yMin = cms.double( -1.0 ), - useFiltering = cms.bool( False ), - rFilt = cms.double( -1.0 ), - yMax = cms.double( -1.0 ), - zcut = cms.double( -1.0 ), - MinVtxNdof = cms.int32( 0 ), - MaxVtxZ = cms.double( 30.0 ), - UseOnlyVertexTracks = cms.bool( False ), - dRMin = cms.double( -1.0 ), - nFilt = cms.int32( -1 ), - usePruning = cms.bool( False ), - maxDepth = cms.int32( -1 ), - yCut = cms.double( -1.0 ), - DzTrVtxMax = cms.double( 0.5 ), - UseOnlyOnePV = cms.bool( True ), - rcut_factor = cms.double( -1.0 ), - sumRecHits = cms.bool( False ), - trimPtFracMin = cms.double( -1.0 ), - dRMax = cms.double( -1.0 ), - DxyTrVtxMax = cms.double( 0.2 ), - useCMSBoostedTauSeedingAlgorithm = cms.bool( False ) -) -process.hltIter0TrackAndTauJets4Iter1 = cms.EDProducer( "TauJetSelectorForHLTTrackSeeding", - fractionMinCaloInTauCone = cms.double( 0.7 ), - fractionMaxChargedPUInCaloCone = cms.double( 0.3 ), - tauConeSize = cms.double( 0.2 ), - ptTrkMaxInCaloCone = cms.double( 1.0 ), - isolationConeSize = cms.double( 0.5 ), - inputTrackJetTag = cms.InputTag( "hltAK4Iter0TrackJets4Iter1" ), - nTrkMaxInCaloCone = cms.int32( 0 ), - inputCaloJetTag = cms.InputTag( "hltAK4CaloJetsPFEt5" ), - etaMinCaloJet = cms.double( -2.7 ), - etaMaxCaloJet = cms.double( 2.7 ), - ptMinCaloJet = cms.double( 5.0 ), - inputTrackTag = cms.InputTag( "hltIter0PFlowTrackSelectionHighPurity" ) -) -process.hltIter1ClustersRefRemoval = cms.EDProducer( "TrackClusterRemover", - minNumberOfLayersWithMeasBeforeFiltering = cms.int32( 0 ), - maxChi2 = cms.double( 9.0 ), - trajectories = cms.InputTag( "hltIter0PFlowTrackSelectionHighPurity" ), - oldClusterRemovalInfo = cms.InputTag( "" ), - stripClusters = cms.InputTag( "hltSiStripRawToClustersFacility" ), - overrideTrkQuals = cms.InputTag( "" ), - pixelClusters = cms.InputTag( "hltSiPixelClusters" ), - TrackQuality = cms.string( "highPurity" ) -) -process.hltIter1MaskedMeasurementTrackerEvent = cms.EDProducer( "MaskedMeasurementTrackerEventProducer", - clustersToSkip = cms.InputTag( "hltIter1ClustersRefRemoval" ), - OnDemand = cms.bool( False ), - src = cms.InputTag( "hltSiStripClusters" ) -) -process.hltIter1PixelLayerTriplets = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2+BPix3', - 'BPix1+BPix2+FPix1_pos', - 'BPix1+BPix2+FPix1_neg', - 'BPix1+FPix1_pos+FPix2_pos', - 'BPix1+FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter1ClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0051 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter1ClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0027 ) - ), - TIB = cms.PSet( ) -) -process.hltIter1PFlowPixelSeeds = cms.EDProducer( "SeedGeneratorFromRegionHitsEDProducer", - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "CandidateSeededTrackingRegionsProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.05 ), - searchOpt = cms.bool( True ), - ptMin = cms.double( 0.5 ), - measurementTrackerName = cms.string( "hltIter1MaskedMeasurementTrackerEvent" ), - mode = cms.string( "VerticesFixed" ), - maxNRegions = cms.int32( 100 ), - maxNVertices = cms.int32( 10 ), - deltaPhi = cms.double( 1.0 ), - deltaEta = cms.double( 1.0 ), - zErrorBeamSpot = cms.double( 15.0 ), - nSigmaZBeamSpot = cms.double( 3.0 ), - zErrorVetex = cms.double( 0.1 ), - vertexCollection = cms.InputTag( "hltTrimmedPixelVertices" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - input = cms.InputTag( "hltIter0TrackAndTauJets4Iter1" ) - ) - ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ), - ClusterCheckPSet = cms.PSet( - PixelClusterCollectionLabel = cms.InputTag( "hltSiPixelClusters" ), - MaxNumberOfCosmicClusters = cms.uint32( 50000 ), - doClusterCheck = cms.bool( False ), - ClusterCollectionLabel = cms.InputTag( "hltSiStripClusters" ), - MaxNumberOfPixelClusters = cms.uint32( 10000 ) - ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitTripletGenerator" ), - GeneratorPSet = cms.PSet( - useBending = cms.bool( True ), - useFixedPreFiltering = cms.bool( False ), - maxElement = cms.uint32( 100000 ), - phiPreFiltering = cms.double( 0.3 ), - extraHitRPhitolerance = cms.double( 0.032 ), - useMultScattering = cms.bool( True ), - ComponentName = cms.string( "PixelTripletHLTGenerator" ), - extraHitRZtolerance = cms.double( 0.037 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) - ), - SeedingLayers = cms.InputTag( "hltIter1PixelLayerTriplets" ) - ), - SeedCreatorPSet = cms.PSet( - ComponentName = cms.string( "SeedFromConsecutiveHitsTripletOnlyCreator" ), - propagator = cms.string( "PropagatorWithMaterialParabolicMf" ), - SeedMomentumForBOFF = cms.double( 5.0 ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) - ), - TTRHBuilder = cms.string( "(unused)" ) +process.hltHISiPixelRecHits = cms.EDProducer( "SiPixelRecHitConverter", + VerboseLevel = cms.untracked.int32( 0 ), + src = cms.InputTag( "hltHISiPixelClusters" ), + CPE = cms.string( "hltESPPixelCPEGeneric" ) ) -process.hltIter1PFlowCkfTrackCandidates = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter1PFlowPixelSeeds" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter1MaskedMeasurementTrackerEvent" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter1PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) +process.hltSiStripExcludedFEDListProducer = cms.EDProducer( "SiStripExcludedFEDListProducer", + ProductLabel = cms.InputTag( "rawDataCollector" ) ) -process.hltIter1PFlowCtfWithMaterialTracks = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter1PFlowCkfTrackCandidates" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter1MaskedMeasurementTrackerEvent" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIter1" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -process.hltIter1PFlowTrackSelectionHighPurityLoose = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.9, 3.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.8, 3.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter1PFlowCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltTrimmedPixelVertices" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.9, 3.0 ), - d0_par1 = cms.vdouble( 0.85, 3.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter1PFlowTrackSelectionHighPurityTight = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 5 ), - chi2n_par = cms.double( 0.4 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 1.0, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 1.0, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter1PFlowCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltTrimmedPixelVertices" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 1.0, 4.0 ), - d0_par1 = cms.vdouble( 1.0, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter1PFlowTrackSelectionHighPurity = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter1PFlowTrackSelectionHighPurityLoose','hltIter1PFlowTrackSelectionHighPurityTight' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter1PFlowTrackSelectionHighPurityLoose','hltIter1PFlowTrackSelectionHighPurityTight' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltIter1Merged = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter0PFlowTrackSelectionHighPurity','hltIter1PFlowTrackSelectionHighPurity' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter0PFlowTrackSelectionHighPurity','hltIter1PFlowTrackSelectionHighPurity' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltIter1TrackRefsForJets4Iter2 = cms.EDProducer( "ChargedRefCandidateProducer", - src = cms.InputTag( "hltIter1Merged" ), - particleType = cms.string( "pi+" ) -) -process.hltAK4Iter1TrackJets4Iter2 = cms.EDProducer( "FastjetJetProducer", - Active_Area_Repeats = cms.int32( 5 ), - doAreaFastjet = cms.bool( False ), - voronoiRfact = cms.double( 0.9 ), - maxBadHcalCells = cms.uint32( 9999999 ), - doAreaDiskApprox = cms.bool( False ), - maxRecoveredEcalCells = cms.uint32( 9999999 ), - jetType = cms.string( "TrackJet" ), - minSeed = cms.uint32( 14327 ), - Ghost_EtaMax = cms.double( 6.0 ), - doRhoFastjet = cms.bool( False ), - jetAlgorithm = cms.string( "AntiKt" ), - nSigmaPU = cms.double( 1.0 ), - GhostArea = cms.double( 0.01 ), - Rho_EtaMax = cms.double( 4.4 ), - maxBadEcalCells = cms.uint32( 9999999 ), - useDeterministicSeed = cms.bool( True ), - doPVCorrection = cms.bool( False ), - maxRecoveredHcalCells = cms.uint32( 9999999 ), - rParam = cms.double( 0.4 ), - maxProblematicHcalCells = cms.uint32( 9999999 ), - doOutputJets = cms.bool( True ), - src = cms.InputTag( "hltIter1TrackRefsForJets4Iter2" ), - inputEtMin = cms.double( 0.1 ), - puPtMin = cms.double( 0.0 ), - srcPVs = cms.InputTag( "hltTrimmedPixelVertices" ), - jetPtMin = cms.double( 7.5 ), - radiusPU = cms.double( 0.4 ), - maxProblematicEcalCells = cms.uint32( 9999999 ), - doPUOffsetCorr = cms.bool( False ), - inputEMin = cms.double( 0.0 ), - useMassDropTagger = cms.bool( False ), - muMin = cms.double( -1.0 ), - subtractorName = cms.string( "" ), - muCut = cms.double( -1.0 ), - subjetPtMin = cms.double( -1.0 ), - useTrimming = cms.bool( False ), - muMax = cms.double( -1.0 ), - yMin = cms.double( -1.0 ), - useFiltering = cms.bool( False ), - rFilt = cms.double( -1.0 ), - yMax = cms.double( -1.0 ), - zcut = cms.double( -1.0 ), - MinVtxNdof = cms.int32( 0 ), - MaxVtxZ = cms.double( 30.0 ), - UseOnlyVertexTracks = cms.bool( False ), - dRMin = cms.double( -1.0 ), - nFilt = cms.int32( -1 ), - usePruning = cms.bool( False ), - maxDepth = cms.int32( -1 ), - yCut = cms.double( -1.0 ), - DzTrVtxMax = cms.double( 0.5 ), - UseOnlyOnePV = cms.bool( True ), - rcut_factor = cms.double( -1.0 ), - sumRecHits = cms.bool( False ), - trimPtFracMin = cms.double( -1.0 ), - dRMax = cms.double( -1.0 ), - DxyTrVtxMax = cms.double( 0.2 ), - useCMSBoostedTauSeedingAlgorithm = cms.bool( False ) -) -process.hltIter1TrackAndTauJets4Iter2 = cms.EDProducer( "TauJetSelectorForHLTTrackSeeding", - fractionMinCaloInTauCone = cms.double( 0.7 ), - fractionMaxChargedPUInCaloCone = cms.double( 0.3 ), - tauConeSize = cms.double( 0.2 ), - ptTrkMaxInCaloCone = cms.double( 1.4 ), - isolationConeSize = cms.double( 0.5 ), - inputTrackJetTag = cms.InputTag( "hltAK4Iter1TrackJets4Iter2" ), - nTrkMaxInCaloCone = cms.int32( 0 ), - inputCaloJetTag = cms.InputTag( "hltAK4CaloJetsPFEt5" ), - etaMinCaloJet = cms.double( -2.7 ), - etaMaxCaloJet = cms.double( 2.7 ), - ptMinCaloJet = cms.double( 5.0 ), - inputTrackTag = cms.InputTag( "hltIter1Merged" ) -) -process.hltIter2ClustersRefRemoval = cms.EDProducer( "TrackClusterRemover", - minNumberOfLayersWithMeasBeforeFiltering = cms.int32( 0 ), - maxChi2 = cms.double( 16.0 ), - trajectories = cms.InputTag( "hltIter1PFlowTrackSelectionHighPurity" ), - oldClusterRemovalInfo = cms.InputTag( "hltIter1ClustersRefRemoval" ), - stripClusters = cms.InputTag( "hltSiStripRawToClustersFacility" ), - overrideTrkQuals = cms.InputTag( "" ), - pixelClusters = cms.InputTag( "hltSiPixelClusters" ), - TrackQuality = cms.string( "highPurity" ) -) -process.hltIter2MaskedMeasurementTrackerEvent = cms.EDProducer( "MaskedMeasurementTrackerEventProducer", - clustersToSkip = cms.InputTag( "hltIter2ClustersRefRemoval" ), - OnDemand = cms.bool( False ), - src = cms.InputTag( "hltSiStripClusters" ) -) -process.hltIter2PixelLayerPairs = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2', - 'BPix1+BPix3', - 'BPix2+BPix3', - 'BPix1+FPix1_pos', - 'BPix1+FPix1_neg', - 'BPix1+FPix2_pos', - 'BPix1+FPix2_neg', - 'BPix2+FPix1_pos', - 'BPix2+FPix1_neg', - 'BPix2+FPix2_pos', - 'BPix2+FPix2_neg', - 'FPix1_pos+FPix2_pos', - 'FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter2ClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0051 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter2ClustersRefRemoval" ), - hitErrorRPhi = cms.double( 0.0027 ) - ), - TIB = cms.PSet( ) -) -process.hltIter2PFlowPixelSeeds = cms.EDProducer( "SeedGeneratorFromRegionHitsEDProducer", - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "CandidateSeededTrackingRegionsProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.025 ), - searchOpt = cms.bool( True ), - originZPos = cms.double( 0.0 ), - ptMin = cms.double( 1.2 ), - measurementTrackerName = cms.string( "hltIter2MaskedMeasurementTrackerEvent" ), - mode = cms.string( "VerticesFixed" ), - maxNRegions = cms.int32( 100 ), - maxNVertices = cms.int32( 10 ), - deltaPhi = cms.double( 0.8 ), - deltaEta = cms.double( 0.8 ), - zErrorBeamSpot = cms.double( 15.0 ), - nSigmaZBeamSpot = cms.double( 3.0 ), - zErrorVetex = cms.double( 0.05 ), - vertexCollection = cms.InputTag( "hltTrimmedPixelVertices" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - input = cms.InputTag( "hltIter1TrackAndTauJets4Iter2" ) - ) - ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ), - ClusterCheckPSet = cms.PSet( - PixelClusterCollectionLabel = cms.InputTag( "hltSiPixelClusters" ), - MaxNumberOfCosmicClusters = cms.uint32( 50000 ), - doClusterCheck = cms.bool( False ), - ClusterCollectionLabel = cms.InputTag( "hltSiStripClusters" ), - MaxNumberOfPixelClusters = cms.uint32( 10000 ) - ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitPairGenerator" ), - GeneratorPSet = cms.PSet( - maxElement = cms.uint32( 100000 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) - ), - SeedingLayers = cms.InputTag( "hltIter2PixelLayerPairs" ) +process.hltSiStripRawToClustersFacility = cms.EDProducer( "SiStripClusterizerFromRaw", + ProductLabel = cms.InputTag( "rawDataCollector" ), + DoAPVEmulatorCheck = cms.bool( False ), + Algorithms = cms.PSet( + SiStripFedZeroSuppressionMode = cms.uint32( 4 ), + CommonModeNoiseSubtractionMode = cms.string( "Median" ), + PedestalSubtractionFedMode = cms.bool( True ), + TruncateInSuppressor = cms.bool( True ), + doAPVRestore = cms.bool( False ), + useCMMeanMap = cms.bool( False ) ), - SeedCreatorPSet = cms.PSet( - ComponentName = cms.string( "SeedFromConsecutiveHitsCreator" ), - propagator = cms.string( "PropagatorWithMaterialParabolicMf" ), - SeedMomentumForBOFF = cms.double( 5.0 ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + Clusterizer = cms.PSet( + ChannelThreshold = cms.double( 2.0 ), + MaxSequentialBad = cms.uint32( 1 ), + MaxSequentialHoles = cms.uint32( 0 ), + Algorithm = cms.string( "ThreeThresholdAlgorithm" ), + MaxAdjacentBad = cms.uint32( 0 ), + QualityLabel = cms.string( "" ), + SeedThreshold = cms.double( 3.0 ), + ClusterThreshold = cms.double( 5.0 ), + setDetId = cms.bool( True ), + RemoveApvShots = cms.bool( True ) ), - TTRHBuilder = cms.string( "(unused)" ) + onDemand = cms.bool( True ) ) -process.hltIter2PFlowCkfTrackCandidates = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter2PFlowPixelSeeds" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter2MaskedMeasurementTrackerEvent" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter2PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) +process.hltHISiStripClusters = cms.EDProducer( "MeasurementTrackerEventProducer", + inactivePixelDetectorLabels = cms.VInputTag( ), + stripClusterProducer = cms.string( "hltSiStripRawToClustersFacility" ), + pixelClusterProducer = cms.string( "hltHISiPixelClusters" ), + switchOffPixelsIfEmpty = cms.bool( True ), + inactiveStripDetectorLabels = cms.VInputTag( 'hltSiStripExcludedFEDListProducer' ), + skipClusters = cms.InputTag( "" ), + measurementTracker = cms.string( "hltESPMeasurementTracker" ) ) -process.hltIter2PFlowCtfWithMaterialTracks = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter2PFlowCkfTrackCandidates" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter2MaskedMeasurementTrackerEvent" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIter2" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -process.hltIter2PFlowTrackSelectionHighPurity = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.4, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.35, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter2PFlowCtfWithMaterialTracks" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltTrimmedPixelVertices" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.4, 4.0 ), - d0_par1 = cms.vdouble( 0.3, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter2Merged = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter1Merged','hltIter2PFlowTrackSelectionHighPurity' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter1Merged','hltIter2PFlowTrackSelectionHighPurity' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltPFMuonMerging = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltL3TkTracksFromL2','hltIter2Merged' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltL3TkTracksFromL2','hltIter2Merged' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltMuonLinks = cms.EDProducer( "MuonLinksProducerForHLT", - pMin = cms.double( 2.5 ), - InclusiveTrackerTrackCollection = cms.InputTag( "hltPFMuonMerging" ), - shareHitFraction = cms.double( 0.8 ), - LinkCollection = cms.InputTag( "hltL3MuonsLinksCombination" ), - ptMin = cms.double( 2.5 ) -) -process.hltMuons = cms.EDProducer( "MuonIdProducer", - TrackExtractorPSet = cms.PSet( - Diff_z = cms.double( 0.2 ), - inputTrackCollection = cms.InputTag( "hltPFMuonMerging" ), - BeamSpotLabel = cms.InputTag( "hltOnlineBeamSpot" ), - ComponentName = cms.string( "TrackExtractor" ), - DR_Max = cms.double( 1.0 ), - Diff_r = cms.double( 0.1 ), - Chi2Prob_Min = cms.double( -1.0 ), - DR_Veto = cms.double( 0.01 ), - NHits_Min = cms.uint32( 0 ), - Chi2Ndof_Max = cms.double( 1.0E64 ), - Pt_Min = cms.double( -1.0 ), - DepositLabel = cms.untracked.string( "" ), - BeamlineOption = cms.string( "BeamSpotFromEvent" ) - ), - maxAbsEta = cms.double( 3.0 ), - fillGlobalTrackRefits = cms.bool( False ), - arbitrationCleanerOptions = cms.PSet( - Clustering = cms.bool( True ), - ME1a = cms.bool( True ), - ClusterDPhi = cms.double( 0.6 ), - OverlapDTheta = cms.double( 0.02 ), - Overlap = cms.bool( True ), - OverlapDPhi = cms.double( 0.0786 ), - ClusterDTheta = cms.double( 0.02 ) - ), - globalTrackQualityInputTag = cms.InputTag( "glbTrackQual" ), - addExtraSoftMuons = cms.bool( False ), - debugWithTruthMatching = cms.bool( False ), - CaloExtractorPSet = cms.PSet( - PrintTimeReport = cms.untracked.bool( False ), - DR_Max = cms.double( 1.0 ), - DepositInstanceLabels = cms.vstring( 'ecal', - 'hcal', - 'ho' ), - Noise_HE = cms.double( 0.2 ), - NoiseTow_EB = cms.double( 0.04 ), - NoiseTow_EE = cms.double( 0.15 ), - Threshold_H = cms.double( 0.5 ), - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPFastSteppingHelixPropagatorAny' ), - RPCLayers = cms.bool( False ), - UseMuonNavigation = cms.untracked.bool( False ) - ), - Threshold_E = cms.double( 0.2 ), - PropagatorName = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - DepositLabel = cms.untracked.string( "Cal" ), - UseRecHitsFlag = cms.bool( False ), - TrackAssociatorParameters = cms.PSet( - muonMaxDistanceSigmaX = cms.double( 0.0 ), - muonMaxDistanceSigmaY = cms.double( 0.0 ), - CSCSegmentCollectionLabel = cms.InputTag( "hltCscSegments" ), - dRHcal = cms.double( 1.0 ), - dRPreshowerPreselection = cms.double( 0.2 ), - CaloTowerCollectionLabel = cms.InputTag( "hltTowerMakerForPF" ), - useEcal = cms.bool( False ), - dREcal = cms.double( 1.0 ), - dREcalPreselection = cms.double( 1.0 ), - HORecHitCollectionLabel = cms.InputTag( "hltHoreco" ), - dRMuon = cms.double( 9999.0 ), - propagateAllDirections = cms.bool( True ), - muonMaxDistanceX = cms.double( 5.0 ), - muonMaxDistanceY = cms.double( 5.0 ), - useHO = cms.bool( False ), - trajectoryUncertaintyTolerance = cms.double( -1.0 ), - usePreshower = cms.bool( False ), - DTRecSegment4DCollectionLabel = cms.InputTag( "hltDt4DSegments" ), - EERecHitCollectionLabel = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEE' ), - dRHcalPreselection = cms.double( 1.0 ), - useMuon = cms.bool( False ), - useCalo = cms.bool( True ), - accountForTrajectoryChangeCalo = cms.bool( False ), - EBRecHitCollectionLabel = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEB' ), - dRMuonPreselection = cms.double( 0.2 ), - truthMatch = cms.bool( False ), - HBHERecHitCollectionLabel = cms.InputTag( "hltHbhereco" ), - useHcal = cms.bool( False ) - ), - Threshold_HO = cms.double( 0.5 ), - Noise_EE = cms.double( 0.1 ), - Noise_EB = cms.double( 0.025 ), - DR_Veto_H = cms.double( 0.1 ), - CenterConeOnCalIntersection = cms.bool( False ), - ComponentName = cms.string( "CaloExtractorByAssociator" ), - Noise_HB = cms.double( 0.2 ), - DR_Veto_E = cms.double( 0.07 ), - DR_Veto_HO = cms.double( 0.1 ), - Noise_HO = cms.double( 0.2 ) - ), - runArbitrationCleaner = cms.bool( False ), - fillEnergy = cms.bool( True ), - TrackerKinkFinderParameters = cms.PSet( - usePosition = cms.bool( False ), - diagonalOnly = cms.bool( False ) - ), - TimingFillerParameters = cms.PSet( - UseDT = cms.bool( True ), - ErrorDT = cms.double( 6.0 ), - EcalEnergyCut = cms.double( 0.4 ), - ErrorEB = cms.double( 2.085 ), - ErrorCSC = cms.double( 7.4 ), - CSCTimingParameters = cms.PSet( - CSCsegments = cms.InputTag( "hltCscSegments" ), - CSCTimeOffset = cms.double( 0.0 ), - CSCStripTimeOffset = cms.double( 0.0 ), - MatchParameters = cms.PSet( - CSCsegments = cms.InputTag( "hltCscSegments" ), - DTsegments = cms.InputTag( "hltDt4DSegments" ), - DTradius = cms.double( 0.01 ), - TightMatchDT = cms.bool( False ), - TightMatchCSC = cms.bool( True ) - ), - debug = cms.bool( False ), - UseStripTime = cms.bool( True ), - CSCStripError = cms.double( 7.0 ), - CSCWireError = cms.double( 8.6 ), - CSCWireTimeOffset = cms.double( 0.0 ), - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPFastSteppingHelixPropagatorAny' ), - RPCLayers = cms.bool( True ) - ), - PruneCut = cms.double( 100.0 ), - UseWireTime = cms.bool( True ) - ), - DTTimingParameters = cms.PSet( - HitError = cms.double( 6.0 ), - DoWireCorr = cms.bool( False ), - MatchParameters = cms.PSet( - CSCsegments = cms.InputTag( "hltCscSegments" ), - DTsegments = cms.InputTag( "hltDt4DSegments" ), - DTradius = cms.double( 0.01 ), - TightMatchDT = cms.bool( False ), - TightMatchCSC = cms.bool( True ) - ), - debug = cms.bool( False ), - DTsegments = cms.InputTag( "hltDt4DSegments" ), - PruneCut = cms.double( 10000.0 ), - RequireBothProjections = cms.bool( False ), - HitsMin = cms.int32( 5 ), - DTTimeOffset = cms.double( 2.7 ), - DropTheta = cms.bool( True ), - UseSegmentT0 = cms.bool( False ), - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPFastSteppingHelixPropagatorAny' ), - RPCLayers = cms.bool( True ) - ) - ), - ErrorEE = cms.double( 6.95 ), - UseCSC = cms.bool( True ), - UseECAL = cms.bool( True ) - ), - inputCollectionTypes = cms.vstring( 'inner tracks', - 'links', - 'outer tracks' ), - minCaloCompatibility = cms.double( 0.6 ), - ecalDepositName = cms.string( "ecal" ), - minP = cms.double( 10.0 ), - fillIsolation = cms.bool( True ), - jetDepositName = cms.string( "jets" ), - hoDepositName = cms.string( "ho" ), - writeIsoDeposits = cms.bool( False ), - maxAbsPullX = cms.double( 4.0 ), - maxAbsPullY = cms.double( 9999.0 ), - minPt = cms.double( 10.0 ), - TrackAssociatorParameters = cms.PSet( - muonMaxDistanceSigmaX = cms.double( 0.0 ), - muonMaxDistanceSigmaY = cms.double( 0.0 ), - CSCSegmentCollectionLabel = cms.InputTag( "hltCscSegments" ), - dRHcal = cms.double( 9999.0 ), - dRPreshowerPreselection = cms.double( 0.2 ), - CaloTowerCollectionLabel = cms.InputTag( "hltTowerMakerForPF" ), - useEcal = cms.bool( True ), - dREcal = cms.double( 9999.0 ), - dREcalPreselection = cms.double( 0.05 ), - HORecHitCollectionLabel = cms.InputTag( "hltHoreco" ), - dRMuon = cms.double( 9999.0 ), - propagateAllDirections = cms.bool( True ), - muonMaxDistanceX = cms.double( 5.0 ), - muonMaxDistanceY = cms.double( 5.0 ), - useHO = cms.bool( True ), - trajectoryUncertaintyTolerance = cms.double( -1.0 ), - usePreshower = cms.bool( False ), - DTRecSegment4DCollectionLabel = cms.InputTag( "hltDt4DSegments" ), - EERecHitCollectionLabel = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEE' ), - dRHcalPreselection = cms.double( 0.2 ), - useMuon = cms.bool( True ), - useCalo = cms.bool( False ), - accountForTrajectoryChangeCalo = cms.bool( False ), - EBRecHitCollectionLabel = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEB' ), - dRMuonPreselection = cms.double( 0.2 ), - truthMatch = cms.bool( False ), - HBHERecHitCollectionLabel = cms.InputTag( "hltHbhereco" ), - useHcal = cms.bool( True ) - ), - JetExtractorPSet = cms.PSet( - PrintTimeReport = cms.untracked.bool( False ), - ExcludeMuonVeto = cms.bool( True ), - TrackAssociatorParameters = cms.PSet( - muonMaxDistanceSigmaX = cms.double( 0.0 ), - muonMaxDistanceSigmaY = cms.double( 0.0 ), - CSCSegmentCollectionLabel = cms.InputTag( "hltCscSegments" ), - dRHcal = cms.double( 0.5 ), - dRPreshowerPreselection = cms.double( 0.2 ), - CaloTowerCollectionLabel = cms.InputTag( "hltTowerMakerForPF" ), - useEcal = cms.bool( False ), - dREcal = cms.double( 0.5 ), - dREcalPreselection = cms.double( 0.5 ), - HORecHitCollectionLabel = cms.InputTag( "hltHoreco" ), - dRMuon = cms.double( 9999.0 ), - propagateAllDirections = cms.bool( True ), - muonMaxDistanceX = cms.double( 5.0 ), - muonMaxDistanceY = cms.double( 5.0 ), - useHO = cms.bool( False ), - trajectoryUncertaintyTolerance = cms.double( -1.0 ), - usePreshower = cms.bool( False ), - DTRecSegment4DCollectionLabel = cms.InputTag( "hltDt4DSegments" ), - EERecHitCollectionLabel = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEE' ), - dRHcalPreselection = cms.double( 0.5 ), - useMuon = cms.bool( False ), - useCalo = cms.bool( True ), - accountForTrajectoryChangeCalo = cms.bool( False ), - EBRecHitCollectionLabel = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEB' ), - dRMuonPreselection = cms.double( 0.2 ), - truthMatch = cms.bool( False ), - HBHERecHitCollectionLabel = cms.InputTag( "hltHbhereco" ), - useHcal = cms.bool( False ) - ), - ServiceParameters = cms.PSet( - Propagators = cms.untracked.vstring( 'hltESPFastSteppingHelixPropagatorAny' ), - RPCLayers = cms.bool( False ), - UseMuonNavigation = cms.untracked.bool( False ) - ), - ComponentName = cms.string( "JetExtractor" ), - DR_Max = cms.double( 1.0 ), - PropagatorName = cms.string( "hltESPFastSteppingHelixPropagatorAny" ), - JetCollectionLabel = cms.InputTag( "hltAK4CaloJetsPFEt5" ), - DR_Veto = cms.double( 0.1 ), - Threshold = cms.double( 5.0 ) - ), - fillGlobalTrackQuality = cms.bool( False ), - minPCaloMuon = cms.double( 1.0E9 ), - maxAbsDy = cms.double( 9999.0 ), - fillCaloCompatibility = cms.bool( True ), - fillMatching = cms.bool( True ), - MuonCaloCompatibility = cms.PSet( - allSiPMHO = cms.bool( False ), - PionTemplateFileName = cms.FileInPath( "RecoMuon/MuonIdentification/data/MuID_templates_pions_lowPt_3_1_norm.root" ), - MuonTemplateFileName = cms.FileInPath( "RecoMuon/MuonIdentification/data/MuID_templates_muons_lowPt_3_1_norm.root" ), - delta_eta = cms.double( 0.02 ), - delta_phi = cms.double( 0.02 ) - ), - fillTrackerKink = cms.bool( False ), - hcalDepositName = cms.string( "hcal" ), - sigmaThresholdToFillCandidateP4WithGlobalFit = cms.double( 2.0 ), - inputCollectionLabels = cms.VInputTag( 'hltPFMuonMerging','hltMuonLinks','hltL2Muons' ), - trackDepositName = cms.string( "tracker" ), - maxAbsDx = cms.double( 3.0 ), - ptThresholdToFillCandidateP4WithGlobalFit = cms.double( 200.0 ), - minNumberOfMatches = cms.int32( 1 ) -) -process.hltParticleFlowRecHitECALUnseeded = cms.EDProducer( "PFRecHitProducer", - producers = cms.VPSet( - cms.PSet( src = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEB' ), - qualityTests = cms.VPSet( - cms.PSet( threshold = cms.double( 0.08 ), - name = cms.string( "PFRecHitQTestThreshold" ) +process.hltHIL3TrajSeedOIState = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + propagatorCompatibleName = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + option = cms.uint32( 3 ), + maxChi2 = cms.double( 40.0 ), + errorMatrixPset = cms.PSet( + atIP = cms.bool( True ), + action = cms.string( "use" ), + errorMatrixValuesPSet = cms.PSet( + pf3_V12 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) ), - cms.PSet( timingCleaning = cms.bool( True ), - topologicalCleaning = cms.bool( True ), - cleaningThreshold = cms.double( 2.0 ), - skipTTRecoveredHits = cms.bool( True ), - name = cms.string( "PFRecHitQTestECAL" ) - ) - ), - name = cms.string( "PFEBRecHitCreator" ) - ), - cms.PSet( src = cms.InputTag( 'hltEcalRecHit','EcalRecHitsEE' ), - qualityTests = cms.VPSet( - cms.PSet( threshold = cms.double( 0.3 ), - name = cms.string( "PFRecHitQTestThreshold" ) + pf3_V13 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) ), - cms.PSet( timingCleaning = cms.bool( True ), - topologicalCleaning = cms.bool( True ), - cleaningThreshold = cms.double( 2.0 ), - skipTTRecoveredHits = cms.bool( True ), - name = cms.string( "PFRecHitQTestECAL" ) - ) - ), - name = cms.string( "PFEERecHitCreator" ) - ) - ), - navigator = cms.PSet( - barrel = cms.PSet( ), - endcap = cms.PSet( ), - name = cms.string( "PFRecHitECALNavigator" ) - ) -) -process.hltParticleFlowRecHitHCAL = cms.EDProducer( "PFCTRecHitProducer", - ECAL_Compensate = cms.bool( False ), - ECAL_Dead_Code = cms.uint32( 10 ), - MinLongTiming_Cut = cms.double( -5.0 ), - ECAL_Compensation = cms.double( 0.5 ), - MaxLongTiming_Cut = cms.double( 5.0 ), - weight_HFhad = cms.double( 1.0 ), - ApplyPulseDPG = cms.bool( False ), - navigator = cms.PSet( name = cms.string( "PFRecHitCaloTowerNavigator" ) ), - ECAL_Threshold = cms.double( 10.0 ), - ApplyTimeDPG = cms.bool( False ), - caloTowers = cms.InputTag( "hltTowerMakerForPF" ), - hcalRecHitsHBHE = cms.InputTag( "hltHbhereco" ), - LongFibre_Fraction = cms.double( 0.1 ), - MaxShortTiming_Cut = cms.double( 5.0 ), - HcalMaxAllowedHFLongShortSev = cms.int32( 9 ), - thresh_Barrel = cms.double( 0.4 ), - navigation_HF = cms.bool( True ), - HcalMaxAllowedHFInTimeWindowSev = cms.int32( 9 ), - HF_Calib_29 = cms.double( 1.07 ), - LongFibre_Cut = cms.double( 120.0 ), - EM_Depth = cms.double( 22.0 ), - weight_HFem = cms.double( 1.0 ), - LongShortFibre_Cut = cms.double( 1.0E9 ), - MinShortTiming_Cut = cms.double( -5.0 ), - HCAL_Calib = cms.bool( True ), - thresh_HF = cms.double( 0.4 ), - HcalMaxAllowedHFDigiTimeSev = cms.int32( 9 ), - thresh_Endcap = cms.double( 0.4 ), - HcalMaxAllowedChannelStatusSev = cms.int32( 9 ), - hcalRecHitsHF = cms.InputTag( "hltHfreco" ), - ShortFibre_Cut = cms.double( 60.0 ), - ApplyLongShortDPG = cms.bool( True ), - HF_Calib = cms.bool( True ), - HAD_Depth = cms.double( 47.0 ), - ShortFibre_Fraction = cms.double( 0.01 ), - HCAL_Calib_29 = cms.double( 1.35 ) -) -process.hltParticleFlowRecHitPSUnseeded = cms.EDProducer( "PFRecHitProducer", - producers = cms.VPSet( - cms.PSet( src = cms.InputTag( 'hltEcalPreshowerRecHit','EcalRecHitsES' ), - qualityTests = cms.VPSet( - cms.PSet( threshold = cms.double( 7.0E-6 ), - name = cms.string( "PFRecHitQTestThreshold" ) - ) - ), - name = cms.string( "PFPSRecHitCreator" ) - ) - ), - navigator = cms.PSet( name = cms.string( "PFRecHitPreshowerNavigator" ) ) -) -process.hltParticleFlowClusterECALUncorrectedUnseeded = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.08 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( 9 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - minFracTot = cms.double( 1.0E-20 ), - positionCalcForConvergence = cms.PSet( - minFractionInCalc = cms.double( 0.0 ), - W0 = cms.double( 4.2 ), - minAllowedNormalization = cms.double( 0.0 ), - T0_EB = cms.double( 7.4 ), - X0 = cms.double( 0.89 ), - T0_ES = cms.double( 1.2 ), - T0_EE = cms.double( 3.1 ), - algoName = cms.string( "ECAL2DPositionCalcWithDepthCorr" ) - ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 1.5 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "ECAL_BARREL" ), - recHitEnergyNorm = cms.double( 0.08 ) - ), - cms.PSet( detector = cms.string( "ECAL_ENDCAP" ), - recHitEnergyNorm = cms.double( 0.3 ) - ) - ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ), - allCellsPositionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.08 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ) - ), - positionReCalc = cms.PSet( - minFractionInCalc = cms.double( 0.0 ), - W0 = cms.double( 4.2 ), - minAllowedNormalization = cms.double( 0.0 ), - T0_EB = cms.double( 7.4 ), - X0 = cms.double( 0.89 ), - T0_ES = cms.double( 1.2 ), - T0_EE = cms.double( 3.1 ), - algoName = cms.string( "ECAL2DPositionCalcWithDepthCorr" ) - ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 0.08 ), - detector = cms.string( "ECAL_BARREL" ), - gatheringThresholdPt = cms.double( 0.0 ) - ), - cms.PSet( gatheringThreshold = cms.double( 0.3 ), - detector = cms.string( "ECAL_ENDCAP" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) - ), - useCornerCells = cms.bool( True ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - cms.PSet( cleaningByDetector = cms.VPSet( - cms.PSet( doubleSpikeS6S2 = cms.double( 0.04 ), - fractionThresholdModifier = cms.double( 3.0 ), - doubleSpikeThresh = cms.double( 10.0 ), - minS4S1_b = cms.double( -0.024 ), - singleSpikeThresh = cms.double( 4.0 ), - detector = cms.string( "ECAL_BARREL" ), - minS4S1_a = cms.double( 0.04 ), - energyThresholdModifier = cms.double( 2.0 ) - ), - cms.PSet( doubleSpikeS6S2 = cms.double( -1.0 ), - fractionThresholdModifier = cms.double( 3.0 ), - doubleSpikeThresh = cms.double( 1.0E9 ), - minS4S1_b = cms.double( -0.0125 ), - singleSpikeThresh = cms.double( 15.0 ), - detector = cms.string( "ECAL_ENDCAP" ), - minS4S1_a = cms.double( 0.02 ), - energyThresholdModifier = cms.double( 2.0 ) - ) -), - algoName = cms.string( "SpikeAndDoubleSpikeCleaner" ) - ) - ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 8 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 0.6 ), - seedingThresholdPt = cms.double( 0.15 ), - detector = cms.string( "ECAL_ENDCAP" ) - ), - cms.PSet( seedingThreshold = cms.double( 0.23 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "ECAL_BARREL" ) - ) - ), - algoName = cms.string( "LocalMaximumSeedFinder" ) - ), - recHitsSource = cms.InputTag( "hltParticleFlowRecHitECALUnseeded" ) -) -process.hltParticleFlowClusterPSUnseeded = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - minFracTot = cms.double( 1.0E-20 ), - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 6.0E-5 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 0.3 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "PS1" ), - recHitEnergyNorm = cms.double( 6.0E-5 ) - ), - cms.PSet( detector = cms.string( "PS2" ), - recHitEnergyNorm = cms.double( 6.0E-5 ) - ) - ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ) - ), - positionReCalc = cms.PSet( ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 6.0E-5 ), - detector = cms.string( "PS1" ), - gatheringThresholdPt = cms.double( 0.0 ) - ), - cms.PSet( gatheringThreshold = cms.double( 6.0E-5 ), - detector = cms.string( "PS2" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) - ), - useCornerCells = cms.bool( False ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 4 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 1.2E-4 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "PS1" ) - ), - cms.PSet( seedingThreshold = cms.double( 1.2E-4 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "PS2" ) - ) - ), - algoName = cms.string( "LocalMaximumSeedFinder" ) - ), - recHitsSource = cms.InputTag( "hltParticleFlowRecHitPSUnseeded" ) -) -process.hltParticleFlowClusterECALUnseeded = cms.EDProducer( "CorrectedECALPFClusterProducer", - inputPS = cms.InputTag( "hltParticleFlowClusterPSUnseeded" ), - minimumPSEnergy = cms.double( 0.0 ), - energyCorrector = cms.PSet( - applyCrackCorrections = cms.bool( False ), - algoName = cms.string( "PFClusterEMEnergyCorrector" ) - ), - inputECAL = cms.InputTag( "hltParticleFlowClusterECALUncorrectedUnseeded" ) -) -process.hltParticleFlowClusterHCAL = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( 5 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - minFracTot = cms.double( 1.0E-20 ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 10.0 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "HCAL_BARREL1" ), - recHitEnergyNorm = cms.double( 0.8 ) - ), - cms.PSet( detector = cms.string( "HCAL_ENDCAP" ), - recHitEnergyNorm = cms.double( 0.8 ) - ) - ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ), - allCellsPositionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ) - ), - positionReCalc = cms.PSet( ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 0.8 ), - detector = cms.string( "HCAL_BARREL1" ), - gatheringThresholdPt = cms.double( 0.0 ) - ), - cms.PSet( gatheringThreshold = cms.double( 0.8 ), - detector = cms.string( "HCAL_ENDCAP" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) - ), - useCornerCells = cms.bool( True ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - cms.PSet( algoName = cms.string( "RBXAndHPDCleaner" ) ) - ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 4 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 0.8 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "HCAL_BARREL1" ) - ), - cms.PSet( seedingThreshold = cms.double( 1.1 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "HCAL_ENDCAP" ) + pf3_V11 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V14 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V15 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), + pf3_V33 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + zAxis = cms.vdouble( -3.14159, 3.14159 ), + pf3_V44 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), + pf3_V22 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V23 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V45 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V55 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V34 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V35 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V25 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V24 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ) ) ), - algoName = cms.string( "LocalMaximumSeedFinder" ) + propagatorName = cms.string( "hltESPSteppingHelixPropagatorAlong" ), + manySeeds = cms.bool( False ), + copyMuonRecHit = cms.bool( False ), + ComponentName = cms.string( "TSGForRoadSearch" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ) ), - recHitsSource = cms.InputTag( "hltParticleFlowRecHitHCAL" ) -) -process.hltParticleFlowClusterHFEM = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( 5 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ), - minFracTot = cms.double( 1.0E-20 ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 10.0 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "HF_EM" ), - recHitEnergyNorm = cms.double( 0.8 ) - ) - ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ), - allCellsPositionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ) + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSteppingHelixPropagatorOpposite', + 'hltESPSteppingHelixPropagatorAlong' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) ), - positionReCalc = cms.PSet( ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 0.8 ), - detector = cms.string( "HF_EM" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) - ), - useCornerCells = cms.bool( False ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( ), + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( ), + PtCut = cms.double( 1.0 ) +) +process.hltHIL3TrackCandidateFromL2OIState = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedOIState" ), + reverseTrajectories = cms.bool( True ), + TransientInitialStateEstimatorParameters = cms.PSet( + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), + numberMeasurementsForFit = cms.int32( 4 ), + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - cms.PSet( cleaningByDetector = cms.VPSet( - cms.PSet( doubleSpikeS6S2 = cms.double( -1.0 ), - fractionThresholdModifier = cms.double( 1.0 ), - doubleSpikeThresh = cms.double( 1.0E9 ), - minS4S1_b = cms.double( -0.19 ), - singleSpikeThresh = cms.double( 80.0 ), - detector = cms.string( "HF_EM" ), - minS4S1_a = cms.double( 0.11 ), - energyThresholdModifier = cms.double( 1.0 ) - ) -), - algoName = cms.string( "SpikeAndDoubleSpikeCleaner" ) - ) + TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + cleanTrajectoryAfterInOut = cms.bool( False ), + useHitsSplitting = cms.bool( False ), + RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), + doSeedingRegionRebuilding = cms.bool( False ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilderSeedHit" ) ), + NavigationSchool = cms.string( "SimpleNavigationSchool" ), + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) +) +process.hltHIL3TkTracksFromL2OIState = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2OIState" ), + SimpleMagneticField = cms.string( "" ), + clusterRemovalInfo = cms.InputTag( "" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), + useHitsSplitting = cms.bool( False ), + MeasurementTracker = cms.string( "" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), + NavigationSchool = cms.string( "" ), + TrajectoryInEvent = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + GeometricInnerState = cms.bool( True ), + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +process.hltHIL3MuonsOIState = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 0 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 1.4 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "HF_EM" ) - ) + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) ), - algoName = cms.string( "LocalMaximumSeedFinder" ) - ), - recHitsSource = cms.InputTag( 'hltParticleFlowRecHitHCAL','HFEM' ) -) -process.hltParticleFlowClusterHFHAD = cms.EDProducer( "PFClusterProducer", - pfClusterBuilder = cms.PSet( - positionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( 5 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) ), - minFracTot = cms.double( 1.0E-20 ), - maxIterations = cms.uint32( 50 ), - stoppingTolerance = cms.double( 1.0E-8 ), - minFractionToKeep = cms.double( 1.0E-7 ), - excludeOtherSeeds = cms.bool( True ), - showerSigma = cms.double( 10.0 ), - recHitEnergyNorms = cms.VPSet( - cms.PSet( detector = cms.string( "HF_HAD" ), - recHitEnergyNorm = cms.double( 0.8 ) - ) + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) ), - algoName = cms.string( "Basic2DGenericPFlowClusterizer" ), - allCellsPositionCalc = cms.PSet( - minFractionInCalc = cms.double( 1.0E-9 ), - logWeightDenominator = cms.double( 0.8 ), - minAllowedNormalization = cms.double( 1.0E-9 ), - posCalcNCrystals = cms.int32( -1 ), - algoName = cms.string( "Basic2DGenericPFlowPositionCalc" ) - ) - ), - positionReCalc = cms.PSet( ), - initialClusteringStep = cms.PSet( - thresholdsByDetector = cms.VPSet( - cms.PSet( gatheringThreshold = cms.double( 0.8 ), - detector = cms.string( "HF_HAD" ), - gatheringThresholdPt = cms.double( 0.0 ) - ) + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) ), - useCornerCells = cms.bool( False ), - algoName = cms.string( "Basic2DGenericTopoClusterizer" ) - ), - energyCorrector = cms.PSet( ), - recHitCleaners = cms.VPSet( - cms.PSet( cleaningByDetector = cms.VPSet( - cms.PSet( doubleSpikeS6S2 = cms.double( -1.0 ), - fractionThresholdModifier = cms.double( 1.0 ), - doubleSpikeThresh = cms.double( 1.0E9 ), - minS4S1_b = cms.double( -0.08 ), - singleSpikeThresh = cms.double( 120.0 ), - detector = cms.string( "HF_HAD" ), - minS4S1_a = cms.double( 0.045 ), - energyThresholdModifier = cms.double( 1.0 ) - ) -), - algoName = cms.string( "SpikeAndDoubleSpikeCleaner" ) - ) + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2OIState" ), + tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) ), - seedFinder = cms.PSet( - nNeighbours = cms.int32( 0 ), - thresholdsByDetector = cms.VPSet( - cms.PSet( seedingThreshold = cms.double( 1.4 ), - seedingThresholdPt = cms.double( 0.0 ), - detector = cms.string( "HF_HAD" ) - ) + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) ), - algoName = cms.string( "LocalMaximumSeedFinder" ) + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) ), - recHitsSource = cms.InputTag( 'hltParticleFlowRecHitHCAL','HFHAD' ) -) -process.hltLightPFTracks = cms.EDProducer( "LightPFTrackProducer", - TrackQuality = cms.string( "none" ), - UseQuality = cms.bool( False ), - TkColList = cms.VInputTag( 'hltPFMuonMerging' ) + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) ) -process.hltParticleFlowBlock = cms.EDProducer( "PFBlockProducer", - debug = cms.untracked.bool( False ), - linkDefinitions = cms.VPSet( - cms.PSet( useKDTree = cms.bool( True ), - linkType = cms.string( "PS1:ECAL" ), - linkerName = cms.string( "PreshowerAndECALLinker" ) - ), - cms.PSet( useKDTree = cms.bool( True ), - linkType = cms.string( "PS2:ECAL" ), - linkerName = cms.string( "PreshowerAndECALLinker" ) - ), - cms.PSet( useKDTree = cms.bool( True ), - linkType = cms.string( "TRACK:ECAL" ), - linkerName = cms.string( "TrackAndECALLinker" ) - ), - cms.PSet( useKDTree = cms.bool( True ), - linkType = cms.string( "TRACK:HCAL" ), - linkerName = cms.string( "TrackAndHCALLinker" ) - ), - cms.PSet( useKDTree = cms.bool( False ), - linkType = cms.string( "ECAL:HCAL" ), - linkerName = cms.string( "ECALAndHCALLinker" ) - ), - cms.PSet( useKDTree = cms.bool( False ), - linkType = cms.string( "HFEM:HFHAD" ), - linkerName = cms.string( "HFEMAndHFHADLinker" ) - ) - ), - elementImporters = cms.VPSet( - cms.PSet( importerName = cms.string( "GeneralTracksImporter" ), - useIterativeTracking = cms.bool( False ), - source = cms.InputTag( "hltLightPFTracks" ), - NHitCuts_byTrackAlgo = cms.vuint32( 3, 3, 3, 3, 3 ), - muonSrc = cms.InputTag( "hltMuons" ), - DPtOverPtCuts_byTrackAlgo = cms.vdouble( 0.5, 0.5, 0.5, 0.5, 0.5 ) - ), - cms.PSet( importerName = cms.string( "ECALClusterImporter" ), - source = cms.InputTag( "hltParticleFlowClusterECALUnseeded" ), - BCtoPFCMap = cms.InputTag( "" ) - ), - cms.PSet( importerName = cms.string( "GenericClusterImporter" ), - source = cms.InputTag( "hltParticleFlowClusterHCAL" ) - ), - cms.PSet( importerName = cms.string( "GenericClusterImporter" ), - source = cms.InputTag( "hltParticleFlowClusterHFEM" ) - ), - cms.PSet( importerName = cms.string( "GenericClusterImporter" ), - source = cms.InputTag( "hltParticleFlowClusterHFHAD" ) +process.hltHIL3TrajSeedOIHit = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + PSetNames = cms.vstring( 'skipTSG', + 'iterativeTSG' ), + L3TkCollectionA = cms.InputTag( "hltHIL3MuonsOIState" ), + iterativeTSG = cms.PSet( + ErrorRescaling = cms.double( 3.0 ), + beamSpot = cms.InputTag( "unused" ), + MaxChi2 = cms.double( 40.0 ), + errorMatrixPset = cms.PSet( + atIP = cms.bool( True ), + action = cms.string( "use" ), + errorMatrixValuesPSet = cms.PSet( + pf3_V12 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V13 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V11 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V14 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V15 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + yAxis = cms.vdouble( 0.0, 1.0, 1.4, 10.0 ), + pf3_V33 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + zAxis = cms.vdouble( -3.14159, 3.14159 ), + pf3_V44 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + xAxis = cms.vdouble( 0.0, 13.0, 30.0, 70.0, 1000.0 ), + pf3_V22 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V23 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V45 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V55 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 3.0, 3.0, 3.0, 5.0, 4.0, 5.0, 10.0, 7.0, 10.0, 10.0, 10.0, 10.0 ) + ), + pf3_V34 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V35 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V25 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ), + pf3_V24 = cms.PSet( + action = cms.string( "scale" ), + values = cms.vdouble( 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ) + ) + ) + ), + UpdateState = cms.bool( True ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + SelectState = cms.bool( False ), + SigmaZ = cms.double( 25.0 ), + ResetMethod = cms.string( "matrix" ), + ComponentName = cms.string( "TSGFromPropagation" ), + UseVertexState = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAnyOpposite" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ) ), - cms.PSet( importerName = cms.string( "GenericClusterImporter" ), - source = cms.InputTag( "hltParticleFlowClusterPSUnseeded" ) - ) - ), - verbose = cms.untracked.bool( False ) -) -process.hltParticleFlow = cms.EDProducer( "PFProducer", - photon_SigmaiEtaiEta_endcap = cms.double( 0.034 ), - minPtForPostCleaning = cms.double( 20.0 ), - pf_nsigma_ECAL = cms.double( 0.0 ), - GedPhotonValueMap = cms.InputTag( 'tmpGedPhotons','valMapPFEgammaCandToPhoton' ), - sumPtTrackIsoForPhoton = cms.double( -1.0 ), - metFactorForFakes = cms.double( 4.0 ), - muon_HO = cms.vdouble( 0.9, 0.9 ), - electron_missinghits = cms.uint32( 1 ), - metSignificanceForCleaning = cms.double( 3.0 ), - usePFPhotons = cms.bool( False ), - dptRel_DispVtx = cms.double( 10.0 ), - nTrackIsoForEgammaSC = cms.uint32( 2 ), - pf_nsigma_HCAL = cms.double( 1.0 ), - cosmicRejectionDistance = cms.double( 1.0 ), - useEGammaFilters = cms.bool( False ), - useEGammaElectrons = cms.bool( False ), - nsigma_TRACK = cms.double( 1.0 ), - useEGammaSupercluster = cms.bool( False ), - sumPtTrackIsoForEgammaSC_barrel = cms.double( 4.0 ), - eventFractionForCleaning = cms.double( 0.8 ), - usePFDecays = cms.bool( False ), - rejectTracks_Step45 = cms.bool( False ), - eventFractionForRejection = cms.double( 0.8 ), - photon_MinEt = cms.double( 10.0 ), - usePFNuclearInteractions = cms.bool( False ), - maxSignificance = cms.double( 2.5 ), - electron_iso_mva_endcap = cms.double( -0.1075 ), - debug = cms.untracked.bool( False ), - pf_convID_mvaWeightFile = cms.string( "RecoParticleFlow/PFProducer/data/MVAnalysis_BDT.weights_pfConversionAug0411.txt" ), - calibHF_eta_step = cms.vdouble( 0.0, 2.9, 3.0, 3.2, 4.2, 4.4, 4.6, 4.8, 5.2, 5.4 ), - ptErrorScale = cms.double( 8.0 ), - minSignificance = cms.double( 2.5 ), - minMomentumForPunchThrough = cms.double( 100.0 ), - pf_conv_mvaCut = cms.double( 0.0 ), - useCalibrationsFromDB = cms.bool( True ), - usePFElectrons = cms.bool( False ), - electron_iso_combIso_endcap = cms.double( 10.0 ), - photon_combIso = cms.double( 10.0 ), - electron_iso_mva_barrel = cms.double( -0.1875 ), - postHFCleaning = cms.bool( False ), - factors_45 = cms.vdouble( 10.0, 100.0 ), - cleanedHF = cms.VInputTag( 'hltParticleFlowRecHitHCAL:Cleaned','hltParticleFlowClusterHFHAD:Cleaned','hltParticleFlowClusterHFEM:Cleaned' ), - coneEcalIsoForEgammaSC = cms.double( 0.3 ), - minSignificanceReduction = cms.double( 1.4 ), - photon_SigmaiEtaiEta_barrel = cms.double( 0.0125 ), - calibHF_b_HADonly = cms.vdouble( 1.27541, 0.85361, 0.86333, 0.89091, 0.94348, 0.94348, 0.9437, 1.0034, 1.0444, 1.0444 ), - minPixelHits = cms.int32( 1 ), - maxDPtOPt = cms.double( 1.0 ), - useHO = cms.bool( False ), - pf_electron_output_col = cms.string( "electrons" ), - electron_noniso_mvaCut = cms.double( -0.1 ), - GedElectronValueMap = cms.InputTag( "gedGsfElectronsTmp" ), - useVerticesForNeutral = cms.bool( True ), - pf_Res_mvaWeightFile = cms.string( "RecoParticleFlow/PFProducer/data/TMVARegression_BDTG_PFRes.root" ), - PFEGammaCandidates = cms.InputTag( "particleFlowEGamma" ), - sumPtTrackIsoSlopeForPhoton = cms.double( -1.0 ), - coneTrackIsoForEgammaSC = cms.double( 0.3 ), - minDeltaMet = cms.double( 0.4 ), - pt_Error = cms.double( 1.0 ), - useProtectionsForJetMET = cms.bool( True ), - metFactorForRejection = cms.double( 4.0 ), - sumPtTrackIsoForEgammaSC_endcap = cms.double( 4.0 ), - calibHF_use = cms.bool( False ), - verbose = cms.untracked.bool( False ), - usePFConversions = cms.bool( False ), - trackQuality = cms.string( "highPurity" ), - calibPFSCEle_endcap = cms.vdouble( 1.153, -16.5975, 5.668, -0.1772, 16.22, 7.326, 0.0483, -4.068, 9.406 ), - metFactorForCleaning = cms.double( 4.0 ), - eventFactorForCosmics = cms.double( 10.0 ), - egammaElectrons = cms.InputTag( "" ), - minEnergyForPunchThrough = cms.double( 100.0 ), - minTrackerHits = cms.int32( 8 ), - iCfgCandConnector = cms.PSet( - bCalibSecondary = cms.bool( False ), - bCalibPrimary = cms.bool( False ), - bCorrect = cms.bool( False ), - nuclCalibFactors = cms.vdouble( 0.8, 0.15, 0.5, 0.5, 0.05 ) + skipTSG = cms.PSet( ), + ComponentName = cms.string( "DualByL2TSG" ) ), - rejectTracks_Bad = cms.bool( False ), - pf_electronID_crackCorrection = cms.bool( False ), - pf_locC_mvaWeightFile = cms.string( "RecoParticleFlow/PFProducer/data/TMVARegression_BDTG_PFClusterCorr.root" ), - calibHF_a_EMonly = cms.vdouble( 0.96945, 0.96701, 0.76309, 0.82268, 0.87583, 0.89718, 0.98674, 1.4681, 1.458, 1.458 ), - muons = cms.InputTag( "hltMuons" ), - metFactorForHighEta = cms.double( 25.0 ), - minHFCleaningPt = cms.double( 5.0 ), - muon_HCAL = cms.vdouble( 3.0, 3.0 ), - pf_electron_mvaCut = cms.double( -0.1 ), - ptFactorForHighEta = cms.double( 2.0 ), - maxDeltaPhiPt = cms.double( 7.0 ), - pf_electronID_mvaWeightFile = cms.string( "RecoParticleFlow/PFProducer/data/MVAnalysis_BDT.weights_PfElectrons23Jan_IntToFloat.txt" ), - sumEtEcalIsoForEgammaSC_endcap = cms.double( 2.0 ), - calibHF_b_EMHAD = cms.vdouble( 1.27541, 0.85361, 0.86333, 0.89091, 0.94348, 0.94348, 0.9437, 1.0034, 1.0444, 1.0444 ), - pf_GlobC_mvaWeightFile = cms.string( "RecoParticleFlow/PFProducer/data/TMVARegression_BDTG_PFGlobalCorr.root" ), - photon_HoE = cms.double( 0.1 ), - sumEtEcalIsoForEgammaSC_barrel = cms.double( 1.0 ), - calibPFSCEle_Fbrem_endcap = cms.vdouble( 0.9, 6.5, -0.0692932, 0.101776, 0.995338, -0.00236548, 0.874998, 1.653, -0.0750184, 0.147, 0.923165, 4.74665E-4, 1.10782 ), - punchThroughFactor = cms.double( 3.0 ), - algoType = cms.uint32( 0 ), - electron_iso_combIso_barrel = cms.double( 10.0 ), - postMuonCleaning = cms.bool( True ), - calibPFSCEle_barrel = cms.vdouble( 1.004, -1.536, 22.88, -1.467, 0.3555, 0.6227, 14.65, 2051.0, 25.0, 0.9932, -0.5444, 0.0, 0.5438, 0.7109, 7.645, 0.2904, 0.0 ), - electron_protectionsForJetMET = cms.PSet( - maxE = cms.double( 50.0 ), - maxTrackPOverEele = cms.double( 1.0 ), - maxEcalEOverP_2 = cms.double( 0.2 ), - maxHcalEOverEcalE = cms.double( 0.1 ), - maxEcalEOverP_1 = cms.double( 0.5 ), - maxHcalEOverP = cms.double( 1.0 ), - maxEcalEOverPRes = cms.double( 0.2 ), - maxHcalE = cms.double( 10.0 ), - maxEeleOverPout = cms.double( 0.2 ), - maxNtracks = cms.double( 3.0 ), - maxEleHcalEOverEcalE = cms.double( 0.1 ), - maxDPhiIN = cms.double( 0.1 ), - maxEeleOverPoutRes = cms.double( 0.5 ) + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'PropagatorWithMaterial', + 'hltESPSmartPropagatorAnyOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) ), - electron_iso_pt = cms.double( 10.0 ), - isolatedElectronID_mvaWeightFile = cms.string( "RecoEgamma/ElectronIdentification/data/TMVA_BDTSimpleCat_17Feb2011.weights.xml" ), - vertexCollection = cms.InputTag( "hltPixelVertices" ), - X0_Map = cms.string( "RecoParticleFlow/PFProducer/data/allX0histos.root" ), - calibPFSCEle_Fbrem_barrel = cms.vdouble( 0.6, 6.0, -0.0255975, 0.0576727, 0.975442, -5.46394E-4, 1.26147, 25.0, -0.02025, 0.04537, 0.9728, -8.962E-4, 1.172 ), - blocks = cms.InputTag( "hltParticleFlowBlock" ), - punchThroughMETFactor = cms.double( 4.0 ), - metSignificanceForRejection = cms.double( 4.0 ), - photon_protectionsForJetMET = cms.PSet( - sumPtTrackIsoSlope = cms.double( 0.001 ), - sumPtTrackIso = cms.double( 2.0 ) + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( ), + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( + cleanerFromSharedHits = cms.bool( True ), + ptCleaner = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + directionCleaner = cms.bool( True ) ), - usePhotonReg = cms.bool( False ), - dzPV = cms.double( 0.2 ), - calibHF_a_EMHAD = cms.vdouble( 1.42215, 1.00496, 0.68961, 0.81656, 0.98504, 0.98504, 1.00802, 1.0593, 1.4576, 1.4576 ), - useRegressionFromDB = cms.bool( False ), - muon_ECAL = cms.vdouble( 0.5, 0.5 ), - usePFSCEleCalib = cms.bool( True ) -) -process.hltAK4PFJets = cms.EDProducer( "FastjetJetProducer", - Active_Area_Repeats = cms.int32( 5 ), - doAreaFastjet = cms.bool( False ), - voronoiRfact = cms.double( -9.0 ), - maxBadHcalCells = cms.uint32( 9999999 ), - doAreaDiskApprox = cms.bool( True ), - maxRecoveredEcalCells = cms.uint32( 9999999 ), - jetType = cms.string( "PFJet" ), - minSeed = cms.uint32( 0 ), - Ghost_EtaMax = cms.double( 6.0 ), - doRhoFastjet = cms.bool( False ), - jetAlgorithm = cms.string( "AntiKt" ), - nSigmaPU = cms.double( 1.0 ), - GhostArea = cms.double( 0.01 ), - Rho_EtaMax = cms.double( 4.4 ), - maxBadEcalCells = cms.uint32( 9999999 ), - useDeterministicSeed = cms.bool( True ), - doPVCorrection = cms.bool( False ), - maxRecoveredHcalCells = cms.uint32( 9999999 ), - rParam = cms.double( 0.4 ), - maxProblematicHcalCells = cms.uint32( 9999999 ), - doOutputJets = cms.bool( True ), - src = cms.InputTag( "hltParticleFlow" ), - inputEtMin = cms.double( 0.0 ), - puPtMin = cms.double( 10.0 ), - srcPVs = cms.InputTag( "hltPixelVertices" ), - jetPtMin = cms.double( 0.0 ), - radiusPU = cms.double( 0.4 ), - maxProblematicEcalCells = cms.uint32( 9999999 ), - doPUOffsetCorr = cms.bool( False ), - inputEMin = cms.double( 0.0 ), - useMassDropTagger = cms.bool( False ), - muMin = cms.double( -1.0 ), - subtractorName = cms.string( "" ), - muCut = cms.double( -1.0 ), - subjetPtMin = cms.double( -1.0 ), - useTrimming = cms.bool( False ), - muMax = cms.double( -1.0 ), - yMin = cms.double( -1.0 ), - useFiltering = cms.bool( False ), - rFilt = cms.double( -1.0 ), - yMax = cms.double( -1.0 ), - zcut = cms.double( -1.0 ), - MinVtxNdof = cms.int32( 0 ), - MaxVtxZ = cms.double( 15.0 ), - UseOnlyVertexTracks = cms.bool( False ), - dRMin = cms.double( -1.0 ), - nFilt = cms.int32( -1 ), - usePruning = cms.bool( False ), - maxDepth = cms.int32( -1 ), - yCut = cms.double( -1.0 ), - DzTrVtxMax = cms.double( 0.0 ), - UseOnlyOnePV = cms.bool( False ), - rcut_factor = cms.double( -1.0 ), - sumRecHits = cms.bool( False ), - trimPtFracMin = cms.double( -1.0 ), - dRMax = cms.double( -1.0 ), - DxyTrVtxMax = cms.double( 0.0 ), - useCMSBoostedTauSeedingAlgorithm = cms.bool( False ) -) -process.hltFixedGridRhoFastjetAll = cms.EDProducer( "FixedGridRhoProducerFastjet", - gridSpacing = cms.double( 0.55 ), - maxRapidity = cms.double( 5.0 ), - pfCandidatesTag = cms.InputTag( "hltParticleFlow" ) -) -process.hltAK4PFJetsCorrected = cms.EDProducer( "PFJetCorrectionProducer", - src = cms.InputTag( "hltAK4PFJets" ), - correctors = cms.vstring( 'hltESPAK4PFCorrection' ) -) -process.hltPFJetsCorrectedMatchedToCaloJets210 = cms.EDProducer( "PFJetsMatchedToFilteredCaloJetsProducer", - DeltaR = cms.double( 0.5 ), - CaloJetFilter = cms.InputTag( "hltSingleCaloJet210" ), - TriggerType = cms.int32( 85 ), - PFJetSrc = cms.InputTag( "hltAK4PFJetsCorrected" ) -) -process.hltSinglePFJet260 = cms.EDFilter( "HLT1PFJet", - saveTags = cms.bool( True ), - MinPt = cms.double( 260.0 ), - MinN = cms.int32( 1 ), - MaxEta = cms.double( 5.0 ), - MinMass = cms.double( -1.0 ), - inputTag = cms.InputTag( "hltPFJetsCorrectedMatchedToCaloJets210" ), - MinE = cms.double( -1.0 ), - triggerType = cms.int32( 85 ) -) -process.hltL1sL1SingleEG10 = cms.EDFilter( "HLTLevel1GTSeed", - L1SeedsLogicalExpression = cms.string( "L1_SingleEG10" ), - saveTags = cms.bool( True ), - L1MuonCollectionTag = cms.InputTag( "hltL1extraParticles" ), - L1UseL1TriggerObjectMaps = cms.bool( True ), - L1UseAliasesForSeeding = cms.bool( True ), - L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), - L1CollectionsTag = cms.InputTag( "hltL1extraParticles" ), - L1NrBxInEvent = cms.int32( 3 ), - L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), - L1TechTriggerSeeding = cms.bool( False ) -) -process.hltPrePhoton20CaloIdVLIsoL = cms.EDFilter( "HLTPrescaler", - L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), - offset = cms.uint32( 0 ) + PtCut = cms.double( 1.0 ) ) -process.hltEGL1SingleEG12Filter = cms.EDFilter( "HLTEgammaL1MatchFilterRegional", - doIsolated = cms.bool( False ), - endcap_end = cms.double( 2.65 ), - saveTags = cms.bool( False ), - region_eta_size_ecap = cms.double( 1.0 ), - barrel_end = cms.double( 1.4791 ), - l1IsolatedTag = cms.InputTag( 'hltL1extraParticles','Isolated' ), - candIsolatedTag = cms.InputTag( "hltEgammaCandidates" ), - region_phi_size = cms.double( 1.044 ), - region_eta_size = cms.double( 0.522 ), - L1SeedFilterTag = cms.InputTag( "hltL1sL1SingleEG10" ), - candNonIsolatedTag = cms.InputTag( "" ), - l1NonIsolatedTag = cms.InputTag( 'hltL1extraParticles','NonIsolated' ), - ncandcut = cms.int32( 1 ) -) -process.hltEG20EtFilter = cms.EDFilter( "HLTEgammaEtFilter", - saveTags = cms.bool( False ), - L1NonIsoCand = cms.InputTag( "" ), - relaxed = cms.untracked.bool( False ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - inputTag = cms.InputTag( "hltEGL1SingleEG12Filter" ), - etcutEB = cms.double( 20.0 ), - etcutEE = cms.double( 20.0 ), - ncandcut = cms.int32( 1 ) -) -process.hltEG20CaloIdVLClusterShapeFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( 0.04 ), - thrOverEEE = cms.double( -1.0 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( -1.0 ), - thrRegularEB = cms.double( 0.024 ), - lessThan = cms.bool( True ), - useEt = cms.bool( False ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( 'hltEgammaClusterShape','sigmaIEtaIEta5x5' ), - candTag = cms.InputTag( "hltEG20EtFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltEG20CaloIdVLHEFilter = cms.EDFilter( "HLTEgammaGenericFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( -1.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( -1.0 ), - thrRegularEE = cms.double( -1.0 ), - thrOverEEE = cms.double( 0.1 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.15 ), - thrRegularEB = cms.double( -1.0 ), - lessThan = cms.bool( True ), - useEt = cms.bool( False ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaHoverE" ), - candTag = cms.InputTag( "hltEG20CaloIdVLClusterShapeFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltEG20CaloIdVLIsoLEcalIsoFilter = cms.EDFilter( "HLTEgammaGenericQuadraticFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( 0.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( 0.0 ), - thrRegularEE = cms.double( 5.5 ), - thrOverEEE = cms.double( 0.012 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.012 ), - thrRegularEB = cms.double( 5.5 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaEcalPFClusterIso" ), - candTag = cms.InputTag( "hltEG20CaloIdVLHEFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltEG20CaloIdVLIsoLHcalIsoFilter = cms.EDFilter( "HLTEgammaGenericQuadraticFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( 0.0 ), - L1NonIsoCand = cms.InputTag( "" ), - saveTags = cms.bool( False ), - thrOverE2EB = cms.double( 0.0 ), - thrRegularEE = cms.double( 3.5 ), - thrOverEEE = cms.double( 0.005 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.005 ), - thrRegularEB = cms.double( 3.5 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaHcalPFClusterIso" ), - candTag = cms.InputTag( "hltEG20CaloIdVLHEFilter" ), - nonIsoTag = cms.InputTag( "" ) -) -process.hltPixelVerticesForPhotons = cms.EDProducer( "PixelVertexProducer", - WtAverage = cms.bool( True ), - Method2 = cms.bool( True ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - PVcomparer = cms.PSet( refToPSet_ = cms.string( "HLTPSetPvClusterComparer" ) ), - Verbosity = cms.int32( 0 ), - UseError = cms.bool( True ), - TrackCollection = cms.InputTag( "hltPixelTracks" ), - PtMin = cms.double( 1.0 ), - NTrkMin = cms.int32( 2 ), - ZOffset = cms.double( 5.0 ), - Finder = cms.string( "DivisiveVertexFinder" ), - ZSeparation = cms.double( 0.05 ) -) -process.hltIter0PFlowPixelSeedsFromPixelTracksForPhotons = cms.EDProducer( "SeedGeneratorFromProtoTracksEDProducer", - useEventsWithNoVertex = cms.bool( True ), - originHalfLength = cms.double( 0.3 ), - useProtoTrackKinematics = cms.bool( False ), - usePV = cms.bool( True ), - InputVertexCollection = cms.InputTag( "hltPixelVerticesForPhotons" ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - InputCollection = cms.InputTag( "hltPixelTracks" ), - originRadius = cms.double( 0.1 ) -) -process.hltIter0PFlowCkfTrackCandidatesForPhotons = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter0PFlowPixelSeedsFromPixelTracksForPhotons" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), +process.hltHIL3TrackCandidateFromL2OIHit = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedOIHit" ), + reverseTrajectories = cms.bool( True ), TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) ), TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), cleanTrajectoryAfterInOut = cms.bool( False ), useHitsSplitting = cms.bool( False ), RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter0PSetTrajectoryBuilderIT" ) ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) ) -process.hltIter0PFlowCtfWithMaterialTracksForPhotons = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter0PFlowCkfTrackCandidatesForPhotons" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), +process.hltHIL3TkTracksFromL2OIHit = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2OIHit" ), + SimpleMagneticField = cms.string( "" ), clusterRemovalInfo = cms.InputTag( "" ), beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltSiStripClusters" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), useHitsSplitting = cms.bool( False ), MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), NavigationSchool = cms.string( "" ), TrajectoryInEvent = cms.bool( True ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -process.hltIter0PFlowTrackSelectionHighPurityForPhotons = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.4, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.35, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter0PFlowCtfWithMaterialTracksForPhotons" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesForPhotons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.4, 4.0 ), - d0_par1 = cms.vdouble( 0.3, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter1ClustersRefRemovalForPhotons = cms.EDProducer( "TrackClusterRemover", - minNumberOfLayersWithMeasBeforeFiltering = cms.int32( 0 ), - maxChi2 = cms.double( 9.0 ), - trajectories = cms.InputTag( "hltIter0PFlowTrackSelectionHighPurityForPhotons" ), - oldClusterRemovalInfo = cms.InputTag( "" ), - stripClusters = cms.InputTag( "hltSiStripRawToClustersFacility" ), - overrideTrkQuals = cms.InputTag( "" ), - pixelClusters = cms.InputTag( "hltSiPixelClusters" ), - TrackQuality = cms.string( "highPurity" ) -) -process.hltIter1MaskedMeasurementTrackerEventForPhotons = cms.EDProducer( "MaskedMeasurementTrackerEventProducer", - clustersToSkip = cms.InputTag( "hltIter1ClustersRefRemovalForPhotons" ), - OnDemand = cms.bool( False ), - src = cms.InputTag( "hltSiStripClusters" ) -) -process.hltIter1PixelLayerTripletsForPhotons = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2+BPix3', - 'BPix1+BPix2+FPix1_pos', - 'BPix1+BPix2+FPix1_neg', - 'BPix1+FPix1_pos+FPix2_pos', - 'BPix1+FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter1ClustersRefRemovalForPhotons" ), - hitErrorRPhi = cms.double( 0.0051 ) + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +process.hltHIL3MuonsOIHit = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) + ), + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) + ), + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + ), + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) + ), + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) + ), + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2OIHit" ), + tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter1ClustersRefRemovalForPhotons" ), - hitErrorRPhi = cms.double( 0.0027 ) + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) + ), + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) ), - TIB = cms.PSet( ) -) -process.hltIter1PFlowPixelSeedsForPhotons = cms.EDProducer( "SeedGeneratorFromRegionHitsEDProducer", - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "CandidateSeededTrackingRegionsProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.05 ), - ptMin = cms.double( 0.5 ), - input = cms.InputTag( "hltEgammaCandidates" ), - maxNRegions = cms.int32( 10 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - vertexCollection = cms.InputTag( "hltPixelVerticesForPhotons" ), - zErrorBeamSpot = cms.double( 24.2 ), - deltaEta = cms.double( 0.5 ), - deltaPhi = cms.double( 0.5 ), - nSigmaZVertex = cms.double( 3.0 ), - nSigmaZBeamSpot = cms.double( 4.0 ), - mode = cms.string( "VerticesFixed" ), - maxNVertices = cms.int32( 3 ), - zErrorVetex = cms.double( 0.2 ) - ) + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) +) +process.hltHIL3TkFromL2OICombination = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit' ) +) +process.hltHIL3TrajSeedIOHit = cms.EDProducer( "TSGFromL2Muon", + TkSeedGenerator = cms.PSet( + PSetNames = cms.vstring( 'skipTSG', + 'skipTSG' ), + L3TkCollectionA = cms.InputTag( "hltHIL3TkFromL2OICombination" ), + iterativeTSG = cms.PSet( + firstTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + ComponentName = cms.string( "StandardHitTripletGenerator" ), + GeneratorPSet = cms.PSet( + useBending = cms.bool( True ), + useFixedPreFiltering = cms.bool( False ), + maxElement = cms.uint32( 0 ), + phiPreFiltering = cms.double( 0.3 ), + extraHitRPhitolerance = cms.double( 0.06 ), + useMultScattering = cms.bool( True ), + ComponentName = cms.string( "PixelTripletHLTGenerator" ), + extraHitRZtolerance = cms.double( 0.06 ), + SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) + ), + SeedingLayers = cms.InputTag( "hltPixelLayerTriplets" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ), + PSetNames = cms.vstring( 'firstTSG', + 'secondTSG' ), + ComponentName = cms.string( "CombinedTSG" ), + thirdTSG = cms.PSet( + PSetNames = cms.vstring( 'endcapTSG', + 'barrelTSG' ), + barrelTSG = cms.PSet( ), + endcapTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + maxElement = cms.uint32( 0 ), + ComponentName = cms.string( "StandardHitPairGenerator" ), + useOnDemandTracker = cms.untracked.int32( 0 ), + SeedingLayers = cms.InputTag( "hltMixedLayerPairs" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ), + etaSeparation = cms.double( 2.0 ), + ComponentName = cms.string( "DualByEtaTSG" ) + ), + secondTSG = cms.PSet( + ComponentName = cms.string( "TSGFromOrderedHits" ), + OrderedHitsFactoryPSet = cms.PSet( + maxElement = cms.uint32( 0 ), + ComponentName = cms.string( "StandardHitPairGenerator" ), + useOnDemandTracker = cms.untracked.int32( 0 ), + SeedingLayers = cms.InputTag( "hltPixelLayerPairs" ) + ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + ) + ), + skipTSG = cms.PSet( ), + ComponentName = cms.string( "DualByL2TSG" ) ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ), - ClusterCheckPSet = cms.PSet( - PixelClusterCollectionLabel = cms.InputTag( "hltSiPixelClusters" ), - MaxNumberOfCosmicClusters = cms.uint32( 50000 ), - doClusterCheck = cms.bool( False ), - ClusterCollectionLabel = cms.InputTag( "hltSiStripClusters" ), - MaxNumberOfPixelClusters = cms.uint32( 10000 ) + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'PropagatorWithMaterial' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitTripletGenerator" ), - GeneratorPSet = cms.PSet( - useBending = cms.bool( True ), - useFixedPreFiltering = cms.bool( False ), - maxElement = cms.uint32( 100000 ), - phiPreFiltering = cms.double( 0.3 ), - extraHitRPhitolerance = cms.double( 0.032 ), - useMultScattering = cms.bool( True ), - ComponentName = cms.string( "PixelTripletHLTGenerator" ), - extraHitRZtolerance = cms.double( 0.037 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) - ), - SeedingLayers = cms.InputTag( "hltIter1PixelLayerTripletsForPhotons" ) + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.1 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.1 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) ), - SeedCreatorPSet = cms.PSet( - ComponentName = cms.string( "SeedFromConsecutiveHitsTripletOnlyCreator" ), - propagator = cms.string( "PropagatorWithMaterialParabolicMf" ), - SeedMomentumForBOFF = cms.double( 5.0 ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + PCut = cms.double( 2.5 ), + TrackerSeedCleaner = cms.PSet( + cleanerFromSharedHits = cms.bool( True ), + ptCleaner = cms.bool( True ), + TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + directionCleaner = cms.bool( True ) ), - TTRHBuilder = cms.string( "(unused)" ) + PtCut = cms.double( 1.0 ) ) -process.hltIter1PFlowCkfTrackCandidatesForPhotons = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter1PFlowPixelSeedsForPhotons" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), +process.hltHIL3TrackCandidateFromL2IOHit = cms.EDProducer( "CkfTrajectoryMaker", + src = cms.InputTag( "hltHIL3TrajSeedIOHit" ), + reverseTrajectories = cms.bool( False ), TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), + propagatorAlongTISE = cms.string( "PropagatorWithMaterial" ), numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) + propagatorOppositeTISE = cms.string( "PropagatorWithMaterialOpposite" ) ), TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter1MaskedMeasurementTrackerEventForPhotons" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), cleanTrajectoryAfterInOut = cms.bool( False ), useHitsSplitting = cms.bool( False ), RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter1PSetTrajectoryBuilderIT" ) ), + trackCandidateAlso = cms.bool( True ), + TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTPSetMuonCkfTrajectoryBuilder" ) ), NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) + TrajectoryBuilder = cms.string( "hltHIAllESPMuonCkfTrajectoryBuilder" ), + maxNSeeds = cms.uint32( 100000 ) ) -process.hltIter1PFlowCtfWithMaterialTracksForPhotons = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter1PFlowCkfTrackCandidatesForPhotons" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), +process.hltHIL3TkTracksFromL2IOHit = cms.EDProducer( "TrackProducer", + src = cms.InputTag( "hltHIL3TrackCandidateFromL2IOHit" ), + SimpleMagneticField = cms.string( "" ), clusterRemovalInfo = cms.InputTag( "" ), beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter1MaskedMeasurementTrackerEventForPhotons" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), + MeasurementTrackerEvent = cms.InputTag( "hltHISiStripClusters" ), + Fitter = cms.string( "hltESPKFFittingSmoother" ), useHitsSplitting = cms.bool( False ), MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), + AlgorithmName = cms.string( "undefAlgorithm" ), + alias = cms.untracked.string( "" ), NavigationSchool = cms.string( "" ), TrajectoryInEvent = cms.bool( True ), TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -process.hltIter1PFlowTrackSelectionHighPurityLooseForPhotons = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.9, 3.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.8, 3.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter1PFlowCtfWithMaterialTracksForPhotons" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesForPhotons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.9, 3.0 ), - d0_par1 = cms.vdouble( 0.85, 3.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter1PFlowTrackSelectionHighPurityTightForPhotons = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 5 ), - chi2n_par = cms.double( 0.4 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 1.0, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 1.0, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter1PFlowCtfWithMaterialTracksForPhotons" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesForPhotons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 1.0, 4.0 ), - d0_par1 = cms.vdouble( 1.0, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter1PFlowTrackSelectionHighPurityForPhotons = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter1PFlowTrackSelectionHighPurityLooseForPhotons','hltIter1PFlowTrackSelectionHighPurityTightForPhotons' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter1PFlowTrackSelectionHighPurityLooseForPhotons','hltIter1PFlowTrackSelectionHighPurityTightForPhotons' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltIter1MergedForPhotons = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter0PFlowTrackSelectionHighPurityForPhotons','hltIter1PFlowTrackSelectionHighPurityForPhotons' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter0PFlowTrackSelectionHighPurityForPhotons','hltIter1PFlowTrackSelectionHighPurityForPhotons' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltIter2ClustersRefRemovalForPhotons = cms.EDProducer( "TrackClusterRemover", - minNumberOfLayersWithMeasBeforeFiltering = cms.int32( 0 ), - maxChi2 = cms.double( 16.0 ), - trajectories = cms.InputTag( "hltIter1PFlowTrackSelectionHighPurityForPhotons" ), - oldClusterRemovalInfo = cms.InputTag( "hltIter1ClustersRefRemovalForPhotons" ), - stripClusters = cms.InputTag( "hltSiStripRawToClustersFacility" ), - overrideTrkQuals = cms.InputTag( "" ), - pixelClusters = cms.InputTag( "hltSiPixelClusters" ), - TrackQuality = cms.string( "highPurity" ) -) -process.hltIter2MaskedMeasurementTrackerEventForPhotons = cms.EDProducer( "MaskedMeasurementTrackerEventProducer", - clustersToSkip = cms.InputTag( "hltIter2ClustersRefRemovalForPhotons" ), - OnDemand = cms.bool( False ), - src = cms.InputTag( "hltSiStripClusters" ) -) -process.hltIter2PixelLayerPairsForPhotons = cms.EDProducer( "SeedingLayersEDProducer", - layerList = cms.vstring( 'BPix1+BPix2', - 'BPix1+BPix3', - 'BPix2+BPix3', - 'BPix1+FPix1_pos', - 'BPix1+FPix1_neg', - 'BPix1+FPix2_pos', - 'BPix1+FPix2_neg', - 'BPix2+FPix1_pos', - 'BPix2+FPix1_neg', - 'BPix2+FPix2_pos', - 'BPix2+FPix2_neg', - 'FPix1_pos+FPix2_pos', - 'FPix1_neg+FPix2_neg' ), - MTOB = cms.PSet( ), - TEC = cms.PSet( ), - MTID = cms.PSet( ), - FPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.0036 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter2ClustersRefRemovalForPhotons" ), - hitErrorRPhi = cms.double( 0.0051 ) - ), - MTEC = cms.PSet( ), - MTIB = cms.PSet( ), - TID = cms.PSet( ), - TOB = cms.PSet( ), - BPix = cms.PSet( - HitProducer = cms.string( "hltSiPixelRecHits" ), - hitErrorRZ = cms.double( 0.006 ), - useErrorsFromParam = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBuilderPixelOnly" ), - skipClusters = cms.InputTag( "hltIter2ClustersRefRemovalForPhotons" ), - hitErrorRPhi = cms.double( 0.0027 ) - ), - TIB = cms.PSet( ) -) -process.hltIter2PFlowPixelSeedsForPhotons = cms.EDProducer( "SeedGeneratorFromRegionHitsEDProducer", - RegionFactoryPSet = cms.PSet( - ComponentName = cms.string( "CandidateSeededTrackingRegionsProducer" ), - RegionPSet = cms.PSet( - precise = cms.bool( True ), - originRadius = cms.double( 0.05 ), - ptMin = cms.double( 1.2 ), - deltaEta = cms.double( 0.5 ), - deltaPhi = cms.double( 0.5 ), - vertexCollection = cms.InputTag( "hltPixelVerticesForPhotons" ), - input = cms.InputTag( "hltEgammaCandidates" ), - mode = cms.string( "VerticesFixed" ), - maxNRegions = cms.int32( 10 ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - maxNVertices = cms.int32( 3 ), - zErrorBeamSpot = cms.double( 24.2 ), - nSigmaZVertex = cms.double( 3.0 ), - nSigmaZBeamSpot = cms.double( 4.0 ), - zErrorVetex = cms.double( 0.2 ) - ) - ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ), - ClusterCheckPSet = cms.PSet( - PixelClusterCollectionLabel = cms.InputTag( "hltSiPixelClusters" ), - MaxNumberOfCosmicClusters = cms.uint32( 50000 ), - doClusterCheck = cms.bool( False ), - ClusterCollectionLabel = cms.InputTag( "hltSiStripClusters" ), - MaxNumberOfPixelClusters = cms.uint32( 10000 ) + useSimpleMF = cms.bool( False ), + Propagator = cms.string( "PropagatorWithMaterial" ) +) +process.hltHIAllL3MuonsIOHit = cms.EDProducer( "L3MuonProducer", + ServiceParameters = cms.PSet( + Propagators = cms.untracked.vstring( 'hltESPSmartPropagatorAny', + 'SteppingHelixPropagatorAny', + 'hltESPSmartPropagator', + 'hltESPSteppingHelixPropagatorOpposite' ), + RPCLayers = cms.bool( True ), + UseMuonNavigation = cms.untracked.bool( True ) ), - OrderedHitsFactoryPSet = cms.PSet( - maxElement = cms.uint32( 0 ), - ComponentName = cms.string( "StandardHitPairGenerator" ), - GeneratorPSet = cms.PSet( - maxElement = cms.uint32( 100000 ), - SeedComparitorPSet = cms.PSet( ComponentName = cms.string( "none" ) ) + L3TrajBuilderParameters = cms.PSet( + ScaleTECyFactor = cms.double( -1.0 ), + GlbRefitterParameters = cms.PSet( + TrackerSkipSection = cms.int32( -1 ), + DoPredictionsOnly = cms.bool( False ), + PropDirForCosmics = cms.bool( False ), + HitThreshold = cms.int32( 1 ), + MuonHitsOption = cms.int32( 1 ), + Chi2CutRPC = cms.double( 1.0 ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + DTRecSegmentLabel = cms.InputTag( "hltDt4DSegments" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + CSCRecSegmentLabel = cms.InputTag( "hltCscSegments" ), + Chi2CutCSC = cms.double( 150.0 ), + Chi2CutDT = cms.double( 10.0 ), + RefitRPCHits = cms.bool( True ), + SkipStation = cms.int32( -1 ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ), + TrackerSkipSystem = cms.int32( -1 ), + DYTthrs = cms.vint32( 30, 15 ) + ), + ScaleTECxFactor = cms.double( -1.0 ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + MuonTrackingRegionBuilder = cms.PSet( + EtaR_UpperLimit_Par1 = cms.double( 0.25 ), + EtaR_UpperLimit_Par2 = cms.double( 0.15 ), + OnDemand = cms.double( -1.0 ), + Rescale_Dz = cms.double( 3.0 ), + vertexCollection = cms.InputTag( "pixelVertices" ), + Rescale_phi = cms.double( 3.0 ), + Eta_fixed = cms.double( 0.2 ), + DeltaZ_Region = cms.double( 15.9 ), + MeasurementTrackerName = cms.string( "hltESPMeasurementTracker" ), + PhiR_UpperLimit_Par2 = cms.double( 0.2 ), + Eta_min = cms.double( 0.05 ), + Phi_fixed = cms.double( 0.2 ), + DeltaR = cms.double( 0.2 ), + EscapePt = cms.double( 1.5 ), + UseFixedRegion = cms.bool( False ), + PhiR_UpperLimit_Par1 = cms.double( 0.6 ), + Rescale_eta = cms.double( 3.0 ), + Phi_min = cms.double( 0.05 ), + UseVertex = cms.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ) + ), + RefitRPCHits = cms.bool( True ), + PCut = cms.double( 2.5 ), + TrackTransformer = cms.PSet( + DoPredictionsOnly = cms.bool( False ), + Fitter = cms.string( "hltESPL3MuKFTrajectoryFitter" ), + TrackerRecHitBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonRecHitBuilder = cms.string( "hltESPMuonTransientTrackingRecHitBuilder" ), + RefitDirection = cms.string( "insideOut" ), + RefitRPCHits = cms.bool( True ), + Propagator = cms.string( "hltESPSmartPropagatorAny" ) + ), + GlobalMuonTrackMatcher = cms.PSet( + Pt_threshold1 = cms.double( 0.0 ), + DeltaDCut_3 = cms.double( 15.0 ), + MinP = cms.double( 2.5 ), + MinPt = cms.double( 1.0 ), + Chi2Cut_1 = cms.double( 50.0 ), + Pt_threshold2 = cms.double( 9.99999999E8 ), + LocChi2Cut = cms.double( 0.001 ), + Eta_threshold = cms.double( 1.2 ), + Quality_3 = cms.double( 7.0 ), + Quality_2 = cms.double( 15.0 ), + Chi2Cut_2 = cms.double( 50.0 ), + Chi2Cut_3 = cms.double( 200.0 ), + DeltaDCut_1 = cms.double( 40.0 ), + DeltaRCut_2 = cms.double( 0.2 ), + DeltaRCut_3 = cms.double( 1.0 ), + DeltaDCut_2 = cms.double( 10.0 ), + DeltaRCut_1 = cms.double( 0.1 ), + Propagator = cms.string( "hltESPSmartPropagator" ), + Quality_1 = cms.double( 20.0 ) ), - SeedingLayers = cms.InputTag( "hltIter2PixelLayerPairsForPhotons" ) + PtCut = cms.double( 1.0 ), + TrackerPropagator = cms.string( "SteppingHelixPropagatorAny" ), + tkTrajLabel = cms.InputTag( "hltHIL3TkTracksFromL2IOHit" ), + tkTrajBeamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + tkTrajMaxChi2 = cms.double( 9999.0 ), + tkTrajMaxDXYBeamSpot = cms.double( 0.2 ), + tkTrajVertex = cms.InputTag( "pixelVertices" ), + tkTrajUseVertex = cms.bool( False ) ), - SeedCreatorPSet = cms.PSet( - ComponentName = cms.string( "SeedFromConsecutiveHitsCreator" ), - propagator = cms.string( "PropagatorWithMaterialParabolicMf" ), - SeedMomentumForBOFF = cms.double( 5.0 ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ) + TrackLoaderParameters = cms.PSet( + PutTkTrackIntoEvent = cms.untracked.bool( False ), + beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), + SmoothTkTrack = cms.untracked.bool( False ), + MuonSeededTracksInstance = cms.untracked.string( "L2Seeded" ), + Smoother = cms.string( "hltESPKFTrajectorySmootherForMuonTrackLoader" ), + MuonUpdatorAtVertexParameters = cms.PSet( + MaxChi2 = cms.double( 1000000.0 ), + Propagator = cms.string( "hltESPSteppingHelixPropagatorOpposite" ), + BeamSpotPositionErrors = cms.vdouble( 0.1, 0.1, 5.3 ) + ), + VertexConstraint = cms.bool( False ), + DoSmoothing = cms.bool( True ) ), - TTRHBuilder = cms.string( "(unused)" ) + MuonCollectionLabel = cms.InputTag( 'hltL2Muons','UpdatedAtVtx' ) ) -process.hltIter2PFlowCkfTrackCandidatesForPhotons = cms.EDProducer( "CkfTrackCandidateMaker", - src = cms.InputTag( "hltIter2PFlowPixelSeedsForPhotons" ), - maxSeedsBeforeCleaning = cms.uint32( 1000 ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - TransientInitialStateEstimatorParameters = cms.PSet( - propagatorAlongTISE = cms.string( "PropagatorWithMaterialParabolicMf" ), - numberMeasurementsForFit = cms.int32( 4 ), - propagatorOppositeTISE = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ) - ), - TrajectoryCleaner = cms.string( "hltESPTrajectoryCleanerBySharedHits" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter2MaskedMeasurementTrackerEventForPhotons" ), - cleanTrajectoryAfterInOut = cms.bool( False ), - useHitsSplitting = cms.bool( False ), - RedundantSeedCleaner = cms.string( "CachingSeedCleanerBySharedInput" ), - doSeedingRegionRebuilding = cms.bool( False ), - maxNSeeds = cms.uint32( 100000 ), - TrajectoryBuilderPSet = cms.PSet( refToPSet_ = cms.string( "HLTIter2PSetTrajectoryBuilderIT" ) ), - NavigationSchool = cms.string( "SimpleNavigationSchool" ), - TrajectoryBuilder = cms.string( "" ) +process.hltHIL3TrajectorySeed = cms.EDProducer( "L3MuonTrajectorySeedCombiner", + labels = cms.VInputTag( 'hltHIL3TrajSeedIOHit','hltHIL3TrajSeedOIState','hltHIL3TrajSeedOIHit' ) ) -process.hltIter2PFlowCtfWithMaterialTracksForPhotons = cms.EDProducer( "TrackProducer", - src = cms.InputTag( "hltIter2PFlowCkfTrackCandidatesForPhotons" ), - SimpleMagneticField = cms.string( "ParabolicMf" ), - clusterRemovalInfo = cms.InputTag( "" ), - beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), - MeasurementTrackerEvent = cms.InputTag( "hltIter2MaskedMeasurementTrackerEventForPhotons" ), - Fitter = cms.string( "hltESPFittingSmootherIT" ), - useHitsSplitting = cms.bool( False ), - MeasurementTracker = cms.string( "" ), - AlgorithmName = cms.string( "hltIterX" ), - alias = cms.untracked.string( "ctfWithMaterialTracks" ), - NavigationSchool = cms.string( "" ), - TrajectoryInEvent = cms.bool( True ), - TTRHBuilder = cms.string( "hltESPTTRHBWithTrackAngle" ), - GeometricInnerState = cms.bool( True ), - useSimpleMF = cms.bool( True ), - Propagator = cms.string( "hltESPRungeKuttaTrackerPropagator" ) -) -process.hltIter2PFlowTrackSelectionHighPurityForPhotons = cms.EDProducer( "AnalyticalTrackSelector", - max_d0 = cms.double( 100.0 ), - minNumber3DLayers = cms.uint32( 0 ), - max_lostHitFraction = cms.double( 1.0 ), - applyAbsCutsIfNoPV = cms.bool( False ), - qualityBit = cms.string( "highPurity" ), - minNumberLayers = cms.uint32( 3 ), - chi2n_par = cms.double( 0.7 ), - useVtxError = cms.bool( False ), - nSigmaZ = cms.double( 3.0 ), - dz_par2 = cms.vdouble( 0.4, 4.0 ), - applyAdaptedPVCuts = cms.bool( True ), - min_eta = cms.double( -9999.0 ), - dz_par1 = cms.vdouble( 0.35, 4.0 ), - copyTrajectories = cms.untracked.bool( True ), - vtxNumber = cms.int32( -1 ), - max_d0NoPV = cms.double( 100.0 ), - keepAllTracks = cms.bool( False ), - maxNumberLostLayers = cms.uint32( 1 ), - beamspot = cms.InputTag( "hltOnlineBeamSpot" ), - max_relpterr = cms.double( 9999.0 ), - copyExtras = cms.untracked.bool( True ), - max_z0NoPV = cms.double( 100.0 ), - vertexCut = cms.string( "tracksSize>=3" ), - max_z0 = cms.double( 100.0 ), - useVertices = cms.bool( True ), - min_nhits = cms.uint32( 0 ), - src = cms.InputTag( "hltIter2PFlowCtfWithMaterialTracksForPhotons" ), - max_minMissHitOutOrIn = cms.int32( 99 ), - chi2n_no1Dmod_par = cms.double( 9999.0 ), - vertices = cms.InputTag( "hltPixelVerticesForPhotons" ), - max_eta = cms.double( 9999.0 ), - d0_par2 = cms.vdouble( 0.4, 4.0 ), - d0_par1 = cms.vdouble( 0.3, 4.0 ), - res_par = cms.vdouble( 0.003, 0.001 ), - minHitsToBypassChecks = cms.uint32( 20 ) -) -process.hltIter2MergedForPhotons = cms.EDProducer( "TrackListMerger", - ShareFrac = cms.double( 0.19 ), - writeOnlyTrkQuals = cms.bool( False ), - MinPT = cms.double( 0.05 ), - allowFirstHitShare = cms.bool( True ), - copyExtras = cms.untracked.bool( True ), - Epsilon = cms.double( -0.001 ), - selectedTrackQuals = cms.VInputTag( 'hltIter1MergedForPhotons','hltIter2PFlowTrackSelectionHighPurityForPhotons' ), - indivShareFrac = cms.vdouble( 1.0, 1.0 ), - MaxNormalizedChisq = cms.double( 1000.0 ), - copyMVA = cms.bool( False ), - FoundHitBonus = cms.double( 5.0 ), - setsToMerge = cms.VPSet( - cms.PSet( pQual = cms.bool( False ), - tLists = cms.vint32( 0, 1 ) - ) - ), - MinFound = cms.int32( 3 ), - hasSelector = cms.vint32( 0, 0 ), - TrackProducers = cms.VInputTag( 'hltIter1MergedForPhotons','hltIter2PFlowTrackSelectionHighPurityForPhotons' ), - LostHitPenalty = cms.double( 20.0 ), - newQuality = cms.string( "confirmed" ) -) -process.hltEgammaHollowTrackIso = cms.EDProducer( "EgammaHLTPhotonTrackIsolationProducersRegional", - egTrkIsoStripEndcap = cms.double( 0.03 ), - egTrkIsoConeSize = cms.double( 0.29 ), - trackProducer = cms.InputTag( "hltIter2MergedForPhotons" ), - egTrkIsoStripBarrel = cms.double( 0.03 ), - countTracks = cms.bool( False ), - egTrkIsoRSpan = cms.double( 999999.0 ), - egTrkIsoVetoConeSize = cms.double( 0.06 ), - recoEcalCandidateProducer = cms.InputTag( "hltEgammaCandidates" ), - egTrkIsoPtMin = cms.double( 1.0 ), - egTrkIsoZSpan = cms.double( 999999.0 ) -) -process.hltEG20CaloIdVLIsoLTrackIsoFilter = cms.EDFilter( "HLTEgammaGenericQuadraticFilter", - doIsolated = cms.bool( True ), - thrOverE2EE = cms.double( 0.0 ), - L1NonIsoCand = cms.InputTag( "" ), +process.hltHIL3TrackCandidateFromL2 = cms.EDProducer( "L3TrackCandCombiner", + labels = cms.VInputTag( 'hltHIL3TrackCandidateFromL2IOHit','hltHIL3TrackCandidateFromL2OIHit','hltHIL3TrackCandidateFromL2OIState' ) +) +process.hltHIL3TkTracksFromL2 = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3TkTracksFromL2IOHit','hltHIL3TkTracksFromL2OIHit','hltHIL3TkTracksFromL2OIState' ) +) +process.hltHIL3MuonsLinksCombination = cms.EDProducer( "L3TrackLinksCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit','hltHIAllL3MuonsIOHit' ) +) +process.hltHIL3Muons = cms.EDProducer( "L3TrackCombiner", + labels = cms.VInputTag( 'hltHIL3MuonsOIState','hltHIL3MuonsOIHit','hltHIAllL3MuonsIOHit' ) +) +process.hltHIL3MuonCandidates = cms.EDProducer( "L3MuonCandidateProducer", + InputLinksObjects = cms.InputTag( "hltHIL3MuonsLinksCombination" ), + InputObjects = cms.InputTag( "hltHIL3Muons" ), + MuonPtOption = cms.string( "Global" ) +) +process.hltHISingleMu3L3Filtered = cms.EDFilter( "HLTMuonL3PreFilter", + MaxNormalizedChi2 = cms.double( 20.0 ), + saveTags = cms.bool( True ), + PreviousCandTag = cms.InputTag( "hltHIL2Mu3L2Filtered" ), + MinNmuonHits = cms.int32( 0 ), + MinN = cms.int32( 1 ), + MinTrackPt = cms.double( 0.0 ), + MaxEta = cms.double( 2.5 ), + MaxDXYBeamSpot = cms.double( 0.1 ), + MinNhits = cms.int32( 0 ), + MinDxySig = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MaxDz = cms.double( 9999.0 ), + MaxPtDifference = cms.double( 9999.0 ), + MaxDr = cms.double( 2.0 ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + MinDXYBeamSpot = cms.double( -1.0 ), + MinDr = cms.double( -1.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinPt = cms.double( 3.0 ) +) +process.hltPreHIL3DoubleMuOpen = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIDimuonL2PreFiltered0 = cms.EDFilter( "HLTMuonL2PreFilter", saveTags = cms.bool( True ), - thrOverE2EB = cms.double( 0.0 ), - thrRegularEE = cms.double( 3.5 ), - thrOverEEE = cms.double( 0.002 ), - L1IsoCand = cms.InputTag( "hltEgammaCandidates" ), - thrOverEEB = cms.double( 0.002 ), - thrRegularEB = cms.double( 3.5 ), - lessThan = cms.bool( True ), - useEt = cms.bool( True ), - ncandcut = cms.int32( 1 ), - isoTag = cms.InputTag( "hltEgammaHollowTrackIso" ), - candTag = cms.InputTag( "hltEG20CaloIdVLIsoLHcalIsoFilter" ), - nonIsoTag = cms.InputTag( "" ) + MaxDr = cms.double( 9999.0 ), + CutOnChambers = cms.bool( False ), + PreviousCandTag = cms.InputTag( "hltHIDoubleMuLevel1PathL1OpenFiltered" ), + MinPt = cms.double( 0.0 ), + MinN = cms.int32( 2 ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.vint32( 0 ), + MinDxySig = cms.double( -1.0 ), + MinNchambers = cms.vint32( 0 ), + AbsEtaBins = cms.vdouble( 5.0 ), + MaxDz = cms.double( 9999.0 ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MinDr = cms.double( -1.0 ), + NSigmaPt = cms.double( 0.0 ), + MinNstations = cms.vint32( 0 ) ) -process.hltPrePhysics = cms.EDFilter( "HLTPrescaler", +process.hltHIDimuonL3FilterOpen = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( 0 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +process.hltPreHIL3DoubleMuOpenSS = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIDimuonL3FilterOpenSS = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( 1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +process.hltPreHIL3DoubleMuOpenOS = cms.EDFilter( "HLTPrescaler", + L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), + offset = cms.uint32( 0 ) +) +process.hltHIDimuonL3FilterOpenOS = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( -1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + MinInvMass = cms.vdouble( 0.0 ) +) +process.hltPreHIL3DoubleMuOpenOSNoCowboy = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) +process.hltHIDimuonL3FilterOpenOSNoCowboy = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + ChargeOpt = cms.int32( -1 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + FastAccept = cms.bool( False ), + CandTag = cms.InputTag( "hltHIL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltHIDimuonL2PreFiltered0" ), + MaxPtBalance = cms.double( 999999.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MaxAcop = cms.double( 999.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxInvMass = cms.vdouble( 300.0 ), + MinPtMax = cms.vdouble( 0.0 ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + MaxDz = cms.double( 9999.0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxDr = cms.double( 20.0 ), + MinAcop = cms.double( -999.0 ), + MaxDCAMuMu = cms.double( 999.0 ), + MinNhits = cms.int32( 0 ), + NSigmaPt = cms.double( 0.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxEta = cms.double( 2.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( True ), + MinInvMass = cms.vdouble( 0.0 ) +) process.hltFEDSelector = cms.EDProducer( "EvFFEDSelector", inputTag = cms.InputTag( "rawDataCollector" ), fedList = cms.vuint32( 1023 ) @@ -8438,11 +3874,19 @@ filterName = cms.untracked.string( "" ), dataTier = cms.untracked.string( "RAW" ) ), - SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring( 'HLT_CaloJet260_v1', - 'HLT_Ele27_eta2p1_WP75_Gsf_v1', - 'HLT_Mu50_v1', - 'HLT_PFJet260_v1', - 'HLT_Photon20_CaloIdVL_IsoL_v1', + SelectEvents = cms.untracked.PSet( SelectEvents = cms.vstring( 'HLT_HIL1DoubleMu0_HighQ_v1', + 'HLT_HIL2DoubleMu0_NHitQ_v1', + 'HLT_HIL2DoubleMu0_v1', + 'HLT_HIL2DoubleMu3_v1', + 'HLT_HIL2Mu15_v1', + 'HLT_HIL2Mu3_NHitQ_v1', + 'HLT_HIL2Mu3_v1', + 'HLT_HIL2Mu7_v1', + 'HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1', + 'HLT_HIL3DoubleMuOpen_OS_v1', + 'HLT_HIL3DoubleMuOpen_SS_v1', + 'HLT_HIL3DoubleMuOpen_v1', + 'HLT_HIL3Mu3_v1', 'HLT_Physics_v1' ) ), outputCommands = cms.untracked.vstring( 'drop *', 'keep *_hltL1GtObjectMap_*_*', @@ -8454,66 +3898,31 @@ process.HLTL1UnpackerSequence = cms.Sequence( process.hltGtDigis + process.hltGctDigis + process.hltL1GtObjectMap + process.hltL1extraParticles ) process.HLTBeamSpot = cms.Sequence( process.hltScalersRawToDigi + process.hltOnlineBeamSpot ) process.HLTBeginSequence = cms.Sequence( process.hltTriggerType + process.HLTL1UnpackerSequence + process.HLTBeamSpot ) -process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence = cms.Sequence( process.hltEcalDigis + process.hltEcalUncalibRecHit + process.hltEcalDetIdToBeRecovered + process.hltEcalRecHit ) -process.HLTDoLocalHcalSequence = cms.Sequence( process.hltHcalDigis + process.hltHbhereco + process.hltHfreco + process.hltHoreco ) -process.HLTDoCaloSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence + process.HLTDoLocalHcalSequence + process.hltTowerMakerForAll ) -process.HLTAK4CaloJetsReconstructionSequence = cms.Sequence( process.HLTDoCaloSequence + process.hltAK4CaloJets + process.hltAK4CaloJetsIDPassed ) -process.HLTAK4CaloJetsCorrectionSequence = cms.Sequence( process.hltFixedGridRhoFastjetAllCalo + process.hltAK4CaloJetsCorrected + process.hltAK4CaloJetsCorrectedIDPassed ) -process.HLTAK4CaloJetsSequence = cms.Sequence( process.HLTAK4CaloJetsReconstructionSequence + process.HLTAK4CaloJetsCorrectionSequence ) process.HLTEndSequence = cms.Sequence( process.hltBoolEnd ) -process.HLTDoFullUnpackingEgammaEcalSequence = cms.Sequence( process.hltEcalDigis + process.hltEcalPreshowerDigis + process.hltEcalUncalibRecHit + process.hltEcalDetIdToBeRecovered + process.hltEcalRecHit + process.hltEcalPreshowerRecHit ) -process.HLTPFClusteringForEgamma = cms.Sequence( process.hltRechitInRegionsECAL + process.hltRechitInRegionsES + process.hltParticleFlowRecHitECALL1Seeded + process.hltParticleFlowRecHitPSL1Seeded + process.hltParticleFlowClusterPSL1Seeded + process.hltParticleFlowClusterECALUncorrectedL1Seeded + process.hltParticleFlowClusterECALL1Seeded + process.hltParticleFlowSuperClusterECALL1Seeded ) -process.HLTDoLocalHcalWithTowerSequence = cms.Sequence( process.hltHcalDigis + process.hltHbhereco + process.hltHfreco + process.hltHoreco + process.hltTowerMakerForAll ) -process.HLTFastJetForEgamma = cms.Sequence( process.hltFixedGridRhoFastjetAllCaloForMuons ) -process.HLTPFHcalClusteringForEgamma = cms.Sequence( process.hltRegionalTowerForEgamma + process.hltParticleFlowRecHitHCALForEgamma + process.hltParticleFlowClusterHCALForEgamma ) -process.HLTDoLocalPixelSequence = cms.Sequence( process.hltSiPixelDigis + process.hltSiPixelClusters + process.hltSiPixelClustersCache + process.hltSiPixelRecHits ) -process.HLTDoLocalStripSequence = cms.Sequence( process.hltSiStripExcludedFEDListProducer + process.hltSiStripRawToClustersFacility + process.hltSiStripClusters ) -process.HLTGsfElectronSequence = cms.Sequence( process.hltEgammaCkfTrackCandidatesForGSF + process.hltEgammaGsfTracks + process.hltEgammaGsfElectrons + process.hltEgammaGsfTrackVars ) -process.HLTRecoPixelVertexingForElectronSequence = cms.Sequence( process.hltPixelLayerTriplets + process.hltPixelTracksElectrons + process.hltPixelVerticesElectrons ) -process.HLTPixelTrackingForElectron = cms.Sequence( process.hltElectronsVertex + process.HLTDoLocalPixelSequence + process.HLTRecoPixelVertexingForElectronSequence ) -process.HLTIterativeTrackingForElectronsIteration0 = cms.Sequence( process.hltIter0ElectronsPixelSeedsFromPixelTracks + process.hltIter0ElectronsCkfTrackCandidates + process.hltIter0ElectronsCtfWithMaterialTracks + process.hltIter0ElectronsTrackSelectionHighPurity ) -process.HLTIterativeTrackingForElectronsIteration1 = cms.Sequence( process.hltIter1ElectronsClustersRefRemoval + process.hltIter1ElectronsMaskedMeasurementTrackerEvent + process.hltIter1ElectronsPixelLayerTriplets + process.hltIter1ElectronsPixelSeeds + process.hltIter1ElectronsCkfTrackCandidates + process.hltIter1ElectronsCtfWithMaterialTracks + process.hltIter1ElectronsTrackSelectionHighPurityLoose + process.hltIter1ElectronsTrackSelectionHighPurityTight + process.hltIter1ElectronsTrackSelectionHighPurity ) -process.HLTIterativeTrackingForElectronsIteration2 = cms.Sequence( process.hltIter2ElectronsClustersRefRemoval + process.hltIter2ElectronsMaskedMeasurementTrackerEvent + process.hltIter2ElectronsPixelLayerPairs + process.hltIter2ElectronsPixelSeeds + process.hltIter2ElectronsCkfTrackCandidates + process.hltIter2ElectronsCtfWithMaterialTracks + process.hltIter2ElectronsTrackSelectionHighPurity ) -process.HLTIterativeTrackingForElectronIter02 = cms.Sequence( process.HLTIterativeTrackingForElectronsIteration0 + process.HLTIterativeTrackingForElectronsIteration1 + process.hltIter1MergedForElectrons + process.HLTIterativeTrackingForElectronsIteration2 + process.hltIter2MergedForElectrons ) -process.HLTTrackReconstructionForIsoElectronIter02 = cms.Sequence( process.HLTPixelTrackingForElectron + process.HLTDoLocalStripSequence + process.HLTIterativeTrackingForElectronIter02 ) -process.HLTEle27erWP75GsfSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleIsoEG22erFilter + process.hltEG27EtL1IsoEG22erFilter + process.hltEgammaClusterShape + process.hltEle27WP75ClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEle27WP75HcEFilter + process.hltEgammaEcalPFClusterIso + process.hltEle27WP75EcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltEle27WP75HcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltMixedLayerPairs + process.hltEgammaElectronPixelSeeds + process.hltEle27WP75PixelMatchFilter + process.HLTGsfElectronSequence + process.hltEle27WP75GsfOneOEMinusOneOPFilter + process.hltEle27WP75GsfChi2Filter + process.hltEle27WP75GsfDetaFilter + process.hltEle27WP75GsfDphiFilter + process.HLTTrackReconstructionForIsoElectronIter02 + process.hltEgammaEleGsfTrackIso + process.hltEle27WP75GsfTrackIsoFilter ) process.HLTMuonLocalRecoSequence = cms.Sequence( process.hltMuonDTDigis + process.hltDt1DRecHits + process.hltDt4DSegments + process.hltMuonCSCDigis + process.hltCsc2DRecHits + process.hltCscSegments + process.hltMuonRPCDigis + process.hltRpcRecHits ) process.HLTL2muonrecoNocandSequence = cms.Sequence( process.HLTMuonLocalRecoSequence + process.hltL2OfflineMuonSeeds + process.hltL2MuonSeeds + process.hltL2Muons ) process.HLTL2muonrecoSequence = cms.Sequence( process.HLTL2muonrecoNocandSequence + process.hltL2MuonCandidates ) -process.HLTL3muonTkCandidateSequence = cms.Sequence( process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.hltL3TrajSeedOIState + process.hltL3TrackCandidateFromL2OIState + process.hltL3TkTracksFromL2OIState + process.hltL3MuonsOIState + process.hltL3TrajSeedOIHit + process.hltL3TrackCandidateFromL2OIHit + process.hltL3TkTracksFromL2OIHit + process.hltL3MuonsOIHit + process.hltL3TkFromL2OICombination + process.hltPixelLayerTriplets + process.hltPixelLayerPairs + process.hltMixedLayerPairs + process.hltL3TrajSeedIOHit + process.hltL3TrackCandidateFromL2IOHit + process.hltL3TkTracksFromL2IOHit + process.hltL3MuonsIOHit + process.hltL3TrajectorySeed + process.hltL3TrackCandidateFromL2 ) -process.HLTL3muonrecoNocandSequence = cms.Sequence( process.HLTL3muonTkCandidateSequence + process.hltL3TkTracksMergeStep1 + process.hltL3TkTracksFromL2 + process.hltL3MuonsLinksCombination + process.hltL3Muons ) -process.HLTL3muonrecoSequence = cms.Sequence( process.HLTL3muonrecoNocandSequence + process.hltL3MuonCandidates ) -process.HLTDoCaloSequencePF = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence + process.HLTDoLocalHcalSequence + process.hltTowerMakerForPF ) -process.HLTAK4CaloJetsPrePFRecoSequence = cms.Sequence( process.HLTDoCaloSequencePF + process.hltAK4CaloJetsPF ) -process.HLTPreAK4PFJetsRecoSequence = cms.Sequence( process.HLTAK4CaloJetsPrePFRecoSequence + process.hltAK4CaloJetsPFEt5 ) -process.HLTRecopixelvertexingSequence = cms.Sequence( process.hltPixelLayerTriplets + process.hltPixelTracks + process.hltPixelVertices + process.hltTrimmedPixelVertices ) -process.HLTIterativeTrackingIteration0 = cms.Sequence( process.hltIter0PFLowPixelSeedsFromPixelTracks + process.hltIter0PFlowCkfTrackCandidates + process.hltIter0PFlowCtfWithMaterialTracks + process.hltIter0PFlowTrackSelectionHighPurity ) -process.HLTIter0TrackAndTauJet4Iter1Sequence = cms.Sequence( process.hltTrackIter0RefsForJets4Iter1 + process.hltAK4Iter0TrackJets4Iter1 + process.hltIter0TrackAndTauJets4Iter1 ) -process.HLTIterativeTrackingIteration1 = cms.Sequence( process.hltIter1ClustersRefRemoval + process.hltIter1MaskedMeasurementTrackerEvent + process.hltIter1PixelLayerTriplets + process.hltIter1PFlowPixelSeeds + process.hltIter1PFlowCkfTrackCandidates + process.hltIter1PFlowCtfWithMaterialTracks + process.hltIter1PFlowTrackSelectionHighPurityLoose + process.hltIter1PFlowTrackSelectionHighPurityTight + process.hltIter1PFlowTrackSelectionHighPurity ) -process.HLTIter1TrackAndTauJets4Iter2Sequence = cms.Sequence( process.hltIter1TrackRefsForJets4Iter2 + process.hltAK4Iter1TrackJets4Iter2 + process.hltIter1TrackAndTauJets4Iter2 ) -process.HLTIterativeTrackingIteration2 = cms.Sequence( process.hltIter2ClustersRefRemoval + process.hltIter2MaskedMeasurementTrackerEvent + process.hltIter2PixelLayerPairs + process.hltIter2PFlowPixelSeeds + process.hltIter2PFlowCkfTrackCandidates + process.hltIter2PFlowCtfWithMaterialTracks + process.hltIter2PFlowTrackSelectionHighPurity ) -process.HLTIterativeTrackingIter02 = cms.Sequence( process.HLTIterativeTrackingIteration0 + process.HLTIter0TrackAndTauJet4Iter1Sequence + process.HLTIterativeTrackingIteration1 + process.hltIter1Merged + process.HLTIter1TrackAndTauJets4Iter2Sequence + process.HLTIterativeTrackingIteration2 + process.hltIter2Merged ) -process.HLTTrackReconstructionForPF = cms.Sequence( process.HLTDoLocalPixelSequence + process.HLTRecopixelvertexingSequence + process.HLTDoLocalStripSequence + process.HLTIterativeTrackingIter02 + process.hltPFMuonMerging + process.hltMuonLinks + process.hltMuons ) -process.HLTPreshowerSequence = cms.Sequence( process.hltEcalPreshowerDigis + process.hltEcalPreshowerRecHit ) -process.HLTParticleFlowSequence = cms.Sequence( process.HLTPreshowerSequence + process.hltParticleFlowRecHitECALUnseeded + process.hltParticleFlowRecHitHCAL + process.hltParticleFlowRecHitPSUnseeded + process.hltParticleFlowClusterECALUncorrectedUnseeded + process.hltParticleFlowClusterPSUnseeded + process.hltParticleFlowClusterECALUnseeded + process.hltParticleFlowClusterHCAL + process.hltParticleFlowClusterHFEM + process.hltParticleFlowClusterHFHAD + process.hltLightPFTracks + process.hltParticleFlowBlock + process.hltParticleFlow ) -process.HLTAK4PFJetsReconstructionSequence = cms.Sequence( process.HLTL2muonrecoSequence + process.HLTL3muonrecoSequence + process.HLTTrackReconstructionForPF + process.HLTParticleFlowSequence + process.hltAK4PFJets ) -process.HLTAK4PFJetsCorrectionSequence = cms.Sequence( process.hltFixedGridRhoFastjetAll + process.hltAK4PFJetsCorrected ) -process.HLTAK4PFJetsSequence = cms.Sequence( process.HLTPreAK4PFJetsRecoSequence + process.HLTAK4PFJetsReconstructionSequence + process.HLTAK4PFJetsCorrectionSequence ) -process.HLTRecoPixelVertexingForPhotonsSequence = cms.Sequence( process.hltPixelLayerTriplets + process.hltPixelTracks + process.hltPixelVerticesForPhotons ) -process.HLTIterativeTrackingForPhotonsIteration0 = cms.Sequence( process.hltIter0PFlowPixelSeedsFromPixelTracksForPhotons + process.hltIter0PFlowCkfTrackCandidatesForPhotons + process.hltIter0PFlowCtfWithMaterialTracksForPhotons + process.hltIter0PFlowTrackSelectionHighPurityForPhotons ) -process.HLTIterativeTrackingForPhotonsIteration1 = cms.Sequence( process.hltIter1ClustersRefRemovalForPhotons + process.hltIter1MaskedMeasurementTrackerEventForPhotons + process.hltIter1PixelLayerTripletsForPhotons + process.hltIter1PFlowPixelSeedsForPhotons + process.hltIter1PFlowCkfTrackCandidatesForPhotons + process.hltIter1PFlowCtfWithMaterialTracksForPhotons + process.hltIter1PFlowTrackSelectionHighPurityLooseForPhotons + process.hltIter1PFlowTrackSelectionHighPurityTightForPhotons + process.hltIter1PFlowTrackSelectionHighPurityForPhotons ) -process.HLTIterativeTrackingForPhotonsIteration2 = cms.Sequence( process.hltIter2ClustersRefRemovalForPhotons + process.hltIter2MaskedMeasurementTrackerEventForPhotons + process.hltIter2PixelLayerPairsForPhotons + process.hltIter2PFlowPixelSeedsForPhotons + process.hltIter2PFlowCkfTrackCandidatesForPhotons + process.hltIter2PFlowCtfWithMaterialTracksForPhotons + process.hltIter2PFlowTrackSelectionHighPurityForPhotons ) -process.HLTIterativeTrackingForPhotonsIter02 = cms.Sequence( process.HLTIterativeTrackingForPhotonsIteration0 + process.HLTIterativeTrackingForPhotonsIteration1 + process.hltIter1MergedForPhotons + process.HLTIterativeTrackingForPhotonsIteration2 + process.hltIter2MergedForPhotons ) -process.HLTTrackReconstructionForIsoForPhotons = cms.Sequence( process.HLTDoLocalPixelSequence + process.HLTRecoPixelVertexingForPhotonsSequence + process.HLTDoLocalStripSequence + process.HLTIterativeTrackingForPhotonsIter02 ) -process.HLTPhoton20CaloIdVLIsoLSequence = cms.Sequence( process.HLTDoFullUnpackingEgammaEcalSequence + process.HLTPFClusteringForEgamma + process.hltEgammaCandidates + process.hltEGL1SingleEG12Filter + process.hltEG20EtFilter + process.hltEgammaClusterShape + process.hltEG20CaloIdVLClusterShapeFilter + process.HLTDoLocalHcalWithTowerSequence + process.HLTFastJetForEgamma + process.hltEgammaHoverE + process.hltEG20CaloIdVLHEFilter + process.hltEgammaEcalPFClusterIso + process.hltEG20CaloIdVLIsoLEcalIsoFilter + process.HLTPFHcalClusteringForEgamma + process.hltEgammaHcalPFClusterIso + process.hltEG20CaloIdVLIsoLHcalIsoFilter + process.HLTDoLocalPixelSequence + process.HLTDoLocalStripSequence + process.HLTTrackReconstructionForIsoForPhotons + process.hltEgammaHollowTrackIso + process.hltEG20CaloIdVLIsoLTrackIsoFilter ) +process.HLTDoHILocalPixelSequence = cms.Sequence( process.hltSiPixelDigis + process.hltHISiPixelClusters + process.hltHISiPixelClustersCache + process.hltHISiPixelRecHits ) +process.HLTDoHILocalStripSequence = cms.Sequence( process.hltSiStripExcludedFEDListProducer + process.hltSiStripRawToClustersFacility + process.hltHISiStripClusters ) +process.HLTHIL3muonTkCandidateSequence = cms.Sequence( process.HLTDoHILocalPixelSequence + process.HLTDoHILocalStripSequence + process.hltHIL3TrajSeedOIState + process.hltHIL3TrackCandidateFromL2OIState + process.hltHIL3TkTracksFromL2OIState + process.hltHIL3MuonsOIState + process.hltHIL3TrajSeedOIHit + process.hltHIL3TrackCandidateFromL2OIHit + process.hltHIL3TkTracksFromL2OIHit + process.hltHIL3MuonsOIHit + process.hltHIL3TkFromL2OICombination + process.hltHIL3TrajSeedIOHit + process.hltHIL3TrackCandidateFromL2IOHit + process.hltHIL3TkTracksFromL2IOHit + process.hltHIAllL3MuonsIOHit + process.hltHIL3TrajectorySeed + process.hltHIL3TrackCandidateFromL2 ) +process.HLTHIL3muonrecoNocandSequence = cms.Sequence( process.HLTHIL3muonTkCandidateSequence + process.hltHIL3TkTracksFromL2 + process.hltHIL3MuonsLinksCombination + process.hltHIL3Muons ) +process.HLTHIL3muonrecoSequence = cms.Sequence( process.HLTHIL3muonrecoNocandSequence + process.hltHIL3MuonCandidates ) process.HLTriggerFirstPath = cms.Path( process.hltGetConditions + process.hltGetRaw + process.hltBoolFalse ) -process.HLT_CaloJet260_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleJet200 + process.hltPreCaloJet260 + process.HLTAK4CaloJetsSequence + process.hltSingleCaloJet260 + process.HLTEndSequence ) -process.HLT_Ele27_eta2p1_WP75_Gsf_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleIsoEG22er + process.hltPreEle27eta2p1WP75Gsf + process.HLTEle27erWP75GsfSequence + process.HLTEndSequence ) -process.HLT_Mu50_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu16ORSingleMu25 + process.hltPreMu50 + process.hltL1fL1sMu16orMu25L1Filtered0 + process.HLTL2muonrecoSequence + process.hltL2fL1sMu16orMu25L1f0L2Filtered16Q + process.HLTL3muonrecoSequence + process.hltL3fL1sMu16orMu25L1f0L2f16QL3Filtered50Q + process.HLTEndSequence ) -process.HLT_PFJet260_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleJet200 + process.hltPrePFJet260 + process.HLTAK4CaloJetsSequence + process.hltSingleCaloJet210 + process.HLTAK4PFJetsSequence + process.hltPFJetsCorrectedMatchedToCaloJets210 + process.hltSinglePFJet260 + process.HLTEndSequence ) -process.HLT_Photon20_CaloIdVL_IsoL_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleEG10 + process.hltPrePhoton20CaloIdVLIsoL + process.HLTPhoton20CaloIdVLIsoLSequence + process.HLTEndSequence ) process.HLT_Physics_v1 = cms.Path( process.HLTBeginSequence + process.hltPrePhysics + process.HLTEndSequence ) +process.HLT_HIL1DoubleMu0_HighQ_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL1DoubleMu0HighQ + process.hltL1fL1DoubleMu0HQL1Filtered0 + process.HLTEndSequence ) +process.HLT_HIL2Mu3_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL2Mu3 + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu3L2Filtered + process.HLTEndSequence ) +process.HLT_HIL2Mu7_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL2Mu7 + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu7L2Filtered + process.HLTEndSequence ) +process.HLT_HIL2Mu15_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL2Mu15 + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu15L2Filtered + process.HLTEndSequence ) +process.HLT_HIL2Mu3_NHitQ_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL2Mu3NHitQ + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu3N1HitQL2Filtered + process.HLTEndSequence ) +process.HLT_HIL2DoubleMu0_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL2DoubleMu0 + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIL2DoubleMu0L2Filtered + process.HLTEndSequence ) +process.HLT_HIL2DoubleMu0_NHitQ_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL2DoubleMu0NHitQ + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIL2DoubleMu0L2N1HitsFiltered + process.HLTEndSequence ) +process.HLT_HIL2DoubleMu3_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL2DoubleMu3 + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIL2DoubleMu3L2Filtered + process.HLTEndSequence ) +process.HLT_HIL3Mu3_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleMu3BptxAND + process.hltPreHIL3Mu3 + process.hltHIL1SingleMu3Filtered + process.HLTL2muonrecoSequence + process.hltHIL2Mu3L2Filtered + process.HLTHIL3muonrecoSequence + process.hltHISingleMu3L3Filtered + process.HLTEndSequence ) +process.HLT_HIL3DoubleMuOpen_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL3DoubleMuOpen + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIDimuonL2PreFiltered0 + process.HLTHIL3muonrecoSequence + process.hltHIDimuonL3FilterOpen + process.HLTEndSequence ) +process.HLT_HIL3DoubleMuOpen_SS_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL3DoubleMuOpenSS + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIDimuonL2PreFiltered0 + process.HLTHIL3muonrecoSequence + process.hltHIDimuonL3FilterOpenSS + process.HLTEndSequence ) +process.HLT_HIL3DoubleMuOpen_OS_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL3DoubleMuOpenOS + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIDimuonL2PreFiltered0 + process.HLTHIL3muonrecoSequence + process.hltHIDimuonL3FilterOpenOS + process.HLTEndSequence ) +process.HLT_HIL3DoubleMuOpen_OS_NoCowboy_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMuOpenBptxAND + process.hltPreHIL3DoubleMuOpenOSNoCowboy + process.hltHIDoubleMuLevel1PathL1OpenFiltered + process.HLTL2muonrecoSequence + process.hltHIDimuonL2PreFiltered0 + process.HLTHIL3muonrecoSequence + process.hltHIDimuonL3FilterOpenOSNoCowboy + process.HLTEndSequence ) process.HLTriggerFinalPath = cms.Path( process.hltGtDigis + process.hltScalersRawToDigi + process.hltFEDSelector + process.hltTriggerSummaryAOD + process.hltTriggerSummaryRAW ) process.AOutput = cms.EndPath( process.hltPreAOutput + process.hltOutputA ) diff --git a/HLTrigger/Configuration/test/OnMc_HLT_PIon.py b/HLTrigger/Configuration/test/OnMc_HLT_PIon.py index 7395501f19780..b5473387395ba 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_PIon.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_PIon.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/PIon/V4 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/PIon/V5 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTPIon" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/PIon/V4') + tableName = cms.string('/dev/CMSSW_7_4_0/PIon/V5') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( diff --git a/HLTrigger/Configuration/test/runIntegration.csh b/HLTrigger/Configuration/test/runIntegration.csh index 6902f48f518a0..44f47c358643f 100755 --- a/HLTrigger/Configuration/test/runIntegration.csh +++ b/HLTrigger/Configuration/test/runIntegration.csh @@ -10,7 +10,7 @@ echo Start $0 $1 $2 if ( $2 == "" ) then set tables = ( GRun 50nsGRun ) else if ( $2 == ALL ) then - set tables = ( FULL Fake GRun HIon PIon 50nsGRun ) + set tables = ( Fake GRun HIon PIon 50nsGRun ) else if ( $2 == DEV ) then set tables = ( GRun HIon PIon 50nsGRun ) else if ( $2 == FULL ) then diff --git a/HLTrigger/Configuration/test/runOne.csh b/HLTrigger/Configuration/test/runOne.csh index 2c4097fd0d9b6..06b25c857d26e 100755 --- a/HLTrigger/Configuration/test/runOne.csh +++ b/HLTrigger/Configuration/test/runOne.csh @@ -13,7 +13,7 @@ echo Starting $0 $1 $2 if ( $2 == "" ) then set tables = ( GRun 50nsGRun ) else if ( ($2 == all) || ($2 == ALL) ) then - set tables = ( FULL Fake GRun HIon PIon 50nsGRun ) + set tables = ( Fake GRun HIon PIon 50nsGRun ) else if ( ($2 == dev) || ($2 == DEV) ) then set tables = ( GRun HIon PIon 50nsGRun ) else if ( ($2 == full) || ($2 == FULL) ) then diff --git a/L1Trigger/L1TCommon/python/customsPostLS1.py b/L1Trigger/L1TCommon/python/customsPostLS1.py index fc8bcc3b73986..be92cd41da64d 100644 --- a/L1Trigger/L1TCommon/python/customsPostLS1.py +++ b/L1Trigger/L1TCommon/python/customsPostLS1.py @@ -132,6 +132,5 @@ def customiseSimL1EmulatorForPostLS1_HI(process): # set the Stage 1 heavy ions-specific parameters process.simCaloStage1Digis.FirmwareVersion = cms.uint32(1) # move to the heavy ions draft L1 menu once the HLT has been updated accordingly - #process = L1Menu_CollisionsHeavyIons2015_v0(process) - process = L1Menu_Collisions2015_25ns_v2(process) + process = L1Menu_CollisionsHeavyIons2015_v0(process) return process From d3ee4a31a58a4ac2000834f14a5b5d88c3e8e91c Mon Sep 17 00:00:00 2001 From: Martin Grunewald Date: Thu, 26 Feb 2015 19:59:25 +0100 Subject: [PATCH 14/22] CMSHLT-255 HLTL1UnpackerSequence --- .../python/HLT_50nsGRun_Famos_cff.py | 4 +- .../Configuration/python/HLT_50nsGRun_cff.py | 4 +- .../python/HLT_FULL_Famos_cff.py | 4 +- .../Configuration/python/HLT_FULL_cff.py | 60 +++++++++-------- .../python/HLT_GRun_Famos_cff.py | 4 +- .../Configuration/python/HLT_GRun_cff.py | 60 +++++++++-------- .../Configuration/python/HLT_HIon_cff.py | 60 +++++++++-------- .../Configuration/python/HLT_PIon_cff.py | 60 +++++++++-------- .../Configuration/python/Tools/confdb.py | 21 +++--- .../Configuration/test/OnData_HLT_50nsGRun.py | 13 ++-- .../Configuration/test/OnData_HLT_FULL.py | 66 +++++++++++-------- .../Configuration/test/OnData_HLT_GRun.py | 66 +++++++++++-------- .../Configuration/test/OnData_HLT_HIon.py | 66 +++++++++++-------- .../Configuration/test/OnData_HLT_PIon.py | 66 +++++++++++-------- .../Configuration/test/OnMc_HLT_50nsGRun.py | 13 ++-- HLTrigger/Configuration/test/OnMc_HLT_FULL.py | 66 +++++++++++-------- HLTrigger/Configuration/test/OnMc_HLT_GRun.py | 66 +++++++++++-------- HLTrigger/Configuration/test/OnMc_HLT_HIon.py | 66 +++++++++++-------- HLTrigger/Configuration/test/OnMc_HLT_PIon.py | 66 +++++++++++-------- HLTrigger/Configuration/test/cmsDriver.csh | 2 +- L1Trigger/L1TCommon/python/customsPostLS1.py | 35 ---------- 21 files changed, 469 insertions(+), 399 deletions(-) diff --git a/HLTrigger/Configuration/python/HLT_50nsGRun_Famos_cff.py b/HLTrigger/Configuration/python/HLT_50nsGRun_Famos_cff.py index 3c0253d9c3fad..bb77b37786aa5 100644 --- a/HLTrigger/Configuration/python/HLT_50nsGRun_Famos_cff.py +++ b/HLTrigger/Configuration/python/HLT_50nsGRun_Famos_cff.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/50nsGRun/V11 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/50nsGRun/V15 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms from FastSimulation.HighLevelTrigger.HLTSetup_cff import * HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V11') + tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V15') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( diff --git a/HLTrigger/Configuration/python/HLT_50nsGRun_cff.py b/HLTrigger/Configuration/python/HLT_50nsGRun_cff.py index 21028d25eee03..3b501f0d8dfbc 100644 --- a/HLTrigger/Configuration/python/HLT_50nsGRun_cff.py +++ b/HLTrigger/Configuration/python/HLT_50nsGRun_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_4_0/50nsGRun/V11 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/50nsGRun/V15 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V11') + tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V15') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( diff --git a/HLTrigger/Configuration/python/HLT_FULL_Famos_cff.py b/HLTrigger/Configuration/python/HLT_FULL_Famos_cff.py index 1484dd13448ab..5532dce44d563 100644 --- a/HLTrigger/Configuration/python/HLT_FULL_Famos_cff.py +++ b/HLTrigger/Configuration/python/HLT_FULL_Famos_cff.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/HLT/V10 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/HLT/V11 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms from FastSimulation.HighLevelTrigger.HLTSetup_cff import * HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V10') + tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V11') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( diff --git a/HLTrigger/Configuration/python/HLT_FULL_cff.py b/HLTrigger/Configuration/python/HLT_FULL_cff.py index 5c24ae66687ea..0aba259049dd2 100644 --- a/HLTrigger/Configuration/python/HLT_FULL_cff.py +++ b/HLTrigger/Configuration/python/HLT_FULL_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_4_0/HLT/V10 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/HLT/V11 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V10') + tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V11') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1872,16 +1872,24 @@ ActiveBoardsMask = cms.uint32( 0xffff ), DaqGtInputTag = cms.InputTag( "rawDataCollector" ) ) -hltGctDigis = cms.EDProducer( "GctRawToDigi", - checkHeaders = cms.untracked.bool( False ), - unpackSharedRegions = cms.bool( False ), - numberOfGctSamplesToUnpack = cms.uint32( 1 ), - verbose = cms.untracked.bool( False ), - numberOfRctSamplesToUnpack = cms.uint32( 1 ), - inputLabel = cms.InputTag( "rawDataCollector" ), - unpackerVersion = cms.uint32( 0 ), - gctFedId = cms.untracked.int32( 745 ), - hltMode = cms.bool( True ) +hltCaloStage1Digis = cms.EDProducer( "L1TRawToDigi", + lenSlinkTrailer = cms.untracked.int32( 8 ), + lenAMC13Header = cms.untracked.int32( 8 ), + lenAMC13Trailer = cms.untracked.int32( 8 ), + Setup = cms.string( "stage1::CaloSetup" ), + InputLabel = cms.InputTag( "rawDataCollector" ), + lenSlinkHeader = cms.untracked.int32( 8 ), + FWId = cms.untracked.int32( 2 ), + lenAMCHeader = cms.untracked.int32( 8 ), + lenAMCTrailer = cms.untracked.int32( 0 ), + FedId = cms.int32( 1352 ) +) +hltCaloStage1LegacyFormatDigis = cms.EDProducer( "L1TCaloUpgradeToGCTConverter", + InputHFCountsCollection = cms.InputTag( 'hltCaloStage1Digis','HFBitCounts' ), + InputHFSumsCollection = cms.InputTag( 'hltCaloStage1Digis','HFRingSums' ), + InputRlxTauCollection = cms.InputTag( 'hltCaloStage1Digis','rlxTaus' ), + InputIsoTauCollection = cms.InputTag( 'hltCaloStage1Digis','isoTaus' ), + InputCollection = cms.InputTag( "hltCaloStage1Digis" ) ) hltL1GtObjectMap = cms.EDProducer( "L1GlobalTrigger", TechnicalTriggersUnprescaled = cms.bool( True ), @@ -1899,29 +1907,29 @@ AlternativeNrBxBoardEvm = cms.uint32( 0 ), TechnicalTriggersInputTags = cms.VInputTag( 'simBscDigis' ), CastorInputTag = cms.InputTag( "castorL1Digis" ), - GctInputTag = cms.InputTag( "hltGctDigis" ), + GctInputTag = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), AlternativeNrBxBoardDaq = cms.uint32( 0 ), WritePsbL1GtDaqRecord = cms.bool( False ), BstLengthBytes = cms.int32( -1 ) ) hltL1extraParticles = cms.EDProducer( "L1ExtraParticlesProd", - tauJetSource = cms.InputTag( 'hltGctDigis','tauJets' ), - etHadSource = cms.InputTag( "hltGctDigis" ), - isoTauJetSource = cms.InputTag( 'hltGctDigis','isoTauJets' ), - etTotalSource = cms.InputTag( "hltGctDigis" ), + tauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','tauJets' ), + etHadSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + isoTauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoTauJets' ), + etTotalSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), centralBxOnly = cms.bool( True ), - centralJetSource = cms.InputTag( 'hltGctDigis','cenJets' ), - etMissSource = cms.InputTag( "hltGctDigis" ), - hfRingEtSumsSource = cms.InputTag( "hltGctDigis" ), + centralJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','cenJets' ), + etMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + hfRingEtSumsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceMuonParticles = cms.bool( True ), - forwardJetSource = cms.InputTag( 'hltGctDigis','forJets' ), + forwardJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','forJets' ), ignoreHtMiss = cms.bool( False ), - htMissSource = cms.InputTag( "hltGctDigis" ), + htMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceCaloParticles = cms.bool( True ), muonSource = cms.InputTag( "hltGtDigis" ), - isolatedEmSource = cms.InputTag( 'hltGctDigis','isoEm' ), - nonIsolatedEmSource = cms.InputTag( 'hltGctDigis','nonIsoEm' ), - hfRingBitCountsSource = cms.InputTag( "hltGctDigis" ) + isolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoEm' ), + nonIsolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','nonIsoEm' ), + hfRingBitCountsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ) ) hltScalersRawToDigi = cms.EDProducer( "ScalersRawToDigi", scalersInputTag = cms.InputTag( "rawDataCollector" ) @@ -46748,7 +46756,7 @@ HLTriggerResults = cms.InputTag( 'TriggerResults','','HLT' ) ) -HLTL1UnpackerSequence = cms.Sequence( hltGtDigis + hltGctDigis + hltL1GtObjectMap + hltL1extraParticles ) +HLTL1UnpackerSequence = cms.Sequence( hltGtDigis + hltCaloStage1Digis + hltCaloStage1LegacyFormatDigis + hltL1GtObjectMap + hltL1extraParticles ) HLTBeamSpot = cms.Sequence( hltScalersRawToDigi + hltOnlineBeamSpot ) HLTBeginSequence = cms.Sequence( hltTriggerType + HLTL1UnpackerSequence + HLTBeamSpot ) HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence = cms.Sequence( hltEcalDigis + hltEcalUncalibRecHit + hltEcalDetIdToBeRecovered + hltEcalRecHit ) diff --git a/HLTrigger/Configuration/python/HLT_GRun_Famos_cff.py b/HLTrigger/Configuration/python/HLT_GRun_Famos_cff.py index 98ae64d521865..e29a26d9d0313 100644 --- a/HLTrigger/Configuration/python/HLT_GRun_Famos_cff.py +++ b/HLTrigger/Configuration/python/HLT_GRun_Famos_cff.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/GRun/V5 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/GRun/V6 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms from FastSimulation.HighLevelTrigger.HLTSetup_cff import * HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V5') + tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V6') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( diff --git a/HLTrigger/Configuration/python/HLT_GRun_cff.py b/HLTrigger/Configuration/python/HLT_GRun_cff.py index c7e26b8a291bc..73306f44b34f2 100644 --- a/HLTrigger/Configuration/python/HLT_GRun_cff.py +++ b/HLTrigger/Configuration/python/HLT_GRun_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_4_0/GRun/V5 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/GRun/V6 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V5') + tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V6') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1830,16 +1830,24 @@ ActiveBoardsMask = cms.uint32( 0xffff ), DaqGtInputTag = cms.InputTag( "rawDataCollector" ) ) -hltGctDigis = cms.EDProducer( "GctRawToDigi", - checkHeaders = cms.untracked.bool( False ), - unpackSharedRegions = cms.bool( False ), - numberOfGctSamplesToUnpack = cms.uint32( 1 ), - verbose = cms.untracked.bool( False ), - numberOfRctSamplesToUnpack = cms.uint32( 1 ), - inputLabel = cms.InputTag( "rawDataCollector" ), - unpackerVersion = cms.uint32( 0 ), - gctFedId = cms.untracked.int32( 745 ), - hltMode = cms.bool( True ) +hltCaloStage1Digis = cms.EDProducer( "L1TRawToDigi", + lenSlinkTrailer = cms.untracked.int32( 8 ), + lenAMC13Header = cms.untracked.int32( 8 ), + lenAMC13Trailer = cms.untracked.int32( 8 ), + Setup = cms.string( "stage1::CaloSetup" ), + InputLabel = cms.InputTag( "rawDataCollector" ), + lenSlinkHeader = cms.untracked.int32( 8 ), + FWId = cms.untracked.int32( 2 ), + lenAMCHeader = cms.untracked.int32( 8 ), + lenAMCTrailer = cms.untracked.int32( 0 ), + FedId = cms.int32( 1352 ) +) +hltCaloStage1LegacyFormatDigis = cms.EDProducer( "L1TCaloUpgradeToGCTConverter", + InputHFCountsCollection = cms.InputTag( 'hltCaloStage1Digis','HFBitCounts' ), + InputHFSumsCollection = cms.InputTag( 'hltCaloStage1Digis','HFRingSums' ), + InputRlxTauCollection = cms.InputTag( 'hltCaloStage1Digis','rlxTaus' ), + InputIsoTauCollection = cms.InputTag( 'hltCaloStage1Digis','isoTaus' ), + InputCollection = cms.InputTag( "hltCaloStage1Digis" ) ) hltL1GtObjectMap = cms.EDProducer( "L1GlobalTrigger", TechnicalTriggersUnprescaled = cms.bool( True ), @@ -1857,29 +1865,29 @@ AlternativeNrBxBoardEvm = cms.uint32( 0 ), TechnicalTriggersInputTags = cms.VInputTag( 'simBscDigis' ), CastorInputTag = cms.InputTag( "castorL1Digis" ), - GctInputTag = cms.InputTag( "hltGctDigis" ), + GctInputTag = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), AlternativeNrBxBoardDaq = cms.uint32( 0 ), WritePsbL1GtDaqRecord = cms.bool( False ), BstLengthBytes = cms.int32( -1 ) ) hltL1extraParticles = cms.EDProducer( "L1ExtraParticlesProd", - tauJetSource = cms.InputTag( 'hltGctDigis','tauJets' ), - etHadSource = cms.InputTag( "hltGctDigis" ), - isoTauJetSource = cms.InputTag( 'hltGctDigis','isoTauJets' ), - etTotalSource = cms.InputTag( "hltGctDigis" ), + tauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','tauJets' ), + etHadSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + isoTauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoTauJets' ), + etTotalSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), centralBxOnly = cms.bool( True ), - centralJetSource = cms.InputTag( 'hltGctDigis','cenJets' ), - etMissSource = cms.InputTag( "hltGctDigis" ), - hfRingEtSumsSource = cms.InputTag( "hltGctDigis" ), + centralJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','cenJets' ), + etMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + hfRingEtSumsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceMuonParticles = cms.bool( True ), - forwardJetSource = cms.InputTag( 'hltGctDigis','forJets' ), + forwardJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','forJets' ), ignoreHtMiss = cms.bool( False ), - htMissSource = cms.InputTag( "hltGctDigis" ), + htMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceCaloParticles = cms.bool( True ), muonSource = cms.InputTag( "hltGtDigis" ), - isolatedEmSource = cms.InputTag( 'hltGctDigis','isoEm' ), - nonIsolatedEmSource = cms.InputTag( 'hltGctDigis','nonIsoEm' ), - hfRingBitCountsSource = cms.InputTag( "hltGctDigis" ) + isolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoEm' ), + nonIsolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','nonIsoEm' ), + hfRingBitCountsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ) ) hltScalersRawToDigi = cms.EDProducer( "ScalersRawToDigi", scalersInputTag = cms.InputTag( "rawDataCollector" ) @@ -43093,7 +43101,7 @@ HLTriggerResults = cms.InputTag( 'TriggerResults','','HLT' ) ) -HLTL1UnpackerSequence = cms.Sequence( hltGtDigis + hltGctDigis + hltL1GtObjectMap + hltL1extraParticles ) +HLTL1UnpackerSequence = cms.Sequence( hltGtDigis + hltCaloStage1Digis + hltCaloStage1LegacyFormatDigis + hltL1GtObjectMap + hltL1extraParticles ) HLTBeamSpot = cms.Sequence( hltScalersRawToDigi + hltOnlineBeamSpot ) HLTBeginSequence = cms.Sequence( hltTriggerType + HLTL1UnpackerSequence + HLTBeamSpot ) HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence = cms.Sequence( hltEcalDigis + hltEcalUncalibRecHit + hltEcalDetIdToBeRecovered + hltEcalRecHit ) diff --git a/HLTrigger/Configuration/python/HLT_HIon_cff.py b/HLTrigger/Configuration/python/HLT_HIon_cff.py index c48626ff96cc0..e6ee7beabd468 100644 --- a/HLTrigger/Configuration/python/HLT_HIon_cff.py +++ b/HLTrigger/Configuration/python/HLT_HIon_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_4_0/HIon/V5 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/HIon/V6 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HIon/V5') + tableName = cms.string('/dev/CMSSW_7_4_0/HIon/V6') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1537,16 +1537,24 @@ ActiveBoardsMask = cms.uint32( 0xffff ), DaqGtInputTag = cms.InputTag( "rawDataCollector" ) ) -hltGctDigis = cms.EDProducer( "GctRawToDigi", - checkHeaders = cms.untracked.bool( False ), - unpackSharedRegions = cms.bool( False ), - numberOfGctSamplesToUnpack = cms.uint32( 1 ), - verbose = cms.untracked.bool( False ), - numberOfRctSamplesToUnpack = cms.uint32( 1 ), - inputLabel = cms.InputTag( "rawDataCollector" ), - unpackerVersion = cms.uint32( 0 ), - gctFedId = cms.untracked.int32( 745 ), - hltMode = cms.bool( True ) +hltCaloStage1Digis = cms.EDProducer( "L1TRawToDigi", + lenSlinkTrailer = cms.untracked.int32( 8 ), + lenAMC13Header = cms.untracked.int32( 8 ), + lenAMC13Trailer = cms.untracked.int32( 8 ), + Setup = cms.string( "stage1::CaloSetup" ), + InputLabel = cms.InputTag( "rawDataCollector" ), + lenSlinkHeader = cms.untracked.int32( 8 ), + FWId = cms.untracked.int32( 2 ), + lenAMCHeader = cms.untracked.int32( 8 ), + lenAMCTrailer = cms.untracked.int32( 0 ), + FedId = cms.int32( 1352 ) +) +hltCaloStage1LegacyFormatDigis = cms.EDProducer( "L1TCaloUpgradeToGCTConverter", + InputHFCountsCollection = cms.InputTag( 'hltCaloStage1Digis','HFBitCounts' ), + InputHFSumsCollection = cms.InputTag( 'hltCaloStage1Digis','HFRingSums' ), + InputRlxTauCollection = cms.InputTag( 'hltCaloStage1Digis','rlxTaus' ), + InputIsoTauCollection = cms.InputTag( 'hltCaloStage1Digis','isoTaus' ), + InputCollection = cms.InputTag( "hltCaloStage1Digis" ) ) hltL1GtObjectMap = cms.EDProducer( "L1GlobalTrigger", TechnicalTriggersUnprescaled = cms.bool( True ), @@ -1564,29 +1572,29 @@ AlternativeNrBxBoardEvm = cms.uint32( 0 ), TechnicalTriggersInputTags = cms.VInputTag( 'simBscDigis' ), CastorInputTag = cms.InputTag( "castorL1Digis" ), - GctInputTag = cms.InputTag( "hltGctDigis" ), + GctInputTag = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), AlternativeNrBxBoardDaq = cms.uint32( 0 ), WritePsbL1GtDaqRecord = cms.bool( False ), BstLengthBytes = cms.int32( -1 ) ) hltL1extraParticles = cms.EDProducer( "L1ExtraParticlesProd", - tauJetSource = cms.InputTag( 'hltGctDigis','tauJets' ), - etHadSource = cms.InputTag( "hltGctDigis" ), - isoTauJetSource = cms.InputTag( 'hltGctDigis','isoTauJets' ), - etTotalSource = cms.InputTag( "hltGctDigis" ), + tauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','tauJets' ), + etHadSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + isoTauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoTauJets' ), + etTotalSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), centralBxOnly = cms.bool( True ), - centralJetSource = cms.InputTag( 'hltGctDigis','cenJets' ), - etMissSource = cms.InputTag( "hltGctDigis" ), - hfRingEtSumsSource = cms.InputTag( "hltGctDigis" ), + centralJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','cenJets' ), + etMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + hfRingEtSumsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceMuonParticles = cms.bool( True ), - forwardJetSource = cms.InputTag( 'hltGctDigis','forJets' ), + forwardJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','forJets' ), ignoreHtMiss = cms.bool( False ), - htMissSource = cms.InputTag( "hltGctDigis" ), + htMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceCaloParticles = cms.bool( True ), muonSource = cms.InputTag( "hltGtDigis" ), - isolatedEmSource = cms.InputTag( 'hltGctDigis','isoEm' ), - nonIsolatedEmSource = cms.InputTag( 'hltGctDigis','nonIsoEm' ), - hfRingBitCountsSource = cms.InputTag( "hltGctDigis" ) + isolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoEm' ), + nonIsolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','nonIsoEm' ), + hfRingBitCountsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ) ) hltScalersRawToDigi = cms.EDProducer( "ScalersRawToDigi", scalersInputTag = cms.InputTag( "rawDataCollector" ) @@ -3367,7 +3375,7 @@ HLTriggerResults = cms.InputTag( 'TriggerResults','','HLT' ) ) -HLTL1UnpackerSequence = cms.Sequence( hltGtDigis + hltGctDigis + hltL1GtObjectMap + hltL1extraParticles ) +HLTL1UnpackerSequence = cms.Sequence( hltGtDigis + hltCaloStage1Digis + hltCaloStage1LegacyFormatDigis + hltL1GtObjectMap + hltL1extraParticles ) HLTBeamSpot = cms.Sequence( hltScalersRawToDigi + hltOnlineBeamSpot ) HLTBeginSequence = cms.Sequence( hltTriggerType + HLTL1UnpackerSequence + HLTBeamSpot ) HLTEndSequence = cms.Sequence( hltBoolEnd ) diff --git a/HLTrigger/Configuration/python/HLT_PIon_cff.py b/HLTrigger/Configuration/python/HLT_PIon_cff.py index 56ca02f1124e6..92a923a1dfd06 100644 --- a/HLTrigger/Configuration/python/HLT_PIon_cff.py +++ b/HLTrigger/Configuration/python/HLT_PIon_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_4_0/PIon/V5 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/PIon/V6 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/PIon/V5') + tableName = cms.string('/dev/CMSSW_7_4_0/PIon/V6') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1529,16 +1529,24 @@ ActiveBoardsMask = cms.uint32( 0xffff ), DaqGtInputTag = cms.InputTag( "rawDataCollector" ) ) -hltGctDigis = cms.EDProducer( "GctRawToDigi", - checkHeaders = cms.untracked.bool( False ), - unpackSharedRegions = cms.bool( False ), - numberOfGctSamplesToUnpack = cms.uint32( 1 ), - verbose = cms.untracked.bool( False ), - numberOfRctSamplesToUnpack = cms.uint32( 1 ), - inputLabel = cms.InputTag( "rawDataCollector" ), - unpackerVersion = cms.uint32( 0 ), - gctFedId = cms.untracked.int32( 745 ), - hltMode = cms.bool( True ) +hltCaloStage1Digis = cms.EDProducer( "L1TRawToDigi", + lenSlinkTrailer = cms.untracked.int32( 8 ), + lenAMC13Header = cms.untracked.int32( 8 ), + lenAMC13Trailer = cms.untracked.int32( 8 ), + Setup = cms.string( "stage1::CaloSetup" ), + InputLabel = cms.InputTag( "rawDataCollector" ), + lenSlinkHeader = cms.untracked.int32( 8 ), + FWId = cms.untracked.int32( 2 ), + lenAMCHeader = cms.untracked.int32( 8 ), + lenAMCTrailer = cms.untracked.int32( 0 ), + FedId = cms.int32( 1352 ) +) +hltCaloStage1LegacyFormatDigis = cms.EDProducer( "L1TCaloUpgradeToGCTConverter", + InputHFCountsCollection = cms.InputTag( 'hltCaloStage1Digis','HFBitCounts' ), + InputHFSumsCollection = cms.InputTag( 'hltCaloStage1Digis','HFRingSums' ), + InputRlxTauCollection = cms.InputTag( 'hltCaloStage1Digis','rlxTaus' ), + InputIsoTauCollection = cms.InputTag( 'hltCaloStage1Digis','isoTaus' ), + InputCollection = cms.InputTag( "hltCaloStage1Digis" ) ) hltL1GtObjectMap = cms.EDProducer( "L1GlobalTrigger", TechnicalTriggersUnprescaled = cms.bool( True ), @@ -1556,29 +1564,29 @@ AlternativeNrBxBoardEvm = cms.uint32( 0 ), TechnicalTriggersInputTags = cms.VInputTag( 'simBscDigis' ), CastorInputTag = cms.InputTag( "castorL1Digis" ), - GctInputTag = cms.InputTag( "hltGctDigis" ), + GctInputTag = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), AlternativeNrBxBoardDaq = cms.uint32( 0 ), WritePsbL1GtDaqRecord = cms.bool( False ), BstLengthBytes = cms.int32( -1 ) ) hltL1extraParticles = cms.EDProducer( "L1ExtraParticlesProd", - tauJetSource = cms.InputTag( 'hltGctDigis','tauJets' ), - etHadSource = cms.InputTag( "hltGctDigis" ), - isoTauJetSource = cms.InputTag( 'hltGctDigis','isoTauJets' ), - etTotalSource = cms.InputTag( "hltGctDigis" ), + tauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','tauJets' ), + etHadSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + isoTauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoTauJets' ), + etTotalSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), centralBxOnly = cms.bool( True ), - centralJetSource = cms.InputTag( 'hltGctDigis','cenJets' ), - etMissSource = cms.InputTag( "hltGctDigis" ), - hfRingEtSumsSource = cms.InputTag( "hltGctDigis" ), + centralJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','cenJets' ), + etMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + hfRingEtSumsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceMuonParticles = cms.bool( True ), - forwardJetSource = cms.InputTag( 'hltGctDigis','forJets' ), + forwardJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','forJets' ), ignoreHtMiss = cms.bool( False ), - htMissSource = cms.InputTag( "hltGctDigis" ), + htMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceCaloParticles = cms.bool( True ), muonSource = cms.InputTag( "hltGtDigis" ), - isolatedEmSource = cms.InputTag( 'hltGctDigis','isoEm' ), - nonIsolatedEmSource = cms.InputTag( 'hltGctDigis','nonIsoEm' ), - hfRingBitCountsSource = cms.InputTag( "hltGctDigis" ) + isolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoEm' ), + nonIsolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','nonIsoEm' ), + hfRingBitCountsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ) ) hltScalersRawToDigi = cms.EDProducer( "ScalersRawToDigi", scalersInputTag = cms.InputTag( "rawDataCollector" ) @@ -7931,7 +7939,7 @@ HLTriggerResults = cms.InputTag( 'TriggerResults','','HLT' ) ) -HLTL1UnpackerSequence = cms.Sequence( hltGtDigis + hltGctDigis + hltL1GtObjectMap + hltL1extraParticles ) +HLTL1UnpackerSequence = cms.Sequence( hltGtDigis + hltCaloStage1Digis + hltCaloStage1LegacyFormatDigis + hltL1GtObjectMap + hltL1extraParticles ) HLTBeamSpot = cms.Sequence( hltScalersRawToDigi + hltOnlineBeamSpot ) HLTBeginSequence = cms.Sequence( hltTriggerType + HLTL1UnpackerSequence + HLTBeamSpot ) HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence = cms.Sequence( hltEcalDigis + hltEcalUncalibRecHit + hltEcalDetIdToBeRecovered + hltEcalRecHit ) diff --git a/HLTrigger/Configuration/python/Tools/confdb.py b/HLTrigger/Configuration/python/Tools/confdb.py index 20c35746f790d..f5cb836da3b84 100755 --- a/HLTrigger/Configuration/python/Tools/confdb.py +++ b/HLTrigger/Configuration/python/Tools/confdb.py @@ -296,21 +296,24 @@ def customize(self): if self.config.type not in ('Fake',) : if self.config.type in ('50nsGRun',) : self.data += """ -# load PostLS1 customisation for 50ns -from SLHCUpgradeSimulations.Configuration.postLS1Customs import customisePostLS1_50ns -process = customisePostLS1_50ns(process) +# load 2015 Run-2 L1 Menu for 50ns +# move to the 50ns v0 L1 menu once the 50ns HLT has been updated accordingly +# from L1Trigger.Configuration.customise_overwriteL1Menu import L1Menu_Collisions2015_50ns_v0 as loadL1Menu +# until then use the 25ns L1 menu +from L1Trigger.Configuration.customise_overwriteL1Menu import L1Menu_Collisions2015_25ns_v2 as loadL1Menu +process = loadL1Menu(process) """ elif self.config.type in ('HIon',) : self.data += """ -# load PostLS1 customisation for HIon -from SLHCUpgradeSimulations.Configuration.postLS1Customs import customisePostLS1_HI -process = customisePostLS1_HI(process) +# load 2015 Run-2 L1 Menu for HIon +from L1Trigger.Configuration.customise_overwriteL1Menu import L1Menu_CollisionsHeavyIons2015_v0 as loadL1Menu +process = loadL1Menu(process) """ else : self.data += """ -# load PostLS1 customisation for 25ns -from SLHCUpgradeSimulations.Configuration.postLS1Customs import customisePostLS1 -process = customisePostLS1(process) +# load 2015 Run-2 L1 Menu for 25ns (default for GRun, PIon) +from L1Trigger.Configuration.customise_overwriteL1Menu import L1Menu_Collisions2015_25ns_v2 as loadL1menu +process = loadL1menu(process) """ # override the process name and adapt the relevant filters diff --git a/HLTrigger/Configuration/test/OnData_HLT_50nsGRun.py b/HLTrigger/Configuration/test/OnData_HLT_50nsGRun.py index fe2545b141c06..3f63edb93b18c 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_50nsGRun.py +++ b/HLTrigger/Configuration/test/OnData_HLT_50nsGRun.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/50nsGRun/V11 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/50nsGRun/V15 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLT50nsGRun" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V11') + tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V15') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -44760,9 +44760,12 @@ del process.TrackerDigiGeometryESModule.trackerGeometryConstants.upgradeGeometry -# load PostLS1 customisation for 50ns -from SLHCUpgradeSimulations.Configuration.postLS1Customs import customisePostLS1_50ns -process = customisePostLS1_50ns(process) +# load 2015 Run-2 L1 Menu for 50ns +# move to the 50ns v0 L1 menu once the 50ns HLT has been updated accordingly +# from L1Trigger.Configuration.customise_overwriteL1Menu import L1Menu_Collisions2015_50ns_v0 as loadL1Menu +# until then use the 25ns L1 menu +from L1Trigger.Configuration.customise_overwriteL1Menu import L1Menu_Collisions2015_25ns_v2 as loadL1Menu +process = loadL1Menu(process) # adapt HLT modules to the correct process name if 'hltTrigReport' in process.__dict__: diff --git a/HLTrigger/Configuration/test/OnData_HLT_FULL.py b/HLTrigger/Configuration/test/OnData_HLT_FULL.py index 398371b399ca1..6a690aa2bcf3b 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_FULL.py +++ b/HLTrigger/Configuration/test/OnData_HLT_FULL.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/HLT/V10 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/HLT/V11 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTFULL" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V10') + tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V11') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2368,16 +2368,24 @@ ActiveBoardsMask = cms.uint32( 0xffff ), DaqGtInputTag = cms.InputTag( "rawDataCollector" ) ) -process.hltGctDigis = cms.EDProducer( "GctRawToDigi", - checkHeaders = cms.untracked.bool( False ), - unpackSharedRegions = cms.bool( False ), - numberOfGctSamplesToUnpack = cms.uint32( 1 ), - verbose = cms.untracked.bool( False ), - numberOfRctSamplesToUnpack = cms.uint32( 1 ), - inputLabel = cms.InputTag( "rawDataCollector" ), - unpackerVersion = cms.uint32( 0 ), - gctFedId = cms.untracked.int32( 745 ), - hltMode = cms.bool( True ) +process.hltCaloStage1Digis = cms.EDProducer( "L1TRawToDigi", + lenSlinkTrailer = cms.untracked.int32( 8 ), + lenAMC13Header = cms.untracked.int32( 8 ), + lenAMC13Trailer = cms.untracked.int32( 8 ), + Setup = cms.string( "stage1::CaloSetup" ), + InputLabel = cms.InputTag( "rawDataCollector" ), + lenSlinkHeader = cms.untracked.int32( 8 ), + FWId = cms.untracked.int32( 2 ), + lenAMCHeader = cms.untracked.int32( 8 ), + lenAMCTrailer = cms.untracked.int32( 0 ), + FedId = cms.int32( 1352 ) +) +process.hltCaloStage1LegacyFormatDigis = cms.EDProducer( "L1TCaloUpgradeToGCTConverter", + InputHFCountsCollection = cms.InputTag( 'hltCaloStage1Digis','HFBitCounts' ), + InputHFSumsCollection = cms.InputTag( 'hltCaloStage1Digis','HFRingSums' ), + InputRlxTauCollection = cms.InputTag( 'hltCaloStage1Digis','rlxTaus' ), + InputIsoTauCollection = cms.InputTag( 'hltCaloStage1Digis','isoTaus' ), + InputCollection = cms.InputTag( "hltCaloStage1Digis" ) ) process.hltL1GtObjectMap = cms.EDProducer( "L1GlobalTrigger", TechnicalTriggersUnprescaled = cms.bool( True ), @@ -2395,29 +2403,29 @@ AlternativeNrBxBoardEvm = cms.uint32( 0 ), TechnicalTriggersInputTags = cms.VInputTag( 'simBscDigis' ), CastorInputTag = cms.InputTag( "castorL1Digis" ), - GctInputTag = cms.InputTag( "hltGctDigis" ), + GctInputTag = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), AlternativeNrBxBoardDaq = cms.uint32( 0 ), WritePsbL1GtDaqRecord = cms.bool( False ), BstLengthBytes = cms.int32( -1 ) ) process.hltL1extraParticles = cms.EDProducer( "L1ExtraParticlesProd", - tauJetSource = cms.InputTag( 'hltGctDigis','tauJets' ), - etHadSource = cms.InputTag( "hltGctDigis" ), - isoTauJetSource = cms.InputTag( 'hltGctDigis','isoTauJets' ), - etTotalSource = cms.InputTag( "hltGctDigis" ), + tauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','tauJets' ), + etHadSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + isoTauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoTauJets' ), + etTotalSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), centralBxOnly = cms.bool( True ), - centralJetSource = cms.InputTag( 'hltGctDigis','cenJets' ), - etMissSource = cms.InputTag( "hltGctDigis" ), - hfRingEtSumsSource = cms.InputTag( "hltGctDigis" ), + centralJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','cenJets' ), + etMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + hfRingEtSumsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceMuonParticles = cms.bool( True ), - forwardJetSource = cms.InputTag( 'hltGctDigis','forJets' ), + forwardJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','forJets' ), ignoreHtMiss = cms.bool( False ), - htMissSource = cms.InputTag( "hltGctDigis" ), + htMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceCaloParticles = cms.bool( True ), muonSource = cms.InputTag( "hltGtDigis" ), - isolatedEmSource = cms.InputTag( 'hltGctDigis','isoEm' ), - nonIsolatedEmSource = cms.InputTag( 'hltGctDigis','nonIsoEm' ), - hfRingBitCountsSource = cms.InputTag( "hltGctDigis" ) + isolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoEm' ), + nonIsolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','nonIsoEm' ), + hfRingBitCountsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ) ) process.hltScalersRawToDigi = cms.EDProducer( "ScalersRawToDigi", scalersInputTag = cms.InputTag( "rawDataCollector" ) @@ -47593,7 +47601,7 @@ 'keep triggerTriggerEvent_*_*_*' ) ) -process.HLTL1UnpackerSequence = cms.Sequence( process.hltGtDigis + process.hltGctDigis + process.hltL1GtObjectMap + process.hltL1extraParticles ) +process.HLTL1UnpackerSequence = cms.Sequence( process.hltGtDigis + process.hltCaloStage1Digis + process.hltCaloStage1LegacyFormatDigis + process.hltL1GtObjectMap + process.hltL1extraParticles ) process.HLTBeamSpot = cms.Sequence( process.hltScalersRawToDigi + process.hltOnlineBeamSpot ) process.HLTBeginSequence = cms.Sequence( process.hltTriggerType + process.HLTL1UnpackerSequence + process.HLTBeamSpot ) process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence = cms.Sequence( process.hltEcalDigis + process.hltEcalUncalibRecHit + process.hltEcalDetIdToBeRecovered + process.hltEcalRecHit ) @@ -48281,9 +48289,9 @@ del process.TrackerDigiGeometryESModule.trackerGeometryConstants.upgradeGeometry -# load PostLS1 customisation for 25ns -from SLHCUpgradeSimulations.Configuration.postLS1Customs import customisePostLS1 -process = customisePostLS1(process) +# load 2015 Run-2 L1 Menu for 25ns (default for GRun, PIon) +from L1Trigger.Configuration.customise_overwriteL1Menu import L1Menu_Collisions2015_25ns_v2 as loadL1menu +process = loadL1menu(process) # adapt HLT modules to the correct process name if 'hltTrigReport' in process.__dict__: diff --git a/HLTrigger/Configuration/test/OnData_HLT_GRun.py b/HLTrigger/Configuration/test/OnData_HLT_GRun.py index 6ffd284dc9839..46a8c4fdf17ca 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_GRun.py +++ b/HLTrigger/Configuration/test/OnData_HLT_GRun.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/GRun/V5 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/GRun/V6 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTGRun" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V5') + tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V6') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2326,16 +2326,24 @@ ActiveBoardsMask = cms.uint32( 0xffff ), DaqGtInputTag = cms.InputTag( "rawDataCollector" ) ) -process.hltGctDigis = cms.EDProducer( "GctRawToDigi", - checkHeaders = cms.untracked.bool( False ), - unpackSharedRegions = cms.bool( False ), - numberOfGctSamplesToUnpack = cms.uint32( 1 ), - verbose = cms.untracked.bool( False ), - numberOfRctSamplesToUnpack = cms.uint32( 1 ), - inputLabel = cms.InputTag( "rawDataCollector" ), - unpackerVersion = cms.uint32( 0 ), - gctFedId = cms.untracked.int32( 745 ), - hltMode = cms.bool( True ) +process.hltCaloStage1Digis = cms.EDProducer( "L1TRawToDigi", + lenSlinkTrailer = cms.untracked.int32( 8 ), + lenAMC13Header = cms.untracked.int32( 8 ), + lenAMC13Trailer = cms.untracked.int32( 8 ), + Setup = cms.string( "stage1::CaloSetup" ), + InputLabel = cms.InputTag( "rawDataCollector" ), + lenSlinkHeader = cms.untracked.int32( 8 ), + FWId = cms.untracked.int32( 2 ), + lenAMCHeader = cms.untracked.int32( 8 ), + lenAMCTrailer = cms.untracked.int32( 0 ), + FedId = cms.int32( 1352 ) +) +process.hltCaloStage1LegacyFormatDigis = cms.EDProducer( "L1TCaloUpgradeToGCTConverter", + InputHFCountsCollection = cms.InputTag( 'hltCaloStage1Digis','HFBitCounts' ), + InputHFSumsCollection = cms.InputTag( 'hltCaloStage1Digis','HFRingSums' ), + InputRlxTauCollection = cms.InputTag( 'hltCaloStage1Digis','rlxTaus' ), + InputIsoTauCollection = cms.InputTag( 'hltCaloStage1Digis','isoTaus' ), + InputCollection = cms.InputTag( "hltCaloStage1Digis" ) ) process.hltL1GtObjectMap = cms.EDProducer( "L1GlobalTrigger", TechnicalTriggersUnprescaled = cms.bool( True ), @@ -2353,29 +2361,29 @@ AlternativeNrBxBoardEvm = cms.uint32( 0 ), TechnicalTriggersInputTags = cms.VInputTag( 'simBscDigis' ), CastorInputTag = cms.InputTag( "castorL1Digis" ), - GctInputTag = cms.InputTag( "hltGctDigis" ), + GctInputTag = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), AlternativeNrBxBoardDaq = cms.uint32( 0 ), WritePsbL1GtDaqRecord = cms.bool( False ), BstLengthBytes = cms.int32( -1 ) ) process.hltL1extraParticles = cms.EDProducer( "L1ExtraParticlesProd", - tauJetSource = cms.InputTag( 'hltGctDigis','tauJets' ), - etHadSource = cms.InputTag( "hltGctDigis" ), - isoTauJetSource = cms.InputTag( 'hltGctDigis','isoTauJets' ), - etTotalSource = cms.InputTag( "hltGctDigis" ), + tauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','tauJets' ), + etHadSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + isoTauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoTauJets' ), + etTotalSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), centralBxOnly = cms.bool( True ), - centralJetSource = cms.InputTag( 'hltGctDigis','cenJets' ), - etMissSource = cms.InputTag( "hltGctDigis" ), - hfRingEtSumsSource = cms.InputTag( "hltGctDigis" ), + centralJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','cenJets' ), + etMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + hfRingEtSumsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceMuonParticles = cms.bool( True ), - forwardJetSource = cms.InputTag( 'hltGctDigis','forJets' ), + forwardJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','forJets' ), ignoreHtMiss = cms.bool( False ), - htMissSource = cms.InputTag( "hltGctDigis" ), + htMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceCaloParticles = cms.bool( True ), muonSource = cms.InputTag( "hltGtDigis" ), - isolatedEmSource = cms.InputTag( 'hltGctDigis','isoEm' ), - nonIsolatedEmSource = cms.InputTag( 'hltGctDigis','nonIsoEm' ), - hfRingBitCountsSource = cms.InputTag( "hltGctDigis" ) + isolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoEm' ), + nonIsolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','nonIsoEm' ), + hfRingBitCountsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ) ) process.hltScalersRawToDigi = cms.EDProducer( "ScalersRawToDigi", scalersInputTag = cms.InputTag( "rawDataCollector" ) @@ -43911,7 +43919,7 @@ 'keep triggerTriggerEvent_*_*_*' ) ) -process.HLTL1UnpackerSequence = cms.Sequence( process.hltGtDigis + process.hltGctDigis + process.hltL1GtObjectMap + process.hltL1extraParticles ) +process.HLTL1UnpackerSequence = cms.Sequence( process.hltGtDigis + process.hltCaloStage1Digis + process.hltCaloStage1LegacyFormatDigis + process.hltL1GtObjectMap + process.hltL1extraParticles ) process.HLTBeamSpot = cms.Sequence( process.hltScalersRawToDigi + process.hltOnlineBeamSpot ) process.HLTBeginSequence = cms.Sequence( process.hltTriggerType + process.HLTL1UnpackerSequence + process.HLTBeamSpot ) process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence = cms.Sequence( process.hltEcalDigis + process.hltEcalUncalibRecHit + process.hltEcalDetIdToBeRecovered + process.hltEcalRecHit ) @@ -44554,9 +44562,9 @@ del process.TrackerDigiGeometryESModule.trackerGeometryConstants.upgradeGeometry -# load PostLS1 customisation for 25ns -from SLHCUpgradeSimulations.Configuration.postLS1Customs import customisePostLS1 -process = customisePostLS1(process) +# load 2015 Run-2 L1 Menu for 25ns (default for GRun, PIon) +from L1Trigger.Configuration.customise_overwriteL1Menu import L1Menu_Collisions2015_25ns_v2 as loadL1menu +process = loadL1menu(process) # adapt HLT modules to the correct process name if 'hltTrigReport' in process.__dict__: diff --git a/HLTrigger/Configuration/test/OnData_HLT_HIon.py b/HLTrigger/Configuration/test/OnData_HLT_HIon.py index a36a22dc9c24e..f3dff2ca8f6e3 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_HIon.py +++ b/HLTrigger/Configuration/test/OnData_HLT_HIon.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/HIon/V5 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/HIon/V6 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTHIon" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HIon/V5') + tableName = cms.string('/dev/CMSSW_7_4_0/HIon/V6') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2033,16 +2033,24 @@ ActiveBoardsMask = cms.uint32( 0xffff ), DaqGtInputTag = cms.InputTag( "rawDataRepacker" ) ) -process.hltGctDigis = cms.EDProducer( "GctRawToDigi", - checkHeaders = cms.untracked.bool( False ), - unpackSharedRegions = cms.bool( False ), - numberOfGctSamplesToUnpack = cms.uint32( 1 ), - verbose = cms.untracked.bool( False ), - numberOfRctSamplesToUnpack = cms.uint32( 1 ), - inputLabel = cms.InputTag( "rawDataRepacker" ), - unpackerVersion = cms.uint32( 0 ), - gctFedId = cms.untracked.int32( 745 ), - hltMode = cms.bool( True ) +process.hltCaloStage1Digis = cms.EDProducer( "L1TRawToDigi", + lenSlinkTrailer = cms.untracked.int32( 8 ), + lenAMC13Header = cms.untracked.int32( 8 ), + lenAMC13Trailer = cms.untracked.int32( 8 ), + Setup = cms.string( "stage1::CaloSetup" ), + InputLabel = cms.InputTag( "rawDataRepacker" ), + lenSlinkHeader = cms.untracked.int32( 8 ), + FWId = cms.untracked.int32( 2 ), + lenAMCHeader = cms.untracked.int32( 8 ), + lenAMCTrailer = cms.untracked.int32( 0 ), + FedId = cms.int32( 1352 ) +) +process.hltCaloStage1LegacyFormatDigis = cms.EDProducer( "L1TCaloUpgradeToGCTConverter", + InputHFCountsCollection = cms.InputTag( 'hltCaloStage1Digis','HFBitCounts' ), + InputHFSumsCollection = cms.InputTag( 'hltCaloStage1Digis','HFRingSums' ), + InputRlxTauCollection = cms.InputTag( 'hltCaloStage1Digis','rlxTaus' ), + InputIsoTauCollection = cms.InputTag( 'hltCaloStage1Digis','isoTaus' ), + InputCollection = cms.InputTag( "hltCaloStage1Digis" ) ) process.hltL1GtObjectMap = cms.EDProducer( "L1GlobalTrigger", TechnicalTriggersUnprescaled = cms.bool( True ), @@ -2060,29 +2068,29 @@ AlternativeNrBxBoardEvm = cms.uint32( 0 ), TechnicalTriggersInputTags = cms.VInputTag( 'simBscDigis' ), CastorInputTag = cms.InputTag( "castorL1Digis" ), - GctInputTag = cms.InputTag( "hltGctDigis" ), + GctInputTag = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), AlternativeNrBxBoardDaq = cms.uint32( 0 ), WritePsbL1GtDaqRecord = cms.bool( False ), BstLengthBytes = cms.int32( -1 ) ) process.hltL1extraParticles = cms.EDProducer( "L1ExtraParticlesProd", - tauJetSource = cms.InputTag( 'hltGctDigis','tauJets' ), - etHadSource = cms.InputTag( "hltGctDigis" ), - isoTauJetSource = cms.InputTag( 'hltGctDigis','isoTauJets' ), - etTotalSource = cms.InputTag( "hltGctDigis" ), + tauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','tauJets' ), + etHadSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + isoTauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoTauJets' ), + etTotalSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), centralBxOnly = cms.bool( True ), - centralJetSource = cms.InputTag( 'hltGctDigis','cenJets' ), - etMissSource = cms.InputTag( "hltGctDigis" ), - hfRingEtSumsSource = cms.InputTag( "hltGctDigis" ), + centralJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','cenJets' ), + etMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + hfRingEtSumsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceMuonParticles = cms.bool( True ), - forwardJetSource = cms.InputTag( 'hltGctDigis','forJets' ), + forwardJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','forJets' ), ignoreHtMiss = cms.bool( False ), - htMissSource = cms.InputTag( "hltGctDigis" ), + htMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceCaloParticles = cms.bool( True ), muonSource = cms.InputTag( "hltGtDigis" ), - isolatedEmSource = cms.InputTag( 'hltGctDigis','isoEm' ), - nonIsolatedEmSource = cms.InputTag( 'hltGctDigis','nonIsoEm' ), - hfRingBitCountsSource = cms.InputTag( "hltGctDigis" ) + isolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoEm' ), + nonIsolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','nonIsoEm' ), + hfRingBitCountsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ) ) process.hltScalersRawToDigi = cms.EDProducer( "ScalersRawToDigi", scalersInputTag = cms.InputTag( "rawDataRepacker" ) @@ -3895,7 +3903,7 @@ 'keep triggerTriggerEvent_*_*_*' ) ) -process.HLTL1UnpackerSequence = cms.Sequence( process.hltGtDigis + process.hltGctDigis + process.hltL1GtObjectMap + process.hltL1extraParticles ) +process.HLTL1UnpackerSequence = cms.Sequence( process.hltGtDigis + process.hltCaloStage1Digis + process.hltCaloStage1LegacyFormatDigis + process.hltL1GtObjectMap + process.hltL1extraParticles ) process.HLTBeamSpot = cms.Sequence( process.hltScalersRawToDigi + process.hltOnlineBeamSpot ) process.HLTBeginSequence = cms.Sequence( process.hltTriggerType + process.HLTL1UnpackerSequence + process.HLTBeamSpot ) process.HLTEndSequence = cms.Sequence( process.hltBoolEnd ) @@ -3965,9 +3973,9 @@ del process.TrackerDigiGeometryESModule.trackerGeometryConstants.upgradeGeometry -# load PostLS1 customisation for HIon -from SLHCUpgradeSimulations.Configuration.postLS1Customs import customisePostLS1_HI -process = customisePostLS1_HI(process) +# load 2015 Run-2 L1 Menu for HIon +from L1Trigger.Configuration.customise_overwriteL1Menu import L1Menu_CollisionsHeavyIons2015_v0 as loadL1Menu +process = loadL1Menu(process) # adapt HLT modules to the correct process name if 'hltTrigReport' in process.__dict__: diff --git a/HLTrigger/Configuration/test/OnData_HLT_PIon.py b/HLTrigger/Configuration/test/OnData_HLT_PIon.py index cfa762dfc4f16..bb25c4bd36678 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_PIon.py +++ b/HLTrigger/Configuration/test/OnData_HLT_PIon.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/PIon/V5 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/PIon/V6 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTPIon" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/PIon/V5') + tableName = cms.string('/dev/CMSSW_7_4_0/PIon/V6') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2025,16 +2025,24 @@ ActiveBoardsMask = cms.uint32( 0xffff ), DaqGtInputTag = cms.InputTag( "rawDataCollector" ) ) -process.hltGctDigis = cms.EDProducer( "GctRawToDigi", - checkHeaders = cms.untracked.bool( False ), - unpackSharedRegions = cms.bool( False ), - numberOfGctSamplesToUnpack = cms.uint32( 1 ), - verbose = cms.untracked.bool( False ), - numberOfRctSamplesToUnpack = cms.uint32( 1 ), - inputLabel = cms.InputTag( "rawDataCollector" ), - unpackerVersion = cms.uint32( 0 ), - gctFedId = cms.untracked.int32( 745 ), - hltMode = cms.bool( True ) +process.hltCaloStage1Digis = cms.EDProducer( "L1TRawToDigi", + lenSlinkTrailer = cms.untracked.int32( 8 ), + lenAMC13Header = cms.untracked.int32( 8 ), + lenAMC13Trailer = cms.untracked.int32( 8 ), + Setup = cms.string( "stage1::CaloSetup" ), + InputLabel = cms.InputTag( "rawDataCollector" ), + lenSlinkHeader = cms.untracked.int32( 8 ), + FWId = cms.untracked.int32( 2 ), + lenAMCHeader = cms.untracked.int32( 8 ), + lenAMCTrailer = cms.untracked.int32( 0 ), + FedId = cms.int32( 1352 ) +) +process.hltCaloStage1LegacyFormatDigis = cms.EDProducer( "L1TCaloUpgradeToGCTConverter", + InputHFCountsCollection = cms.InputTag( 'hltCaloStage1Digis','HFBitCounts' ), + InputHFSumsCollection = cms.InputTag( 'hltCaloStage1Digis','HFRingSums' ), + InputRlxTauCollection = cms.InputTag( 'hltCaloStage1Digis','rlxTaus' ), + InputIsoTauCollection = cms.InputTag( 'hltCaloStage1Digis','isoTaus' ), + InputCollection = cms.InputTag( "hltCaloStage1Digis" ) ) process.hltL1GtObjectMap = cms.EDProducer( "L1GlobalTrigger", TechnicalTriggersUnprescaled = cms.bool( True ), @@ -2052,29 +2060,29 @@ AlternativeNrBxBoardEvm = cms.uint32( 0 ), TechnicalTriggersInputTags = cms.VInputTag( 'simBscDigis' ), CastorInputTag = cms.InputTag( "castorL1Digis" ), - GctInputTag = cms.InputTag( "hltGctDigis" ), + GctInputTag = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), AlternativeNrBxBoardDaq = cms.uint32( 0 ), WritePsbL1GtDaqRecord = cms.bool( False ), BstLengthBytes = cms.int32( -1 ) ) process.hltL1extraParticles = cms.EDProducer( "L1ExtraParticlesProd", - tauJetSource = cms.InputTag( 'hltGctDigis','tauJets' ), - etHadSource = cms.InputTag( "hltGctDigis" ), - isoTauJetSource = cms.InputTag( 'hltGctDigis','isoTauJets' ), - etTotalSource = cms.InputTag( "hltGctDigis" ), + tauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','tauJets' ), + etHadSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + isoTauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoTauJets' ), + etTotalSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), centralBxOnly = cms.bool( True ), - centralJetSource = cms.InputTag( 'hltGctDigis','cenJets' ), - etMissSource = cms.InputTag( "hltGctDigis" ), - hfRingEtSumsSource = cms.InputTag( "hltGctDigis" ), + centralJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','cenJets' ), + etMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + hfRingEtSumsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceMuonParticles = cms.bool( True ), - forwardJetSource = cms.InputTag( 'hltGctDigis','forJets' ), + forwardJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','forJets' ), ignoreHtMiss = cms.bool( False ), - htMissSource = cms.InputTag( "hltGctDigis" ), + htMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceCaloParticles = cms.bool( True ), muonSource = cms.InputTag( "hltGtDigis" ), - isolatedEmSource = cms.InputTag( 'hltGctDigis','isoEm' ), - nonIsolatedEmSource = cms.InputTag( 'hltGctDigis','nonIsoEm' ), - hfRingBitCountsSource = cms.InputTag( "hltGctDigis" ) + isolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoEm' ), + nonIsolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','nonIsoEm' ), + hfRingBitCountsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ) ) process.hltScalersRawToDigi = cms.EDProducer( "ScalersRawToDigi", scalersInputTag = cms.InputTag( "rawDataCollector" ) @@ -8451,7 +8459,7 @@ 'keep triggerTriggerEvent_*_*_*' ) ) -process.HLTL1UnpackerSequence = cms.Sequence( process.hltGtDigis + process.hltGctDigis + process.hltL1GtObjectMap + process.hltL1extraParticles ) +process.HLTL1UnpackerSequence = cms.Sequence( process.hltGtDigis + process.hltCaloStage1Digis + process.hltCaloStage1LegacyFormatDigis + process.hltL1GtObjectMap + process.hltL1extraParticles ) process.HLTBeamSpot = cms.Sequence( process.hltScalersRawToDigi + process.hltOnlineBeamSpot ) process.HLTBeginSequence = cms.Sequence( process.hltTriggerType + process.HLTL1UnpackerSequence + process.HLTBeamSpot ) process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence = cms.Sequence( process.hltEcalDigis + process.hltEcalUncalibRecHit + process.hltEcalDetIdToBeRecovered + process.hltEcalRecHit ) @@ -8556,9 +8564,9 @@ del process.TrackerDigiGeometryESModule.trackerGeometryConstants.upgradeGeometry -# load PostLS1 customisation for 25ns -from SLHCUpgradeSimulations.Configuration.postLS1Customs import customisePostLS1 -process = customisePostLS1(process) +# load 2015 Run-2 L1 Menu for 25ns (default for GRun, PIon) +from L1Trigger.Configuration.customise_overwriteL1Menu import L1Menu_Collisions2015_25ns_v2 as loadL1menu +process = loadL1menu(process) # adapt HLT modules to the correct process name if 'hltTrigReport' in process.__dict__: diff --git a/HLTrigger/Configuration/test/OnMc_HLT_50nsGRun.py b/HLTrigger/Configuration/test/OnMc_HLT_50nsGRun.py index d80fec431caee..c3aa6111dbd3d 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_50nsGRun.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_50nsGRun.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/50nsGRun/V11 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/50nsGRun/V15 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLT50nsGRun" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V11') + tableName = cms.string('/dev/CMSSW_7_4_0/50nsGRun/V15') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -44764,9 +44764,12 @@ del process.TrackerDigiGeometryESModule.trackerGeometryConstants.upgradeGeometry -# load PostLS1 customisation for 50ns -from SLHCUpgradeSimulations.Configuration.postLS1Customs import customisePostLS1_50ns -process = customisePostLS1_50ns(process) +# load 2015 Run-2 L1 Menu for 50ns +# move to the 50ns v0 L1 menu once the 50ns HLT has been updated accordingly +# from L1Trigger.Configuration.customise_overwriteL1Menu import L1Menu_Collisions2015_50ns_v0 as loadL1Menu +# until then use the 25ns L1 menu +from L1Trigger.Configuration.customise_overwriteL1Menu import L1Menu_Collisions2015_25ns_v2 as loadL1Menu +process = loadL1Menu(process) # adapt HLT modules to the correct process name if 'hltTrigReport' in process.__dict__: diff --git a/HLTrigger/Configuration/test/OnMc_HLT_FULL.py b/HLTrigger/Configuration/test/OnMc_HLT_FULL.py index 26269740c388f..039153aafb24d 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_FULL.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_FULL.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/HLT/V10 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/HLT/V11 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTFULL" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V10') + tableName = cms.string('/dev/CMSSW_7_4_0/HLT/V11') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2368,16 +2368,24 @@ ActiveBoardsMask = cms.uint32( 0xffff ), DaqGtInputTag = cms.InputTag( "rawDataCollector" ) ) -process.hltGctDigis = cms.EDProducer( "GctRawToDigi", - checkHeaders = cms.untracked.bool( False ), - unpackSharedRegions = cms.bool( False ), - numberOfGctSamplesToUnpack = cms.uint32( 1 ), - verbose = cms.untracked.bool( False ), - numberOfRctSamplesToUnpack = cms.uint32( 1 ), - inputLabel = cms.InputTag( "rawDataCollector" ), - unpackerVersion = cms.uint32( 0 ), - gctFedId = cms.untracked.int32( 745 ), - hltMode = cms.bool( True ) +process.hltCaloStage1Digis = cms.EDProducer( "L1TRawToDigi", + lenSlinkTrailer = cms.untracked.int32( 8 ), + lenAMC13Header = cms.untracked.int32( 8 ), + lenAMC13Trailer = cms.untracked.int32( 8 ), + Setup = cms.string( "stage1::CaloSetup" ), + InputLabel = cms.InputTag( "rawDataCollector" ), + lenSlinkHeader = cms.untracked.int32( 8 ), + FWId = cms.untracked.int32( 2 ), + lenAMCHeader = cms.untracked.int32( 8 ), + lenAMCTrailer = cms.untracked.int32( 0 ), + FedId = cms.int32( 1352 ) +) +process.hltCaloStage1LegacyFormatDigis = cms.EDProducer( "L1TCaloUpgradeToGCTConverter", + InputHFCountsCollection = cms.InputTag( 'hltCaloStage1Digis','HFBitCounts' ), + InputHFSumsCollection = cms.InputTag( 'hltCaloStage1Digis','HFRingSums' ), + InputRlxTauCollection = cms.InputTag( 'hltCaloStage1Digis','rlxTaus' ), + InputIsoTauCollection = cms.InputTag( 'hltCaloStage1Digis','isoTaus' ), + InputCollection = cms.InputTag( "hltCaloStage1Digis" ) ) process.hltL1GtObjectMap = cms.EDProducer( "L1GlobalTrigger", TechnicalTriggersUnprescaled = cms.bool( True ), @@ -2395,29 +2403,29 @@ AlternativeNrBxBoardEvm = cms.uint32( 0 ), TechnicalTriggersInputTags = cms.VInputTag( 'simBscDigis' ), CastorInputTag = cms.InputTag( "castorL1Digis" ), - GctInputTag = cms.InputTag( "hltGctDigis" ), + GctInputTag = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), AlternativeNrBxBoardDaq = cms.uint32( 0 ), WritePsbL1GtDaqRecord = cms.bool( False ), BstLengthBytes = cms.int32( -1 ) ) process.hltL1extraParticles = cms.EDProducer( "L1ExtraParticlesProd", - tauJetSource = cms.InputTag( 'hltGctDigis','tauJets' ), - etHadSource = cms.InputTag( "hltGctDigis" ), - isoTauJetSource = cms.InputTag( 'hltGctDigis','isoTauJets' ), - etTotalSource = cms.InputTag( "hltGctDigis" ), + tauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','tauJets' ), + etHadSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + isoTauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoTauJets' ), + etTotalSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), centralBxOnly = cms.bool( True ), - centralJetSource = cms.InputTag( 'hltGctDigis','cenJets' ), - etMissSource = cms.InputTag( "hltGctDigis" ), - hfRingEtSumsSource = cms.InputTag( "hltGctDigis" ), + centralJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','cenJets' ), + etMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + hfRingEtSumsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceMuonParticles = cms.bool( True ), - forwardJetSource = cms.InputTag( 'hltGctDigis','forJets' ), + forwardJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','forJets' ), ignoreHtMiss = cms.bool( False ), - htMissSource = cms.InputTag( "hltGctDigis" ), + htMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceCaloParticles = cms.bool( True ), muonSource = cms.InputTag( "hltGtDigis" ), - isolatedEmSource = cms.InputTag( 'hltGctDigis','isoEm' ), - nonIsolatedEmSource = cms.InputTag( 'hltGctDigis','nonIsoEm' ), - hfRingBitCountsSource = cms.InputTag( "hltGctDigis" ) + isolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoEm' ), + nonIsolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','nonIsoEm' ), + hfRingBitCountsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ) ) process.hltScalersRawToDigi = cms.EDProducer( "ScalersRawToDigi", scalersInputTag = cms.InputTag( "rawDataCollector" ) @@ -47593,7 +47601,7 @@ 'keep triggerTriggerEvent_*_*_*' ) ) -process.HLTL1UnpackerSequence = cms.Sequence( process.hltGtDigis + process.hltGctDigis + process.hltL1GtObjectMap + process.hltL1extraParticles ) +process.HLTL1UnpackerSequence = cms.Sequence( process.hltGtDigis + process.hltCaloStage1Digis + process.hltCaloStage1LegacyFormatDigis + process.hltL1GtObjectMap + process.hltL1extraParticles ) process.HLTBeamSpot = cms.Sequence( process.hltScalersRawToDigi + process.hltOnlineBeamSpot ) process.HLTBeginSequence = cms.Sequence( process.hltTriggerType + process.HLTL1UnpackerSequence + process.HLTBeamSpot ) process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence = cms.Sequence( process.hltEcalDigis + process.hltEcalUncalibRecHit + process.hltEcalDetIdToBeRecovered + process.hltEcalRecHit ) @@ -48285,9 +48293,9 @@ del process.TrackerDigiGeometryESModule.trackerGeometryConstants.upgradeGeometry -# load PostLS1 customisation for 25ns -from SLHCUpgradeSimulations.Configuration.postLS1Customs import customisePostLS1 -process = customisePostLS1(process) +# load 2015 Run-2 L1 Menu for 25ns (default for GRun, PIon) +from L1Trigger.Configuration.customise_overwriteL1Menu import L1Menu_Collisions2015_25ns_v2 as loadL1menu +process = loadL1menu(process) # adapt HLT modules to the correct process name if 'hltTrigReport' in process.__dict__: diff --git a/HLTrigger/Configuration/test/OnMc_HLT_GRun.py b/HLTrigger/Configuration/test/OnMc_HLT_GRun.py index 0d482a568dda1..ff6a228ace18a 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_GRun.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_GRun.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/GRun/V5 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/GRun/V6 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTGRun" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V5') + tableName = cms.string('/dev/CMSSW_7_4_0/GRun/V6') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2326,16 +2326,24 @@ ActiveBoardsMask = cms.uint32( 0xffff ), DaqGtInputTag = cms.InputTag( "rawDataCollector" ) ) -process.hltGctDigis = cms.EDProducer( "GctRawToDigi", - checkHeaders = cms.untracked.bool( False ), - unpackSharedRegions = cms.bool( False ), - numberOfGctSamplesToUnpack = cms.uint32( 1 ), - verbose = cms.untracked.bool( False ), - numberOfRctSamplesToUnpack = cms.uint32( 1 ), - inputLabel = cms.InputTag( "rawDataCollector" ), - unpackerVersion = cms.uint32( 0 ), - gctFedId = cms.untracked.int32( 745 ), - hltMode = cms.bool( True ) +process.hltCaloStage1Digis = cms.EDProducer( "L1TRawToDigi", + lenSlinkTrailer = cms.untracked.int32( 8 ), + lenAMC13Header = cms.untracked.int32( 8 ), + lenAMC13Trailer = cms.untracked.int32( 8 ), + Setup = cms.string( "stage1::CaloSetup" ), + InputLabel = cms.InputTag( "rawDataCollector" ), + lenSlinkHeader = cms.untracked.int32( 8 ), + FWId = cms.untracked.int32( 2 ), + lenAMCHeader = cms.untracked.int32( 8 ), + lenAMCTrailer = cms.untracked.int32( 0 ), + FedId = cms.int32( 1352 ) +) +process.hltCaloStage1LegacyFormatDigis = cms.EDProducer( "L1TCaloUpgradeToGCTConverter", + InputHFCountsCollection = cms.InputTag( 'hltCaloStage1Digis','HFBitCounts' ), + InputHFSumsCollection = cms.InputTag( 'hltCaloStage1Digis','HFRingSums' ), + InputRlxTauCollection = cms.InputTag( 'hltCaloStage1Digis','rlxTaus' ), + InputIsoTauCollection = cms.InputTag( 'hltCaloStage1Digis','isoTaus' ), + InputCollection = cms.InputTag( "hltCaloStage1Digis" ) ) process.hltL1GtObjectMap = cms.EDProducer( "L1GlobalTrigger", TechnicalTriggersUnprescaled = cms.bool( True ), @@ -2353,29 +2361,29 @@ AlternativeNrBxBoardEvm = cms.uint32( 0 ), TechnicalTriggersInputTags = cms.VInputTag( 'simBscDigis' ), CastorInputTag = cms.InputTag( "castorL1Digis" ), - GctInputTag = cms.InputTag( "hltGctDigis" ), + GctInputTag = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), AlternativeNrBxBoardDaq = cms.uint32( 0 ), WritePsbL1GtDaqRecord = cms.bool( False ), BstLengthBytes = cms.int32( -1 ) ) process.hltL1extraParticles = cms.EDProducer( "L1ExtraParticlesProd", - tauJetSource = cms.InputTag( 'hltGctDigis','tauJets' ), - etHadSource = cms.InputTag( "hltGctDigis" ), - isoTauJetSource = cms.InputTag( 'hltGctDigis','isoTauJets' ), - etTotalSource = cms.InputTag( "hltGctDigis" ), + tauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','tauJets' ), + etHadSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + isoTauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoTauJets' ), + etTotalSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), centralBxOnly = cms.bool( True ), - centralJetSource = cms.InputTag( 'hltGctDigis','cenJets' ), - etMissSource = cms.InputTag( "hltGctDigis" ), - hfRingEtSumsSource = cms.InputTag( "hltGctDigis" ), + centralJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','cenJets' ), + etMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + hfRingEtSumsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceMuonParticles = cms.bool( True ), - forwardJetSource = cms.InputTag( 'hltGctDigis','forJets' ), + forwardJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','forJets' ), ignoreHtMiss = cms.bool( False ), - htMissSource = cms.InputTag( "hltGctDigis" ), + htMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceCaloParticles = cms.bool( True ), muonSource = cms.InputTag( "hltGtDigis" ), - isolatedEmSource = cms.InputTag( 'hltGctDigis','isoEm' ), - nonIsolatedEmSource = cms.InputTag( 'hltGctDigis','nonIsoEm' ), - hfRingBitCountsSource = cms.InputTag( "hltGctDigis" ) + isolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoEm' ), + nonIsolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','nonIsoEm' ), + hfRingBitCountsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ) ) process.hltScalersRawToDigi = cms.EDProducer( "ScalersRawToDigi", scalersInputTag = cms.InputTag( "rawDataCollector" ) @@ -43911,7 +43919,7 @@ 'keep triggerTriggerEvent_*_*_*' ) ) -process.HLTL1UnpackerSequence = cms.Sequence( process.hltGtDigis + process.hltGctDigis + process.hltL1GtObjectMap + process.hltL1extraParticles ) +process.HLTL1UnpackerSequence = cms.Sequence( process.hltGtDigis + process.hltCaloStage1Digis + process.hltCaloStage1LegacyFormatDigis + process.hltL1GtObjectMap + process.hltL1extraParticles ) process.HLTBeamSpot = cms.Sequence( process.hltScalersRawToDigi + process.hltOnlineBeamSpot ) process.HLTBeginSequence = cms.Sequence( process.hltTriggerType + process.HLTL1UnpackerSequence + process.HLTBeamSpot ) process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence = cms.Sequence( process.hltEcalDigis + process.hltEcalUncalibRecHit + process.hltEcalDetIdToBeRecovered + process.hltEcalRecHit ) @@ -44558,9 +44566,9 @@ del process.TrackerDigiGeometryESModule.trackerGeometryConstants.upgradeGeometry -# load PostLS1 customisation for 25ns -from SLHCUpgradeSimulations.Configuration.postLS1Customs import customisePostLS1 -process = customisePostLS1(process) +# load 2015 Run-2 L1 Menu for 25ns (default for GRun, PIon) +from L1Trigger.Configuration.customise_overwriteL1Menu import L1Menu_Collisions2015_25ns_v2 as loadL1menu +process = loadL1menu(process) # adapt HLT modules to the correct process name if 'hltTrigReport' in process.__dict__: diff --git a/HLTrigger/Configuration/test/OnMc_HLT_HIon.py b/HLTrigger/Configuration/test/OnMc_HLT_HIon.py index bc2aaa59513ba..380c9294b2604 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_HIon.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_HIon.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/HIon/V5 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/HIon/V6 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTHIon" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/HIon/V5') + tableName = cms.string('/dev/CMSSW_7_4_0/HIon/V6') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2033,16 +2033,24 @@ ActiveBoardsMask = cms.uint32( 0xffff ), DaqGtInputTag = cms.InputTag( "rawDataCollector" ) ) -process.hltGctDigis = cms.EDProducer( "GctRawToDigi", - checkHeaders = cms.untracked.bool( False ), - unpackSharedRegions = cms.bool( False ), - numberOfGctSamplesToUnpack = cms.uint32( 1 ), - verbose = cms.untracked.bool( False ), - numberOfRctSamplesToUnpack = cms.uint32( 1 ), - inputLabel = cms.InputTag( "rawDataCollector" ), - unpackerVersion = cms.uint32( 0 ), - gctFedId = cms.untracked.int32( 745 ), - hltMode = cms.bool( True ) +process.hltCaloStage1Digis = cms.EDProducer( "L1TRawToDigi", + lenSlinkTrailer = cms.untracked.int32( 8 ), + lenAMC13Header = cms.untracked.int32( 8 ), + lenAMC13Trailer = cms.untracked.int32( 8 ), + Setup = cms.string( "stage1::CaloSetup" ), + InputLabel = cms.InputTag( "rawDataCollector" ), + lenSlinkHeader = cms.untracked.int32( 8 ), + FWId = cms.untracked.int32( 2 ), + lenAMCHeader = cms.untracked.int32( 8 ), + lenAMCTrailer = cms.untracked.int32( 0 ), + FedId = cms.int32( 1352 ) +) +process.hltCaloStage1LegacyFormatDigis = cms.EDProducer( "L1TCaloUpgradeToGCTConverter", + InputHFCountsCollection = cms.InputTag( 'hltCaloStage1Digis','HFBitCounts' ), + InputHFSumsCollection = cms.InputTag( 'hltCaloStage1Digis','HFRingSums' ), + InputRlxTauCollection = cms.InputTag( 'hltCaloStage1Digis','rlxTaus' ), + InputIsoTauCollection = cms.InputTag( 'hltCaloStage1Digis','isoTaus' ), + InputCollection = cms.InputTag( "hltCaloStage1Digis" ) ) process.hltL1GtObjectMap = cms.EDProducer( "L1GlobalTrigger", TechnicalTriggersUnprescaled = cms.bool( True ), @@ -2060,29 +2068,29 @@ AlternativeNrBxBoardEvm = cms.uint32( 0 ), TechnicalTriggersInputTags = cms.VInputTag( 'simBscDigis' ), CastorInputTag = cms.InputTag( "castorL1Digis" ), - GctInputTag = cms.InputTag( "hltGctDigis" ), + GctInputTag = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), AlternativeNrBxBoardDaq = cms.uint32( 0 ), WritePsbL1GtDaqRecord = cms.bool( False ), BstLengthBytes = cms.int32( -1 ) ) process.hltL1extraParticles = cms.EDProducer( "L1ExtraParticlesProd", - tauJetSource = cms.InputTag( 'hltGctDigis','tauJets' ), - etHadSource = cms.InputTag( "hltGctDigis" ), - isoTauJetSource = cms.InputTag( 'hltGctDigis','isoTauJets' ), - etTotalSource = cms.InputTag( "hltGctDigis" ), + tauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','tauJets' ), + etHadSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + isoTauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoTauJets' ), + etTotalSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), centralBxOnly = cms.bool( True ), - centralJetSource = cms.InputTag( 'hltGctDigis','cenJets' ), - etMissSource = cms.InputTag( "hltGctDigis" ), - hfRingEtSumsSource = cms.InputTag( "hltGctDigis" ), + centralJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','cenJets' ), + etMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + hfRingEtSumsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceMuonParticles = cms.bool( True ), - forwardJetSource = cms.InputTag( 'hltGctDigis','forJets' ), + forwardJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','forJets' ), ignoreHtMiss = cms.bool( False ), - htMissSource = cms.InputTag( "hltGctDigis" ), + htMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceCaloParticles = cms.bool( True ), muonSource = cms.InputTag( "hltGtDigis" ), - isolatedEmSource = cms.InputTag( 'hltGctDigis','isoEm' ), - nonIsolatedEmSource = cms.InputTag( 'hltGctDigis','nonIsoEm' ), - hfRingBitCountsSource = cms.InputTag( "hltGctDigis" ) + isolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoEm' ), + nonIsolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','nonIsoEm' ), + hfRingBitCountsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ) ) process.hltScalersRawToDigi = cms.EDProducer( "ScalersRawToDigi", scalersInputTag = cms.InputTag( "rawDataCollector" ) @@ -3895,7 +3903,7 @@ 'keep triggerTriggerEvent_*_*_*' ) ) -process.HLTL1UnpackerSequence = cms.Sequence( process.hltGtDigis + process.hltGctDigis + process.hltL1GtObjectMap + process.hltL1extraParticles ) +process.HLTL1UnpackerSequence = cms.Sequence( process.hltGtDigis + process.hltCaloStage1Digis + process.hltCaloStage1LegacyFormatDigis + process.hltL1GtObjectMap + process.hltL1extraParticles ) process.HLTBeamSpot = cms.Sequence( process.hltScalersRawToDigi + process.hltOnlineBeamSpot ) process.HLTBeginSequence = cms.Sequence( process.hltTriggerType + process.HLTL1UnpackerSequence + process.HLTBeamSpot ) process.HLTEndSequence = cms.Sequence( process.hltBoolEnd ) @@ -3969,9 +3977,9 @@ del process.TrackerDigiGeometryESModule.trackerGeometryConstants.upgradeGeometry -# load PostLS1 customisation for HIon -from SLHCUpgradeSimulations.Configuration.postLS1Customs import customisePostLS1_HI -process = customisePostLS1_HI(process) +# load 2015 Run-2 L1 Menu for HIon +from L1Trigger.Configuration.customise_overwriteL1Menu import L1Menu_CollisionsHeavyIons2015_v0 as loadL1Menu +process = loadL1Menu(process) # adapt HLT modules to the correct process name if 'hltTrigReport' in process.__dict__: diff --git a/HLTrigger/Configuration/test/OnMc_HLT_PIon.py b/HLTrigger/Configuration/test/OnMc_HLT_PIon.py index b5473387395ba..47e6d78b685d9 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_PIon.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_PIon.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_4_0/PIon/V5 (CMSSW_7_4_0_pre7_HLT1) +# /dev/CMSSW_7_4_0/PIon/V6 (CMSSW_7_4_0_pre7_HLT1) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTPIon" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_4_0/PIon/V5') + tableName = cms.string('/dev/CMSSW_7_4_0/PIon/V6') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2025,16 +2025,24 @@ ActiveBoardsMask = cms.uint32( 0xffff ), DaqGtInputTag = cms.InputTag( "rawDataCollector" ) ) -process.hltGctDigis = cms.EDProducer( "GctRawToDigi", - checkHeaders = cms.untracked.bool( False ), - unpackSharedRegions = cms.bool( False ), - numberOfGctSamplesToUnpack = cms.uint32( 1 ), - verbose = cms.untracked.bool( False ), - numberOfRctSamplesToUnpack = cms.uint32( 1 ), - inputLabel = cms.InputTag( "rawDataCollector" ), - unpackerVersion = cms.uint32( 0 ), - gctFedId = cms.untracked.int32( 745 ), - hltMode = cms.bool( True ) +process.hltCaloStage1Digis = cms.EDProducer( "L1TRawToDigi", + lenSlinkTrailer = cms.untracked.int32( 8 ), + lenAMC13Header = cms.untracked.int32( 8 ), + lenAMC13Trailer = cms.untracked.int32( 8 ), + Setup = cms.string( "stage1::CaloSetup" ), + InputLabel = cms.InputTag( "rawDataCollector" ), + lenSlinkHeader = cms.untracked.int32( 8 ), + FWId = cms.untracked.int32( 2 ), + lenAMCHeader = cms.untracked.int32( 8 ), + lenAMCTrailer = cms.untracked.int32( 0 ), + FedId = cms.int32( 1352 ) +) +process.hltCaloStage1LegacyFormatDigis = cms.EDProducer( "L1TCaloUpgradeToGCTConverter", + InputHFCountsCollection = cms.InputTag( 'hltCaloStage1Digis','HFBitCounts' ), + InputHFSumsCollection = cms.InputTag( 'hltCaloStage1Digis','HFRingSums' ), + InputRlxTauCollection = cms.InputTag( 'hltCaloStage1Digis','rlxTaus' ), + InputIsoTauCollection = cms.InputTag( 'hltCaloStage1Digis','isoTaus' ), + InputCollection = cms.InputTag( "hltCaloStage1Digis" ) ) process.hltL1GtObjectMap = cms.EDProducer( "L1GlobalTrigger", TechnicalTriggersUnprescaled = cms.bool( True ), @@ -2052,29 +2060,29 @@ AlternativeNrBxBoardEvm = cms.uint32( 0 ), TechnicalTriggersInputTags = cms.VInputTag( 'simBscDigis' ), CastorInputTag = cms.InputTag( "castorL1Digis" ), - GctInputTag = cms.InputTag( "hltGctDigis" ), + GctInputTag = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), AlternativeNrBxBoardDaq = cms.uint32( 0 ), WritePsbL1GtDaqRecord = cms.bool( False ), BstLengthBytes = cms.int32( -1 ) ) process.hltL1extraParticles = cms.EDProducer( "L1ExtraParticlesProd", - tauJetSource = cms.InputTag( 'hltGctDigis','tauJets' ), - etHadSource = cms.InputTag( "hltGctDigis" ), - isoTauJetSource = cms.InputTag( 'hltGctDigis','isoTauJets' ), - etTotalSource = cms.InputTag( "hltGctDigis" ), + tauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','tauJets' ), + etHadSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + isoTauJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoTauJets' ), + etTotalSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), centralBxOnly = cms.bool( True ), - centralJetSource = cms.InputTag( 'hltGctDigis','cenJets' ), - etMissSource = cms.InputTag( "hltGctDigis" ), - hfRingEtSumsSource = cms.InputTag( "hltGctDigis" ), + centralJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','cenJets' ), + etMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), + hfRingEtSumsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceMuonParticles = cms.bool( True ), - forwardJetSource = cms.InputTag( 'hltGctDigis','forJets' ), + forwardJetSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','forJets' ), ignoreHtMiss = cms.bool( False ), - htMissSource = cms.InputTag( "hltGctDigis" ), + htMissSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ), produceCaloParticles = cms.bool( True ), muonSource = cms.InputTag( "hltGtDigis" ), - isolatedEmSource = cms.InputTag( 'hltGctDigis','isoEm' ), - nonIsolatedEmSource = cms.InputTag( 'hltGctDigis','nonIsoEm' ), - hfRingBitCountsSource = cms.InputTag( "hltGctDigis" ) + isolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','isoEm' ), + nonIsolatedEmSource = cms.InputTag( 'hltCaloStage1LegacyFormatDigis','nonIsoEm' ), + hfRingBitCountsSource = cms.InputTag( "hltCaloStage1LegacyFormatDigis" ) ) process.hltScalersRawToDigi = cms.EDProducer( "ScalersRawToDigi", scalersInputTag = cms.InputTag( "rawDataCollector" ) @@ -8451,7 +8459,7 @@ 'keep triggerTriggerEvent_*_*_*' ) ) -process.HLTL1UnpackerSequence = cms.Sequence( process.hltGtDigis + process.hltGctDigis + process.hltL1GtObjectMap + process.hltL1extraParticles ) +process.HLTL1UnpackerSequence = cms.Sequence( process.hltGtDigis + process.hltCaloStage1Digis + process.hltCaloStage1LegacyFormatDigis + process.hltL1GtObjectMap + process.hltL1extraParticles ) process.HLTBeamSpot = cms.Sequence( process.hltScalersRawToDigi + process.hltOnlineBeamSpot ) process.HLTBeginSequence = cms.Sequence( process.hltTriggerType + process.HLTL1UnpackerSequence + process.HLTBeamSpot ) process.HLTDoFullUnpackingEgammaEcalWithoutPreshowerSequence = cms.Sequence( process.hltEcalDigis + process.hltEcalUncalibRecHit + process.hltEcalDetIdToBeRecovered + process.hltEcalRecHit ) @@ -8560,9 +8568,9 @@ del process.TrackerDigiGeometryESModule.trackerGeometryConstants.upgradeGeometry -# load PostLS1 customisation for 25ns -from SLHCUpgradeSimulations.Configuration.postLS1Customs import customisePostLS1 -process = customisePostLS1(process) +# load 2015 Run-2 L1 Menu for 25ns (default for GRun, PIon) +from L1Trigger.Configuration.customise_overwriteL1Menu import L1Menu_Collisions2015_25ns_v2 as loadL1menu +process = loadL1menu(process) # adapt HLT modules to the correct process name if 'hltTrigReport' in process.__dict__: diff --git a/HLTrigger/Configuration/test/cmsDriver.csh b/HLTrigger/Configuration/test/cmsDriver.csh index b0d6e9ccd0877..9c15b489267e1 100755 --- a/HLTrigger/Configuration/test/cmsDriver.csh +++ b/HLTrigger/Configuration/test/cmsDriver.csh @@ -84,7 +84,7 @@ foreach gtag ( MC DATA ) continue endif - foreach table ( FULL Fake GRun HIon PIon 50nsGRun ) + foreach table ( Fake GRun HIon PIon 50nsGRun ) set name = ${table}_${gtag} diff --git a/L1Trigger/L1TCommon/python/customsPostLS1.py b/L1Trigger/L1TCommon/python/customsPostLS1.py index be92cd41da64d..1e7b2a7045097 100644 --- a/L1Trigger/L1TCommon/python/customsPostLS1.py +++ b/L1Trigger/L1TCommon/python/customsPostLS1.py @@ -43,41 +43,6 @@ def customiseSimL1EmulatorForStage1(process): process.L1RawToDigiSeq = cms.Sequence(process.gctDigis+process.caloStage1Digis+process.caloStage1LegacyFormatDigis) process.RawToDigi.replace(process.gctDigis, process.L1RawToDigiSeq) - if hasattr(process, 'HLTL1UnpackerSequence'): - - # extend sequence to add Layer 1 unpacking and conversion back to legacy format - process.hltCaloStage1Digis = process.caloStage1Digis.clone() - process.hltCaloStage1LegacyFormatDigis = process.caloStage1LegacyFormatDigis.clone() - process.hltCaloStage1LegacyFormatDigis.InputCollection = cms.InputTag("hltCaloStage1Digis") - process.hltCaloStage1LegacyFormatDigis.InputRlxTauCollection = cms.InputTag("hltCaloStage1Digis:rlxTaus") - process.hltCaloStage1LegacyFormatDigis.InputIsoTauCollection = cms.InputTag("hltCaloStage1Digis:isoTaus") - process.hltCaloStage1LegacyFormatDigis.InputHFSumsCollection = cms.InputTag("hltCaloStage1Digis:HFRingSums") - process.hltCaloStage1LegacyFormatDigis.InputHFCountsCollection = cms.InputTag("hltCaloStage1Digis:HFBitCounts") - #process.hltL1RawToDigiSeq = cms.Sequence(process.hltGctDigis+process.hltCaloStage1 + process.hltCaloStage1LegacyFormatDigis) - process.hltL1RawToDigiSeq = cms.Sequence(process.hltCaloStage1Digis + process.hltCaloStage1LegacyFormatDigis) - process.HLTL1UnpackerSequence.replace(process.hltGctDigis, process.hltL1RawToDigiSeq) - - alist=['hltL1GtObjectMap'] - for a in alist: - if hasattr(process,a): - getattr(process, a).GctInputTag = cms.InputTag("hltCaloStage1LegacyFormatDigis") - - alist=['hltL1extraParticles'] - for a in alist: - if hasattr(process,a): - getattr(process, a).etTotalSource = cms.InputTag("hltCaloStage1LegacyFormatDigis") - getattr(process, a).nonIsolatedEmSource = cms.InputTag("hltCaloStage1LegacyFormatDigis","nonIsoEm") - getattr(process, a).etMissSource = cms.InputTag("hltCaloStage1LegacyFormatDigis") - getattr(process, a).htMissSource = cms.InputTag("hltCaloStage1LegacyFormatDigis") - getattr(process, a).forwardJetSource = cms.InputTag("hltCaloStage1LegacyFormatDigis","forJets") - getattr(process, a).centralJetSource = cms.InputTag("hltCaloStage1LegacyFormatDigis","cenJets") - getattr(process, a).tauJetSource = cms.InputTag("hltCaloStage1LegacyFormatDigis","tauJets") - getattr(process, a).isoTauJetSource = cms.InputTag("hltCaloStage1LegacyFormatDigis","isoTauJets") - getattr(process, a).isolatedEmSource = cms.InputTag("hltCaloStage1LegacyFormatDigis","isoEm") - getattr(process, a).etHadSource = cms.InputTag("hltCaloStage1LegacyFormatDigis") - getattr(process, a).hfRingEtSumsSource = cms.InputTag("hltCaloStage1LegacyFormatDigis") - getattr(process, a).hfRingBitCountsSource = cms.InputTag("hltCaloStage1LegacyFormatDigis") - blist=['l1extraParticles','recoL1extraParticles','dqmL1ExtraParticles'] for b in blist: if hasattr(process,b): From 9eb7a5c6486a51953ea64aa3f72773bf74923dc5 Mon Sep 17 00:00:00 2001 From: AJ Johnson Date: Tue, 3 Mar 2015 19:10:48 +0100 Subject: [PATCH 15/22] Bugfix in TauReco/src/classes_def_2.xml adding ioread rules to clear transient vectors https://hypernews.cern.ch/HyperNews/CMS/get/physTools/3315/1/1.html --- DataFormats/TauReco/src/classes_def_2.xml | 38 +++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/DataFormats/TauReco/src/classes_def_2.xml b/DataFormats/TauReco/src/classes_def_2.xml index ecf4be9ce82e2..434aca8bf9fdc 100644 --- a/DataFormats/TauReco/src/classes_def_2.xml +++ b/DataFormats/TauReco/src/classes_def_2.xml @@ -155,6 +155,44 @@ for(auto const& ref : onfile.selectedIsolationPFGammaCands_) { + + + + + + + + + + + + + + + + + + + From d27d55a0a338ee76228d51ddd948ec09ec29c4ea Mon Sep 17 00:00:00 2001 From: AJ Johnson Date: Tue, 3 Mar 2015 19:29:15 +0100 Subject: [PATCH 16/22] Transient Vector Bugfix --- DataFormats/TauReco/src/classes_def_2.xml | 1 + 1 file changed, 1 insertion(+) diff --git a/DataFormats/TauReco/src/classes_def_2.xml b/DataFormats/TauReco/src/classes_def_2.xml index 434aca8bf9fdc..ef1524b548b2e 100644 --- a/DataFormats/TauReco/src/classes_def_2.xml +++ b/DataFormats/TauReco/src/classes_def_2.xml @@ -174,6 +174,7 @@ isolationPiZeroCandidates_.clear(); ]]> + Date: Wed, 4 Mar 2015 11:42:41 +0100 Subject: [PATCH 17/22] bugfix fourth attempt --- DataFormats/TauReco/src/classes_def_2.xml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/DataFormats/TauReco/src/classes_def_2.xml b/DataFormats/TauReco/src/classes_def_2.xml index ef1524b548b2e..6095650394341 100644 --- a/DataFormats/TauReco/src/classes_def_2.xml +++ b/DataFormats/TauReco/src/classes_def_2.xml @@ -156,6 +156,8 @@ for(auto const& ref : onfile.selectedIsolationPFGammaCands_) { + + Date: Wed, 4 Mar 2015 11:17:52 +0100 Subject: [PATCH 18/22] working in production by default patch to be applied in case of playback deployement patch to be applied in case of user area deployement changing the default to users gui adding patch for prod installation --- .../python/test/PlaybackInstall.patch | 55 +++-------- .../python/test/ProductionInstall.patch | 24 +++++ .../python/test/UserAreaInstall.patch | 99 +++++++++++++++++++ .../python/test/environment_cfi.py | 6 +- 4 files changed, 139 insertions(+), 45 deletions(-) create mode 100644 DQM/Integration/python/test/ProductionInstall.patch create mode 100644 DQM/Integration/python/test/UserAreaInstall.patch diff --git a/DQM/Integration/python/test/PlaybackInstall.patch b/DQM/Integration/python/test/PlaybackInstall.patch index e91205140e2dd..d83e8629efb5c 100644 --- a/DQM/Integration/python/test/PlaybackInstall.patch +++ b/DQM/Integration/python/test/PlaybackInstall.patch @@ -1,42 +1,15 @@ -Index: environment_cfi.py -=================================================================== -RCS file: /cvs_server/repositories/CMSSW/CMSSW/DQM/Integration/python/test/environment_cfi.py,v -retrieving revision 1.23 -diff -u -p -r1.23 environment_cfi.py ---- environment_cfi.py 26 Mar 2012 16:44:05 -0000 1.23 -+++ environment_cfi.py 16 Apr 2012 08:57:22 -0000 -@@ -2,15 +2,15 @@ import FWCore.ParameterSet.Config as cms +diff --git a/DQM/Integration/python/test/environment_cfi.py b/DQM/Integration/python/test/environment_cfi.py +index 86d7bda..f2e3ab2 100644 +--- a/DQM/Integration/python/test/environment_cfi.py ++++ b/DQM/Integration/python/test/environment_cfi.py +@@ -6,8 +6,8 @@ from DQMServices.Core.DQMStore_cfi import * + DQM = cms.Service("DQM", + debug = cms.untracked.bool(False), + publishFrequency = cms.untracked.double(5.0), +- collectorPort = cms.untracked.int32(9190), +- collectorHost = cms.untracked.string('dqm-c2d07-29.cms'), ++ collectorPort = cms.untracked.int32(9090), ++ collectorHost = cms.untracked.string('dqm-c2d07-11.cms'), + filter = cms.untracked.string('') + ) - from DQMServices.Core.DQM_cfg import * - --DQM.collectorHost = 'dqm-prod-local.cms' -+DQM.collectorHost = 'dqm-integration.cms' - DQM.collectorPort = 9090 - - from DQMServices.Components.DQMEnvironment_cfi import * - - dqmSaver.convention = 'Online' - dqmSaver.referenceHandling = 'all' --dqmSaver.dirName = '/home/dqmprolocal/output' --dqmSaver.producer = 'DQM' -+dqmSaver.dirName = '/home/dqmdevlocal/output' -+dqmSaver.producer = 'Playback' - dqmSaver.saveByTime = 1 - dqmSaver.saveByLumiSection = -1 - dqmSaver.saveByMinute = 8 -Index: inputsource_cfi.py -=================================================================== -RCS file: /cvs_server/repositories/CMSSW/CMSSW/DQM/Integration/python/test/inputsource_cfi.py,v -retrieving revision 1.33 -diff -u -p -r1.33 inputsource_cfi.py ---- inputsource_cfi.py 26 Mar 2012 16:44:05 -0000 1.33 -+++ inputsource_cfi.py 16 Apr 2012 08:57:22 -0000 -@@ -20,7 +20,7 @@ source = cms.Source("EventStreamHttpRead - consumerName = cms.untracked.string('DQM Source'), - SelectHLTOutput = cms.untracked.string('hltOutputA'), - max_queue_depth = cms.int32(5), -- maxEventRequestRate = cms.untracked.double(100.0), -+ maxEventRequestRate = cms.untracked.double(10.0), - SelectEvents = cms.untracked.PSet( - SelectEvents = cms.vstring('*') - ), diff --git a/DQM/Integration/python/test/ProductionInstall.patch b/DQM/Integration/python/test/ProductionInstall.patch new file mode 100644 index 0000000000000..9273700259edc --- /dev/null +++ b/DQM/Integration/python/test/ProductionInstall.patch @@ -0,0 +1,24 @@ +diff --git a/DQM/Integration/python/test/environment_cfi.py b/DQM/Integration/python/test/environment_cfi.py +index 86d7bda..1de213d 100644 +--- a/DQM/Integration/python/test/environment_cfi.py ++++ b/DQM/Integration/python/test/environment_cfi.py +@@ -6,8 +6,8 @@ from DQMServices.Core.DQMStore_cfi import * + DQM = cms.Service("DQM", + debug = cms.untracked.bool(False), + publishFrequency = cms.untracked.double(5.0), +- collectorPort = cms.untracked.int32(9190), +- collectorHost = cms.untracked.string('dqm-c2d07-29.cms'), ++ collectorPort = cms.untracked.int32(9090), ++ collectorHost = cms.untracked.string('dqm-prod-local.cms'), + filter = cms.untracked.string('') + ) + +@@ -18,7 +18,7 @@ from DQMServices.Components.DQMEnvironment_cfi import * + dqmSaver.convention = 'Online' + dqmSaver.referenceHandling = 'all' + dqmSaver.dirName = '.' +-dqmSaver.producer = 'Playback' ++dqmSaver.producer = 'DQM' + dqmSaver.saveByLumiSection = 10 + dqmSaver.saveByRun = 1 + dqmSaver.saveAtJobEnd = False diff --git a/DQM/Integration/python/test/UserAreaInstall.patch b/DQM/Integration/python/test/UserAreaInstall.patch new file mode 100644 index 0000000000000..4bdf49e1a70f5 --- /dev/null +++ b/DQM/Integration/python/test/UserAreaInstall.patch @@ -0,0 +1,99 @@ +diff --git a/DQM/Integration/python/test/UserAreaInstall.patch b/DQM/Integration/python/test/UserAreaInstall.patch +index fda3b82..e69de29 100644 +--- a/DQM/Integration/python/test/UserAreaInstall.patch ++++ b/DQM/Integration/python/test/UserAreaInstall.patch +@@ -1,59 +0,0 @@ +-diff --git a/DQM/Integration/python/test/environment_cfi.py b/DQM/Integration/python/test/environment_cfi.py +-index 1de213d..86d7bda 100644 +---- a/DQM/Integration/python/test/environment_cfi.py +-+++ b/DQM/Integration/python/test/environment_cfi.py +-@@ -6,8 +6,8 @@ from DQMServices.Core.DQMStore_cfi import * +- DQM = cms.Service("DQM", +- debug = cms.untracked.bool(False), +- publishFrequency = cms.untracked.double(5.0), +-- collectorPort = cms.untracked.int32(9090), +-- collectorHost = cms.untracked.string('dqm-prod-local.cms'), +-+ collectorPort = cms.untracked.int32(9190), +-+ collectorHost = cms.untracked.string('dqm-c2d07-29.cms'), +- filter = cms.untracked.string('') +- ) +- +-@@ -18,7 +18,7 @@ from DQMServices.Components.DQMEnvironment_cfi import * +- dqmSaver.convention = 'Online' +- dqmSaver.referenceHandling = 'all' +- dqmSaver.dirName = '.' +--dqmSaver.producer = 'DQM' +-+dqmSaver.producer = 'Playback' +- dqmSaver.saveByLumiSection = 10 +- dqmSaver.saveByRun = 1 +- dqmSaver.saveAtJobEnd = False +-diff --git a/DQM/Integration/python/test/inputsource_cfi.py b/DQM/Integration/python/test/inputsource_cfi.py +-index 1ece7b3..32d1fe2 100644 +---- a/DQM/Integration/python/test/inputsource_cfi.py +-+++ b/DQM/Integration/python/test/inputsource_cfi.py +-@@ -7,13 +7,13 @@ from dqmPythonTypes import * +- options = VarParsing.VarParsing('analysis') +- +- options.register('runNumber', +-- 111, +-+ SetRunNumByHand, +- VarParsing.VarParsing.multiplicity.singleton, +- VarParsing.VarParsing.varType.int, +- "Run number.") +- +- options.register('runInputDir', +-- '/tmp', +-+ '/fff/BU0/output', +- VarParsing.VarParsing.multiplicity.singleton, +- VarParsing.VarParsing.varType.string, +- "Directory where the DQM files will appear.") +-@@ -56,11 +56,11 @@ source = cms.Source("DQMStreamerReader", +- runInputDir = cms.untracked.string(options.runInputDir), +- SelectEvents = cms.untracked.vstring('*'), +- streamLabel = cms.untracked.string('streamDQM'), +-- minEventsPerLumi = cms.untracked.int32(1), +-+ minEventsPerLumi = cms.untracked.int32(-1), +- delayMillis = cms.untracked.uint32(500), +-- nextLumiTimeoutMillis = cms.untracked.int32(30000), +-+ nextLumiTimeoutMillis = cms.untracked.int32(3000), +- skipFirstLumis = cms.untracked.bool(options.skipFirstLumis), +- deleteDatFiles = cms.untracked.bool(False), +-- endOfRunKills = cms.untracked.bool(True), +-+ endOfRunKills = cms.untracked.bool(False), +- ) +- +diff --git a/DQM/Integration/python/test/inputsource_cfi.py b/DQM/Integration/python/test/inputsource_cfi.py +index 1ece7b3..32d1fe2 100644 +--- a/DQM/Integration/python/test/inputsource_cfi.py ++++ b/DQM/Integration/python/test/inputsource_cfi.py +@@ -7,13 +7,13 @@ from dqmPythonTypes import * + options = VarParsing.VarParsing('analysis') + + options.register('runNumber', +- 111, ++ SetRunNumByHand, + VarParsing.VarParsing.multiplicity.singleton, + VarParsing.VarParsing.varType.int, + "Run number.") + + options.register('runInputDir', +- '/tmp', ++ '/fff/BU0/output', + VarParsing.VarParsing.multiplicity.singleton, + VarParsing.VarParsing.varType.string, + "Directory where the DQM files will appear.") +@@ -56,11 +56,11 @@ source = cms.Source("DQMStreamerReader", + runInputDir = cms.untracked.string(options.runInputDir), + SelectEvents = cms.untracked.vstring('*'), + streamLabel = cms.untracked.string('streamDQM'), +- minEventsPerLumi = cms.untracked.int32(1), ++ minEventsPerLumi = cms.untracked.int32(-1), + delayMillis = cms.untracked.uint32(500), +- nextLumiTimeoutMillis = cms.untracked.int32(30000), ++ nextLumiTimeoutMillis = cms.untracked.int32(3000), + skipFirstLumis = cms.untracked.bool(options.skipFirstLumis), + deleteDatFiles = cms.untracked.bool(False), +- endOfRunKills = cms.untracked.bool(True), ++ endOfRunKills = cms.untracked.bool(False), + ) + diff --git a/DQM/Integration/python/test/environment_cfi.py b/DQM/Integration/python/test/environment_cfi.py index 0d7b4a61e79ef..86d7bda673778 100644 --- a/DQM/Integration/python/test/environment_cfi.py +++ b/DQM/Integration/python/test/environment_cfi.py @@ -6,8 +6,7 @@ DQM = cms.Service("DQM", debug = cms.untracked.bool(False), publishFrequency = cms.untracked.double(5.0), - collectorPort = cms.untracked.int32(9090), -# collectorHost = cms.untracked.string('dqm-prod-local.cms'), + collectorPort = cms.untracked.int32(9190), collectorHost = cms.untracked.string('dqm-c2d07-29.cms'), filter = cms.untracked.string('') ) @@ -18,9 +17,8 @@ dqmSaver.convention = 'Online' dqmSaver.referenceHandling = 'all' -#dqmSaver.dirName = '/home/dqmprolocal/output' dqmSaver.dirName = '.' -dqmSaver.producer = 'DQM' +dqmSaver.producer = 'Playback' dqmSaver.saveByLumiSection = 10 dqmSaver.saveByRun = 1 dqmSaver.saveAtJobEnd = False From cf0c454e560524e13d679f72d342554f16cb01f0 Mon Sep 17 00:00:00 2001 From: federico de guio Date: Wed, 4 Mar 2015 17:35:38 +0100 Subject: [PATCH 19/22] fix --- .../python/test/UserAreaInstall.patch | 64 ------------------- 1 file changed, 64 deletions(-) diff --git a/DQM/Integration/python/test/UserAreaInstall.patch b/DQM/Integration/python/test/UserAreaInstall.patch index 4bdf49e1a70f5..ae4c703b692b3 100644 --- a/DQM/Integration/python/test/UserAreaInstall.patch +++ b/DQM/Integration/python/test/UserAreaInstall.patch @@ -1,67 +1,3 @@ -diff --git a/DQM/Integration/python/test/UserAreaInstall.patch b/DQM/Integration/python/test/UserAreaInstall.patch -index fda3b82..e69de29 100644 ---- a/DQM/Integration/python/test/UserAreaInstall.patch -+++ b/DQM/Integration/python/test/UserAreaInstall.patch -@@ -1,59 +0,0 @@ --diff --git a/DQM/Integration/python/test/environment_cfi.py b/DQM/Integration/python/test/environment_cfi.py --index 1de213d..86d7bda 100644 ----- a/DQM/Integration/python/test/environment_cfi.py --+++ b/DQM/Integration/python/test/environment_cfi.py --@@ -6,8 +6,8 @@ from DQMServices.Core.DQMStore_cfi import * -- DQM = cms.Service("DQM", -- debug = cms.untracked.bool(False), -- publishFrequency = cms.untracked.double(5.0), --- collectorPort = cms.untracked.int32(9090), --- collectorHost = cms.untracked.string('dqm-prod-local.cms'), --+ collectorPort = cms.untracked.int32(9190), --+ collectorHost = cms.untracked.string('dqm-c2d07-29.cms'), -- filter = cms.untracked.string('') -- ) -- --@@ -18,7 +18,7 @@ from DQMServices.Components.DQMEnvironment_cfi import * -- dqmSaver.convention = 'Online' -- dqmSaver.referenceHandling = 'all' -- dqmSaver.dirName = '.' ---dqmSaver.producer = 'DQM' --+dqmSaver.producer = 'Playback' -- dqmSaver.saveByLumiSection = 10 -- dqmSaver.saveByRun = 1 -- dqmSaver.saveAtJobEnd = False --diff --git a/DQM/Integration/python/test/inputsource_cfi.py b/DQM/Integration/python/test/inputsource_cfi.py --index 1ece7b3..32d1fe2 100644 ----- a/DQM/Integration/python/test/inputsource_cfi.py --+++ b/DQM/Integration/python/test/inputsource_cfi.py --@@ -7,13 +7,13 @@ from dqmPythonTypes import * -- options = VarParsing.VarParsing('analysis') -- -- options.register('runNumber', --- 111, --+ SetRunNumByHand, -- VarParsing.VarParsing.multiplicity.singleton, -- VarParsing.VarParsing.varType.int, -- "Run number.") -- -- options.register('runInputDir', --- '/tmp', --+ '/fff/BU0/output', -- VarParsing.VarParsing.multiplicity.singleton, -- VarParsing.VarParsing.varType.string, -- "Directory where the DQM files will appear.") --@@ -56,11 +56,11 @@ source = cms.Source("DQMStreamerReader", -- runInputDir = cms.untracked.string(options.runInputDir), -- SelectEvents = cms.untracked.vstring('*'), -- streamLabel = cms.untracked.string('streamDQM'), --- minEventsPerLumi = cms.untracked.int32(1), --+ minEventsPerLumi = cms.untracked.int32(-1), -- delayMillis = cms.untracked.uint32(500), --- nextLumiTimeoutMillis = cms.untracked.int32(30000), --+ nextLumiTimeoutMillis = cms.untracked.int32(3000), -- skipFirstLumis = cms.untracked.bool(options.skipFirstLumis), -- deleteDatFiles = cms.untracked.bool(False), --- endOfRunKills = cms.untracked.bool(True), --+ endOfRunKills = cms.untracked.bool(False), -- ) -- diff --git a/DQM/Integration/python/test/inputsource_cfi.py b/DQM/Integration/python/test/inputsource_cfi.py index 1ece7b3..32d1fe2 100644 --- a/DQM/Integration/python/test/inputsource_cfi.py From 154fa1322f4a856f8526c81d41a06e90d4415ec0 Mon Sep 17 00:00:00 2001 From: Christopher Jones Date: Wed, 4 Mar 2015 17:48:37 +0100 Subject: [PATCH 20/22] Make char arrays fully const in TaggingVariable The globally available arrays of names are now fully const. This was spotted by the static analyzer. --- DataFormats/BTauReco/interface/TaggingVariable.h | 4 ++-- DataFormats/BTauReco/src/TaggingVariable.cc | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/DataFormats/BTauReco/interface/TaggingVariable.h b/DataFormats/BTauReco/interface/TaggingVariable.h index 9adff22628f94..b531f6e57cf6b 100644 --- a/DataFormats/BTauReco/interface/TaggingVariable.h +++ b/DataFormats/BTauReco/interface/TaggingVariable.h @@ -133,8 +133,8 @@ namespace reco { // import only TaggingVariableName type into reco namespace using btau::TaggingVariableName; - extern const char* TaggingVariableDescription[]; - extern const char* TaggingVariableTokens[]; + extern const char* const TaggingVariableDescription[]; + extern const char* const TaggingVariableTokens[]; TaggingVariableName getTaggingVariableName ( const std::string & name ); diff --git a/DataFormats/BTauReco/src/TaggingVariable.cc b/DataFormats/BTauReco/src/TaggingVariable.cc index ad1ff3fc4a746..d68aaa4bd0767 100644 --- a/DataFormats/BTauReco/src/TaggingVariable.cc +++ b/DataFormats/BTauReco/src/TaggingVariable.cc @@ -8,7 +8,7 @@ using namespace std; namespace reco { -const char* TaggingVariableDescription[] = { +const char* const TaggingVariableDescription[] = { /* [jetEnergy] = */ "jet energy", /* [jetPt] = */ "jet transverse momentum", /* [trackJetPt] = */ "track-based jet transverse momentum", @@ -108,7 +108,7 @@ const char* TaggingVariableDescription[] = { /* [lastTaggingVariable] = */ "" }; -const char* TaggingVariableTokens[] = { +const char* const TaggingVariableTokens[] = { /* [jetEnergy] = */ "jetEnergy", /* [jetPt] = */ "jetPt", /* [trackJetPt] = */ "trackJetPt", From 8c898923aa287a8db70f4e8370ac62ea6a0c0c21 Mon Sep 17 00:00:00 2001 From: Giulio Eulisse Date: Mon, 2 Mar 2015 15:24:29 +0100 Subject: [PATCH 21/22] Drop a bunch of unneeded dependencies on rootrflx Since DataFormats/DetId depends on it, basically everything else does. --- Alignment/OfflineValidation/BuildFile.xml | 2 +- AnalysisDataFormats/EWK/BuildFile.xml | 2 +- AnalysisDataFormats/Egamma/BuildFile.xml | 2 +- AnalysisDataFormats/SUSYBSMObjects/BuildFile.xml | 2 +- AnalysisDataFormats/TrackInfo/BuildFile.xml | 2 +- CalibTracker/SiStripCommon/BuildFile.xml | 2 +- Calibration/HcalCalibAlgos/BuildFile.xml | 2 +- CaloOnlineTools/HcalOnlineDb/BuildFile.xml | 2 +- CaloOnlineTools/HcalOnlineDb/plugins/BuildFile.xml | 2 +- CaloOnlineTools/HcalOnlineDb/test/BuildFile.xml | 4 ++-- CommonTools/PileupAlgos/BuildFile.xml | 2 +- CommonTools/RecoUtils/BuildFile.xml | 2 +- CondCore/CondDB/test/BuildFile.xml | 2 +- CondCore/DBCommon/plugins/BuildFile.xml | 2 +- CondCore/DBCommon/test/BuildFile.xml | 2 +- CondCore/IOVService/test/BuildFile.xml | 2 +- CondCore/ORA/test/BuildFile.xml | 2 +- CondFormats/Alignment/BuildFile.xml | 2 +- CondFormats/BTauObjects/BuildFile.xml | 2 +- CondFormats/BeamSpotObjects/BuildFile.xml | 2 +- CondFormats/CSCObjects/BuildFile.xml | 2 +- CondFormats/Calibration/BuildFile.xml | 2 +- CondFormats/CastorObjects/BuildFile.xml | 2 +- CondFormats/Common/BuildFile.xml | 2 +- CondFormats/DQMObjects/BuildFile.xml | 2 +- CondFormats/DTObjects/BuildFile.xml | 2 +- CondFormats/ESObjects/BuildFile.xml | 2 +- CondFormats/EcalCorrections/BuildFile.xml | 2 +- CondFormats/EcalObjects/BuildFile.xml | 2 +- CondFormats/EgammaObjects/BuildFile.xml | 2 +- CondFormats/GeometryObjects/BuildFile.xml | 2 +- CondFormats/HIObjects/BuildFile.xml | 2 +- CondFormats/HLTObjects/BuildFile.xml | 2 +- CondFormats/HcalObjects/BuildFile.xml | 2 +- CondFormats/JetMETObjects/BuildFile.xml | 2 +- CondFormats/L1TObjects/BuildFile.xml | 2 +- CondFormats/Luminosity/BuildFile.xml | 2 +- CondFormats/MFObjects/BuildFile.xml | 2 +- CondFormats/OptAlignObjects/BuildFile.xml | 2 +- CondFormats/RPCObjects/BuildFile.xml | 2 +- CondFormats/RecoMuonObjects/BuildFile.xml | 2 +- CondFormats/RunInfo/BuildFile.xml | 2 +- CondFormats/SiPixelObjects/BuildFile.xml | 2 +- CondFormats/SiStripObjects/BuildFile.xml | 2 +- CondTools/DQM/BuildFile.xml | 2 +- CondTools/DT/BuildFile.xml | 2 +- CondTools/RunInfo/BuildFile.xml | 2 +- CondTools/Utilities/test/BuildFile.xml | 2 +- DPGAnalysis/SiStripTools/BuildFile.xml | 2 +- DQM/Integration/BuildFile.xml | 2 +- DQM/SiPixelCommon/BuildFile.xml | 2 +- DataFormats/Alignment/BuildFile.xml | 2 +- DataFormats/BTauReco/BuildFile.xml | 2 +- DataFormats/BeamSpot/BuildFile.xml | 2 +- DataFormats/CLHEP/BuildFile.xml | 2 +- DataFormats/CSCDigi/BuildFile.xml | 2 +- DataFormats/CSCRecHit/BuildFile.xml | 2 +- DataFormats/CaloRecHit/BuildFile.xml | 2 +- DataFormats/CaloTowers/BuildFile.xml | 2 +- DataFormats/CastorReco/BuildFile.xml | 2 +- DataFormats/DTDigi/BuildFile.xml | 2 +- DataFormats/DTRecHit/BuildFile.xml | 2 +- DataFormats/EcalDetId/BuildFile.xml | 2 +- DataFormats/EcalDigi/BuildFile.xml | 2 +- DataFormats/EcalRawData/BuildFile.xml | 2 +- DataFormats/EcalRecHit/BuildFile.xml | 2 +- DataFormats/EgammaCandidates/BuildFile.xml | 2 +- DataFormats/EgammaReco/BuildFile.xml | 2 +- DataFormats/EgammaTrackReco/BuildFile.xml | 2 +- DataFormats/FEDRawData/BuildFile.xml | 1 + DataFormats/FP420Cluster/BuildFile.xml | 2 +- DataFormats/FP420Digi/BuildFile.xml | 2 +- DataFormats/GEMDigi/BuildFile.xml | 2 +- DataFormats/GEMRecHit/BuildFile.xml | 2 +- DataFormats/GeometryCommonDetAlgo/BuildFile.xml | 2 +- DataFormats/GeometrySurface/BuildFile.xml | 2 +- DataFormats/GeometryVector/BuildFile.xml | 2 +- DataFormats/GsfTrackReco/BuildFile.xml | 2 +- DataFormats/HLTReco/BuildFile.xml | 2 +- DataFormats/HcalCalibObjects/BuildFile.xml | 2 +- DataFormats/HcalDetId/BuildFile.xml | 2 +- DataFormats/HcalDigi/BuildFile.xml | 2 +- DataFormats/HcalIsolatedTrack/BuildFile.xml | 2 +- DataFormats/HcalRecHit/BuildFile.xml | 2 +- DataFormats/HeavyIonEvent/BuildFile.xml | 2 +- DataFormats/Histograms/BuildFile.xml | 2 +- DataFormats/JetReco/BuildFile.xml | 2 +- DataFormats/L1CSCTrackFinder/BuildFile.xml | 2 +- DataFormats/L1CaloTrigger/BuildFile.xml | 2 +- DataFormats/L1DTTrackFinder/BuildFile.xml | 2 +- DataFormats/L1GlobalCaloTrigger/BuildFile.xml | 2 +- DataFormats/L1GlobalMuonTrigger/BuildFile.xml | 2 +- DataFormats/L1GlobalTrigger/BuildFile.xml | 2 +- DataFormats/L1TCalorimeter/BuildFile.xml | 2 +- DataFormats/L1TGlobal/BuildFile.xml | 2 +- DataFormats/L1Trigger/BuildFile.xml | 2 +- DataFormats/LTCDigi/BuildFile.xml | 2 +- DataFormats/Luminosity/BuildFile.xml | 2 +- DataFormats/METReco/BuildFile.xml | 2 +- DataFormats/Math/BuildFile.xml | 1 + DataFormats/MuonDetId/BuildFile.xml | 2 +- DataFormats/MuonReco/BuildFile.xml | 2 +- DataFormats/MuonSeed/BuildFile.xml | 2 +- DataFormats/ParticleFlowCandidate/BuildFile.xml | 2 +- DataFormats/ParticleFlowReco/BuildFile.xml | 2 +- DataFormats/PatCandidates/BuildFile.xml | 2 +- DataFormats/Phase2TrackerDigi/BuildFile.xml | 2 +- DataFormats/RPCDigi/BuildFile.xml | 2 +- DataFormats/RPCRecHit/BuildFile.xml | 2 +- DataFormats/RecoCandidate/BuildFile.xml | 2 +- DataFormats/Scalers/BuildFile.xml | 2 +- DataFormats/SiPixelCluster/BuildFile.xml | 2 +- DataFormats/SiPixelDetId/BuildFile.xml | 2 +- DataFormats/SiPixelDigi/BuildFile.xml | 2 +- DataFormats/SiPixelRawData/BuildFile.xml | 2 +- DataFormats/SiStripCluster/BuildFile.xml | 2 +- DataFormats/SiStripCommon/BuildFile.xml | 2 +- DataFormats/SiStripDetId/BuildFile.xml | 2 +- DataFormats/SiStripDigi/BuildFile.xml | 2 +- DataFormats/StdDictionaries/BuildFile.xml | 3 ++- DataFormats/TauReco/BuildFile.xml | 2 +- DataFormats/TrackCandidate/BuildFile.xml | 2 +- DataFormats/TrackReco/BuildFile.xml | 2 +- DataFormats/TrackerRecHit2D/BuildFile.xml | 2 +- DataFormats/TrackingRecHit/BuildFile.xml | 1 + DataFormats/TrackingSeed/BuildFile.xml | 2 +- DataFormats/TrajectorySeed/BuildFile.xml | 2 +- DataFormats/TrajectoryState/BuildFile.xml | 3 ++- DataFormats/V0Candidate/BuildFile.xml | 2 +- DataFormats/VZero/BuildFile.xml | 2 +- DataFormats/VertexReco/BuildFile.xml | 2 +- ElectroWeakAnalysis/Utilities/BuildFile.xml | 2 +- EventFilter/ESDigiToRaw/BuildFile.xml | 2 +- EventFilter/ESRawToDigi/BuildFile.xml | 2 +- EventFilter/EcalDigiToRaw/BuildFile.xml | 2 +- EventFilter/EcalRawToDigi/BuildFile.xml | 2 +- EventFilter/RPCRawToDigi/BuildFile.xml | 2 +- FWCore/Skeletons/scripts/mkTemplates/DataPkg/BuildFile.xml | 2 +- .../scripts/mkTemplates/EventHypothesis/BuildFile.xml | 4 ++-- FWCore/Utilities/BuildFile.xml | 2 +- FastSimDataFormats/External/BuildFile.xml | 2 +- FastSimDataFormats/NuclearInteractions/BuildFile.xml | 2 +- FastSimDataFormats/PileUpEvents/BuildFile.xml | 3 ++- Fireworks/Muons/plugins/BuildFile.xml | 2 +- Fireworks/Tracks/plugins/BuildFile.xml | 2 +- GeneratorInterface/Hydjet2Interface/BuildFile.xml | 2 +- HiggsAnalysis/HiggsToGammaGamma/BuildFile.xml | 2 +- JetMETCorrections/JetParton/BuildFile.xml | 2 +- JetMETCorrections/TauJet/BuildFile.xml | 2 +- JetMETCorrections/TauJet/plugins/BuildFile.xml | 2 +- L1Trigger/DTBti/BuildFile.xml | 2 +- L1Trigger/DTSectorCollector/BuildFile.xml | 2 +- L1Trigger/DTTraco/BuildFile.xml | 2 +- L1Trigger/DTTrigger/BuildFile.xml | 2 +- L1Trigger/DTTriggerServerPhi/BuildFile.xml | 2 +- L1Trigger/DTTriggerServerTheta/BuildFile.xml | 2 +- L1Trigger/DTUtilities/BuildFile.xml | 2 +- L1TriggerConfig/DTTPGConfig/BuildFile.xml | 2 +- L1TriggerConfig/DTTPGConfigProducers/BuildFile.xml | 2 +- MuonAnalysis/MomentumScaleCalibration/BuildFile.xml | 2 +- PhysicsTools/Heppy/BuildFile.xml | 2 +- PhysicsTools/HeppyCore/BuildFile.xml | 2 +- PhysicsTools/JetMCUtils/BuildFile.xml | 2 +- PhysicsTools/ParallelAnalysis/BuildFile.xml | 2 +- PhysicsTools/SelectorUtils/BuildFile.xml | 2 +- PhysicsTools/Utilities/BuildFile.xml | 2 +- RecoBTag/ImpactParameter/test/BuildFile.xml | 2 +- RecoEgamma/ElectronIdentification/BuildFile.xml | 2 +- RecoHI/HiCentralityAlgos/BuildFile.xml | 2 +- RecoHI/HiEvtPlaneAlgos/BuildFile.xml | 2 +- RecoHI/HiMuonAlgos/BuildFile.xml | 2 +- RecoHI/HiMuonAlgos/plugins/BuildFile.xml | 2 +- RecoJets/FFTJetAlgorithms/BuildFile.xml | 2 +- RecoParticleFlow/PFClusterTools/BuildFile.xml | 2 +- RecoRomanPot/RecoFP420/BuildFile.xml | 2 +- RecoTauTag/ImpactParameter/BuildFile.xml | 2 +- RecoTauTag/ImpactParameter/plugins/BuildFile.xml | 2 +- RecoTracker/MeasurementDet/BuildFile.xml | 2 +- RecoTracker/NuclearSeedGenerator/BuildFile.xml | 2 +- RecoTracker/TkSeedGenerator/BuildFile.xml | 2 +- RecoVertex/BeamSpotProducer/plugins/BuildFile.xml | 2 +- RecoVertex/BeamSpotProducer/test/BuildFile.xml | 2 +- SimDataFormats/CaloHit/BuildFile.xml | 2 +- SimDataFormats/CaloTest/BuildFile.xml | 2 +- SimDataFormats/CrossingFrame/BuildFile.xml | 2 +- SimDataFormats/DigiSimLinks/BuildFile.xml | 2 +- SimDataFormats/EcalTestBeam/BuildFile.xml | 2 +- SimDataFormats/EncodedEventId/BuildFile.xml | 1 + SimDataFormats/Forward/BuildFile.xml | 2 +- SimDataFormats/GeneratorProducts/BuildFile.xml | 2 +- SimDataFormats/HcalTestBeam/BuildFile.xml | 2 +- SimDataFormats/HiGenData/BuildFile.xml | 2 +- SimDataFormats/JetMatching/BuildFile.xml | 2 +- SimDataFormats/PileupSummaryInfo/BuildFile.xml | 2 +- SimDataFormats/RPCDigiSimLink/BuildFile.xml | 2 +- SimDataFormats/RandomEngine/BuildFile.xml | 2 +- SimDataFormats/Track/BuildFile.xml | 2 +- SimDataFormats/TrackerDigiSimLink/BuildFile.xml | 2 +- SimDataFormats/TrackingAnalysis/BuildFile.xml | 2 +- SimDataFormats/TrackingHit/BuildFile.xml | 2 +- SimDataFormats/ValidationFormats/BuildFile.xml | 2 +- SimDataFormats/Vertex/BuildFile.xml | 2 +- SimG4CMS/Calo/BuildFile.xml | 2 +- SimG4Core/Application/BuildFile.xml | 2 +- SimMuon/GEMDigitizer/BuildFile.xml | 2 +- SimMuon/MCTruth/BuildFile.xml | 2 +- SimMuon/RPCDigitizer/BuildFile.xml | 2 +- SimTracker/TrackAssociation/BuildFile.xml | 2 +- TBDataFormats/EcalTBObjects/BuildFile.xml | 2 +- TBDataFormats/HcalTBObjects/BuildFile.xml | 2 +- TrackingTools/PatternTools/BuildFile.xml | 2 +- TrackingTools/TrajectoryState/BuildFile.xml | 2 +- Validation/RecoParticleFlow/BuildFile.xml | 1 + 213 files changed, 218 insertions(+), 210 deletions(-) diff --git a/Alignment/OfflineValidation/BuildFile.xml b/Alignment/OfflineValidation/BuildFile.xml index fa83af8d821f7..87e7a11cab864 100644 --- a/Alignment/OfflineValidation/BuildFile.xml +++ b/Alignment/OfflineValidation/BuildFile.xml @@ -7,7 +7,7 @@ - + diff --git a/AnalysisDataFormats/EWK/BuildFile.xml b/AnalysisDataFormats/EWK/BuildFile.xml index 255d0ab364f63..6a4014ccf09f0 100644 --- a/AnalysisDataFormats/EWK/BuildFile.xml +++ b/AnalysisDataFormats/EWK/BuildFile.xml @@ -8,7 +8,7 @@ - + diff --git a/AnalysisDataFormats/Egamma/BuildFile.xml b/AnalysisDataFormats/Egamma/BuildFile.xml index c72e1ae0e4054..8caa6925e4b57 100644 --- a/AnalysisDataFormats/Egamma/BuildFile.xml +++ b/AnalysisDataFormats/Egamma/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/AnalysisDataFormats/SUSYBSMObjects/BuildFile.xml b/AnalysisDataFormats/SUSYBSMObjects/BuildFile.xml index cec048f15aba4..f333a38a9089e 100644 --- a/AnalysisDataFormats/SUSYBSMObjects/BuildFile.xml +++ b/AnalysisDataFormats/SUSYBSMObjects/BuildFile.xml @@ -3,7 +3,7 @@ - + diff --git a/AnalysisDataFormats/TrackInfo/BuildFile.xml b/AnalysisDataFormats/TrackInfo/BuildFile.xml index 195ddc1b3e561..7156152686aa4 100644 --- a/AnalysisDataFormats/TrackInfo/BuildFile.xml +++ b/AnalysisDataFormats/TrackInfo/BuildFile.xml @@ -8,7 +8,7 @@ - + diff --git a/CalibTracker/SiStripCommon/BuildFile.xml b/CalibTracker/SiStripCommon/BuildFile.xml index edea19ea79e55..ac48b035d25d4 100644 --- a/CalibTracker/SiStripCommon/BuildFile.xml +++ b/CalibTracker/SiStripCommon/BuildFile.xml @@ -8,7 +8,7 @@ - + diff --git a/Calibration/HcalCalibAlgos/BuildFile.xml b/Calibration/HcalCalibAlgos/BuildFile.xml index 6abaa1925d359..1a79e9af0cd25 100644 --- a/Calibration/HcalCalibAlgos/BuildFile.xml +++ b/Calibration/HcalCalibAlgos/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/CaloOnlineTools/HcalOnlineDb/BuildFile.xml b/CaloOnlineTools/HcalOnlineDb/BuildFile.xml index 815131cb51245..b61867294396d 100644 --- a/CaloOnlineTools/HcalOnlineDb/BuildFile.xml +++ b/CaloOnlineTools/HcalOnlineDb/BuildFile.xml @@ -6,7 +6,7 @@ - + diff --git a/CaloOnlineTools/HcalOnlineDb/plugins/BuildFile.xml b/CaloOnlineTools/HcalOnlineDb/plugins/BuildFile.xml index 5a0351e7c936c..9beff94bc52d4 100644 --- a/CaloOnlineTools/HcalOnlineDb/plugins/BuildFile.xml +++ b/CaloOnlineTools/HcalOnlineDb/plugins/BuildFile.xml @@ -6,7 +6,7 @@ - + diff --git a/CaloOnlineTools/HcalOnlineDb/test/BuildFile.xml b/CaloOnlineTools/HcalOnlineDb/test/BuildFile.xml index e5b56f234d97c..1267c94af2dac 100644 --- a/CaloOnlineTools/HcalOnlineDb/test/BuildFile.xml +++ b/CaloOnlineTools/HcalOnlineDb/test/BuildFile.xml @@ -1,6 +1,6 @@ - + @@ -10,7 +10,7 @@ - + diff --git a/CommonTools/PileupAlgos/BuildFile.xml b/CommonTools/PileupAlgos/BuildFile.xml index 7dfc1bb36c0b9..eb953908de111 100644 --- a/CommonTools/PileupAlgos/BuildFile.xml +++ b/CommonTools/PileupAlgos/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/CommonTools/RecoUtils/BuildFile.xml b/CommonTools/RecoUtils/BuildFile.xml index f72e5a0e8c22d..544d3cc90bfd0 100644 --- a/CommonTools/RecoUtils/BuildFile.xml +++ b/CommonTools/RecoUtils/BuildFile.xml @@ -14,7 +14,7 @@ - + diff --git a/CondCore/CondDB/test/BuildFile.xml b/CondCore/CondDB/test/BuildFile.xml index 57af57d8f2fc3..98e47b33eaad8 100644 --- a/CondCore/CondDB/test/BuildFile.xml +++ b/CondCore/CondDB/test/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/CondCore/DBCommon/plugins/BuildFile.xml b/CondCore/DBCommon/plugins/BuildFile.xml index 7505024e4b1c8..374d18e46c486 100644 --- a/CondCore/DBCommon/plugins/BuildFile.xml +++ b/CondCore/DBCommon/plugins/BuildFile.xml @@ -24,6 +24,6 @@ - + diff --git a/CondCore/DBCommon/test/BuildFile.xml b/CondCore/DBCommon/test/BuildFile.xml index afaca55622e09..37495c9c0a0b2 100644 --- a/CondCore/DBCommon/test/BuildFile.xml +++ b/CondCore/DBCommon/test/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/CondCore/IOVService/test/BuildFile.xml b/CondCore/IOVService/test/BuildFile.xml index b55b61cb58fa3..4bd5d0973bf7d 100644 --- a/CondCore/IOVService/test/BuildFile.xml +++ b/CondCore/IOVService/test/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/CondCore/ORA/test/BuildFile.xml b/CondCore/ORA/test/BuildFile.xml index 65fa93c5b3068..240e0ff888dde 100644 --- a/CondCore/ORA/test/BuildFile.xml +++ b/CondCore/ORA/test/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/CondFormats/Alignment/BuildFile.xml b/CondFormats/Alignment/BuildFile.xml index 40e19a91ba922..796145f1c3476 100644 --- a/CondFormats/Alignment/BuildFile.xml +++ b/CondFormats/Alignment/BuildFile.xml @@ -5,7 +5,7 @@ - + diff --git a/CondFormats/BTauObjects/BuildFile.xml b/CondFormats/BTauObjects/BuildFile.xml index 93db96c78d3b8..8df6b15f34bb8 100644 --- a/CondFormats/BTauObjects/BuildFile.xml +++ b/CondFormats/BTauObjects/BuildFile.xml @@ -4,7 +4,7 @@ - + diff --git a/CondFormats/BeamSpotObjects/BuildFile.xml b/CondFormats/BeamSpotObjects/BuildFile.xml index 2e1640de3a9bc..ce8be06adf1bf 100644 --- a/CondFormats/BeamSpotObjects/BuildFile.xml +++ b/CondFormats/BeamSpotObjects/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/CondFormats/CSCObjects/BuildFile.xml b/CondFormats/CSCObjects/BuildFile.xml index 9b9d0c1d81024..489c382e1f4cd 100644 --- a/CondFormats/CSCObjects/BuildFile.xml +++ b/CondFormats/CSCObjects/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/CondFormats/Calibration/BuildFile.xml b/CondFormats/Calibration/BuildFile.xml index 8cb5a282bf440..1445574562287 100644 --- a/CondFormats/Calibration/BuildFile.xml +++ b/CondFormats/Calibration/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/CondFormats/CastorObjects/BuildFile.xml b/CondFormats/CastorObjects/BuildFile.xml index e644a1fea2b86..d8a49b16ab4fa 100644 --- a/CondFormats/CastorObjects/BuildFile.xml +++ b/CondFormats/CastorObjects/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/CondFormats/Common/BuildFile.xml b/CondFormats/Common/BuildFile.xml index 955c026556df2..a412821acae1d 100644 --- a/CondFormats/Common/BuildFile.xml +++ b/CondFormats/Common/BuildFile.xml @@ -5,7 +5,7 @@ - + diff --git a/CondFormats/DQMObjects/BuildFile.xml b/CondFormats/DQMObjects/BuildFile.xml index 7d7fd839c8e35..26fad76e414b6 100644 --- a/CondFormats/DQMObjects/BuildFile.xml +++ b/CondFormats/DQMObjects/BuildFile.xml @@ -3,7 +3,7 @@ - + diff --git a/CondFormats/DTObjects/BuildFile.xml b/CondFormats/DTObjects/BuildFile.xml index 95ae634adb559..448f600aec3f3 100644 --- a/CondFormats/DTObjects/BuildFile.xml +++ b/CondFormats/DTObjects/BuildFile.xml @@ -6,7 +6,7 @@ - + diff --git a/CondFormats/ESObjects/BuildFile.xml b/CondFormats/ESObjects/BuildFile.xml index a6d891a54d1e2..c25dc74df4899 100644 --- a/CondFormats/ESObjects/BuildFile.xml +++ b/CondFormats/ESObjects/BuildFile.xml @@ -5,7 +5,7 @@ - + diff --git a/CondFormats/EcalCorrections/BuildFile.xml b/CondFormats/EcalCorrections/BuildFile.xml index c5cdc3b19d8bb..b4fe3b578936f 100644 --- a/CondFormats/EcalCorrections/BuildFile.xml +++ b/CondFormats/EcalCorrections/BuildFile.xml @@ -3,7 +3,7 @@ - + diff --git a/CondFormats/EcalObjects/BuildFile.xml b/CondFormats/EcalObjects/BuildFile.xml index 342dfca37bb4b..1ac659f8abdd1 100644 --- a/CondFormats/EcalObjects/BuildFile.xml +++ b/CondFormats/EcalObjects/BuildFile.xml @@ -8,7 +8,7 @@ - + diff --git a/CondFormats/EgammaObjects/BuildFile.xml b/CondFormats/EgammaObjects/BuildFile.xml index 1aa4e256f3e7a..fd10fd3023857 100644 --- a/CondFormats/EgammaObjects/BuildFile.xml +++ b/CondFormats/EgammaObjects/BuildFile.xml @@ -3,7 +3,7 @@ - + diff --git a/CondFormats/GeometryObjects/BuildFile.xml b/CondFormats/GeometryObjects/BuildFile.xml index 0179b093c3dbf..d5bdb550c994e 100644 --- a/CondFormats/GeometryObjects/BuildFile.xml +++ b/CondFormats/GeometryObjects/BuildFile.xml @@ -5,7 +5,7 @@ - + diff --git a/CondFormats/HIObjects/BuildFile.xml b/CondFormats/HIObjects/BuildFile.xml index 256e0e17247c0..5955afea13af6 100644 --- a/CondFormats/HIObjects/BuildFile.xml +++ b/CondFormats/HIObjects/BuildFile.xml @@ -3,7 +3,7 @@ - + diff --git a/CondFormats/HLTObjects/BuildFile.xml b/CondFormats/HLTObjects/BuildFile.xml index 6bf396eb25280..447af6b559c14 100644 --- a/CondFormats/HLTObjects/BuildFile.xml +++ b/CondFormats/HLTObjects/BuildFile.xml @@ -3,7 +3,7 @@ - + diff --git a/CondFormats/HcalObjects/BuildFile.xml b/CondFormats/HcalObjects/BuildFile.xml index 7f7f04a3971e9..901da043adce5 100644 --- a/CondFormats/HcalObjects/BuildFile.xml +++ b/CondFormats/HcalObjects/BuildFile.xml @@ -7,7 +7,7 @@ - + diff --git a/CondFormats/JetMETObjects/BuildFile.xml b/CondFormats/JetMETObjects/BuildFile.xml index 911f2239a193a..26cbe21fa5c40 100644 --- a/CondFormats/JetMETObjects/BuildFile.xml +++ b/CondFormats/JetMETObjects/BuildFile.xml @@ -5,7 +5,7 @@ - + diff --git a/CondFormats/L1TObjects/BuildFile.xml b/CondFormats/L1TObjects/BuildFile.xml index c94821b501810..62459599c2ae8 100644 --- a/CondFormats/L1TObjects/BuildFile.xml +++ b/CondFormats/L1TObjects/BuildFile.xml @@ -5,7 +5,7 @@ - + diff --git a/CondFormats/Luminosity/BuildFile.xml b/CondFormats/Luminosity/BuildFile.xml index 5e8209019023a..35b1112eb3de2 100644 --- a/CondFormats/Luminosity/BuildFile.xml +++ b/CondFormats/Luminosity/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/CondFormats/MFObjects/BuildFile.xml b/CondFormats/MFObjects/BuildFile.xml index c5c372d051391..613293980e054 100644 --- a/CondFormats/MFObjects/BuildFile.xml +++ b/CondFormats/MFObjects/BuildFile.xml @@ -4,7 +4,7 @@ - + diff --git a/CondFormats/OptAlignObjects/BuildFile.xml b/CondFormats/OptAlignObjects/BuildFile.xml index 415c1c323d220..01de6c365cdfa 100644 --- a/CondFormats/OptAlignObjects/BuildFile.xml +++ b/CondFormats/OptAlignObjects/BuildFile.xml @@ -4,7 +4,7 @@ - + diff --git a/CondFormats/RPCObjects/BuildFile.xml b/CondFormats/RPCObjects/BuildFile.xml index 8e3ae658d3f40..01b659fa7fd3b 100644 --- a/CondFormats/RPCObjects/BuildFile.xml +++ b/CondFormats/RPCObjects/BuildFile.xml @@ -6,7 +6,7 @@ - + diff --git a/CondFormats/RecoMuonObjects/BuildFile.xml b/CondFormats/RecoMuonObjects/BuildFile.xml index dde06cefd5a0b..325d6f66a2dff 100644 --- a/CondFormats/RecoMuonObjects/BuildFile.xml +++ b/CondFormats/RecoMuonObjects/BuildFile.xml @@ -4,7 +4,7 @@ - + diff --git a/CondFormats/RunInfo/BuildFile.xml b/CondFormats/RunInfo/BuildFile.xml index b56dbb8cbe885..fd02c6396df0a 100644 --- a/CondFormats/RunInfo/BuildFile.xml +++ b/CondFormats/RunInfo/BuildFile.xml @@ -4,7 +4,7 @@ - + diff --git a/CondFormats/SiPixelObjects/BuildFile.xml b/CondFormats/SiPixelObjects/BuildFile.xml index 8b12050efeead..f00b8e9183372 100644 --- a/CondFormats/SiPixelObjects/BuildFile.xml +++ b/CondFormats/SiPixelObjects/BuildFile.xml @@ -12,7 +12,7 @@ - + diff --git a/CondFormats/SiStripObjects/BuildFile.xml b/CondFormats/SiStripObjects/BuildFile.xml index 81498bd22a5d7..306e807a6ef9e 100644 --- a/CondFormats/SiStripObjects/BuildFile.xml +++ b/CondFormats/SiStripObjects/BuildFile.xml @@ -7,7 +7,7 @@ - + diff --git a/CondTools/DQM/BuildFile.xml b/CondTools/DQM/BuildFile.xml index bac2f52b56a5f..72af19f23238e 100644 --- a/CondTools/DQM/BuildFile.xml +++ b/CondTools/DQM/BuildFile.xml @@ -7,7 +7,7 @@ - + diff --git a/CondTools/DT/BuildFile.xml b/CondTools/DT/BuildFile.xml index 6bdbc7ff21add..3234a95a94615 100644 --- a/CondTools/DT/BuildFile.xml +++ b/CondTools/DT/BuildFile.xml @@ -8,7 +8,7 @@ - + diff --git a/CondTools/RunInfo/BuildFile.xml b/CondTools/RunInfo/BuildFile.xml index eeeaa5d9307d4..ab36cdc2c9378 100644 --- a/CondTools/RunInfo/BuildFile.xml +++ b/CondTools/RunInfo/BuildFile.xml @@ -10,7 +10,7 @@ - + diff --git a/CondTools/Utilities/test/BuildFile.xml b/CondTools/Utilities/test/BuildFile.xml index 341733da420de..3792a5e502980 100644 --- a/CondTools/Utilities/test/BuildFile.xml +++ b/CondTools/Utilities/test/BuildFile.xml @@ -9,6 +9,6 @@ - + diff --git a/DPGAnalysis/SiStripTools/BuildFile.xml b/DPGAnalysis/SiStripTools/BuildFile.xml index 27b2758693ddd..ccd74e8458df6 100644 --- a/DPGAnalysis/SiStripTools/BuildFile.xml +++ b/DPGAnalysis/SiStripTools/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/DQM/Integration/BuildFile.xml b/DQM/Integration/BuildFile.xml index 66697e38791cf..a38fc07e61ee1 100644 --- a/DQM/Integration/BuildFile.xml +++ b/DQM/Integration/BuildFile.xml @@ -5,7 +5,7 @@ - + diff --git a/DQM/SiPixelCommon/BuildFile.xml b/DQM/SiPixelCommon/BuildFile.xml index ddb45812d74c6..83fbd29dee34d 100644 --- a/DQM/SiPixelCommon/BuildFile.xml +++ b/DQM/SiPixelCommon/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/DataFormats/Alignment/BuildFile.xml b/DataFormats/Alignment/BuildFile.xml index 0cf0244b2b5a4..42276457935d8 100644 --- a/DataFormats/Alignment/BuildFile.xml +++ b/DataFormats/Alignment/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/DataFormats/BTauReco/BuildFile.xml b/DataFormats/BTauReco/BuildFile.xml index 83559c7e03ae7..cb2f3e212189a 100644 --- a/DataFormats/BTauReco/BuildFile.xml +++ b/DataFormats/BTauReco/BuildFile.xml @@ -8,7 +8,7 @@ - + diff --git a/DataFormats/BeamSpot/BuildFile.xml b/DataFormats/BeamSpot/BuildFile.xml index 17df120436809..c00db8a122e5a 100644 --- a/DataFormats/BeamSpot/BuildFile.xml +++ b/DataFormats/BeamSpot/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/DataFormats/CLHEP/BuildFile.xml b/DataFormats/CLHEP/BuildFile.xml index 828bbd1e850f6..e31cb337489f0 100644 --- a/DataFormats/CLHEP/BuildFile.xml +++ b/DataFormats/CLHEP/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/DataFormats/CSCDigi/BuildFile.xml b/DataFormats/CSCDigi/BuildFile.xml index c44319884cc85..6b051ab873637 100644 --- a/DataFormats/CSCDigi/BuildFile.xml +++ b/DataFormats/CSCDigi/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/DataFormats/CSCRecHit/BuildFile.xml b/DataFormats/CSCRecHit/BuildFile.xml index d132435d1f51f..90b1759298ee3 100644 --- a/DataFormats/CSCRecHit/BuildFile.xml +++ b/DataFormats/CSCRecHit/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/DataFormats/CaloRecHit/BuildFile.xml b/DataFormats/CaloRecHit/BuildFile.xml index ef3acc2633f87..8338e8b9c0da0 100644 --- a/DataFormats/CaloRecHit/BuildFile.xml +++ b/DataFormats/CaloRecHit/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/DataFormats/CaloTowers/BuildFile.xml b/DataFormats/CaloTowers/BuildFile.xml index 2fffaac1f136e..a1c8e2e436767 100644 --- a/DataFormats/CaloTowers/BuildFile.xml +++ b/DataFormats/CaloTowers/BuildFile.xml @@ -3,7 +3,7 @@ - + diff --git a/DataFormats/CastorReco/BuildFile.xml b/DataFormats/CastorReco/BuildFile.xml index 2cecd48254a1c..dc3ee5ffe14a5 100644 --- a/DataFormats/CastorReco/BuildFile.xml +++ b/DataFormats/CastorReco/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/DataFormats/DTDigi/BuildFile.xml b/DataFormats/DTDigi/BuildFile.xml index 1108a519064e1..d4f71bd65669b 100644 --- a/DataFormats/DTDigi/BuildFile.xml +++ b/DataFormats/DTDigi/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/DataFormats/DTRecHit/BuildFile.xml b/DataFormats/DTRecHit/BuildFile.xml index 22709c259747d..d6477b2103214 100644 --- a/DataFormats/DTRecHit/BuildFile.xml +++ b/DataFormats/DTRecHit/BuildFile.xml @@ -5,7 +5,7 @@ - + diff --git a/DataFormats/EcalDetId/BuildFile.xml b/DataFormats/EcalDetId/BuildFile.xml index 7bf553bbd55cd..d766a0875751d 100644 --- a/DataFormats/EcalDetId/BuildFile.xml +++ b/DataFormats/EcalDetId/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/DataFormats/EcalDigi/BuildFile.xml b/DataFormats/EcalDigi/BuildFile.xml index 77cacb8a92001..10056d6a57065 100644 --- a/DataFormats/EcalDigi/BuildFile.xml +++ b/DataFormats/EcalDigi/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/DataFormats/EcalRawData/BuildFile.xml b/DataFormats/EcalRawData/BuildFile.xml index 58a30006bd9e6..2534ed9f7c507 100644 --- a/DataFormats/EcalRawData/BuildFile.xml +++ b/DataFormats/EcalRawData/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/DataFormats/EcalRecHit/BuildFile.xml b/DataFormats/EcalRecHit/BuildFile.xml index d1fd1f8e4a13e..66f2c3f9637dd 100644 --- a/DataFormats/EcalRecHit/BuildFile.xml +++ b/DataFormats/EcalRecHit/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/DataFormats/EgammaCandidates/BuildFile.xml b/DataFormats/EgammaCandidates/BuildFile.xml index ded4b01aab5ac..9643f47afda4c 100644 --- a/DataFormats/EgammaCandidates/BuildFile.xml +++ b/DataFormats/EgammaCandidates/BuildFile.xml @@ -12,7 +12,7 @@ # - + diff --git a/DataFormats/EgammaReco/BuildFile.xml b/DataFormats/EgammaReco/BuildFile.xml index 197fd23c3a5c0..01e8700b773e5 100644 --- a/DataFormats/EgammaReco/BuildFile.xml +++ b/DataFormats/EgammaReco/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/DataFormats/EgammaTrackReco/BuildFile.xml b/DataFormats/EgammaTrackReco/BuildFile.xml index b92373070fd33..7f1be48dbbbfb 100644 --- a/DataFormats/EgammaTrackReco/BuildFile.xml +++ b/DataFormats/EgammaTrackReco/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/DataFormats/FEDRawData/BuildFile.xml b/DataFormats/FEDRawData/BuildFile.xml index 16dcb9b82b73c..4ac1a9bdd716e 100644 --- a/DataFormats/FEDRawData/BuildFile.xml +++ b/DataFormats/FEDRawData/BuildFile.xml @@ -1,6 +1,7 @@ + diff --git a/DataFormats/FP420Cluster/BuildFile.xml b/DataFormats/FP420Cluster/BuildFile.xml index 58a30006bd9e6..2534ed9f7c507 100644 --- a/DataFormats/FP420Cluster/BuildFile.xml +++ b/DataFormats/FP420Cluster/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/DataFormats/FP420Digi/BuildFile.xml b/DataFormats/FP420Digi/BuildFile.xml index 58a30006bd9e6..2534ed9f7c507 100644 --- a/DataFormats/FP420Digi/BuildFile.xml +++ b/DataFormats/FP420Digi/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/DataFormats/GEMDigi/BuildFile.xml b/DataFormats/GEMDigi/BuildFile.xml index c44319884cc85..6b051ab873637 100644 --- a/DataFormats/GEMDigi/BuildFile.xml +++ b/DataFormats/GEMDigi/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/DataFormats/GEMRecHit/BuildFile.xml b/DataFormats/GEMRecHit/BuildFile.xml index 4a170cd30016e..0b431e98854d6 100644 --- a/DataFormats/GEMRecHit/BuildFile.xml +++ b/DataFormats/GEMRecHit/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/DataFormats/GeometryCommonDetAlgo/BuildFile.xml b/DataFormats/GeometryCommonDetAlgo/BuildFile.xml index 70fb2a7280cec..92b45ab0734dd 100644 --- a/DataFormats/GeometryCommonDetAlgo/BuildFile.xml +++ b/DataFormats/GeometryCommonDetAlgo/BuildFile.xml @@ -3,7 +3,7 @@ - + diff --git a/DataFormats/GeometrySurface/BuildFile.xml b/DataFormats/GeometrySurface/BuildFile.xml index 87ff35abeaf30..d938464f99cb2 100644 --- a/DataFormats/GeometrySurface/BuildFile.xml +++ b/DataFormats/GeometrySurface/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/DataFormats/GeometryVector/BuildFile.xml b/DataFormats/GeometryVector/BuildFile.xml index c2993b3bb883f..84eab0a14a01c 100644 --- a/DataFormats/GeometryVector/BuildFile.xml +++ b/DataFormats/GeometryVector/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/DataFormats/GsfTrackReco/BuildFile.xml b/DataFormats/GsfTrackReco/BuildFile.xml index 85a672f7d3095..b8dc5473c9cc2 100644 --- a/DataFormats/GsfTrackReco/BuildFile.xml +++ b/DataFormats/GsfTrackReco/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/DataFormats/HLTReco/BuildFile.xml b/DataFormats/HLTReco/BuildFile.xml index 5e5d9f9af7cef..65966e9da9ea1 100644 --- a/DataFormats/HLTReco/BuildFile.xml +++ b/DataFormats/HLTReco/BuildFile.xml @@ -3,7 +3,7 @@ - + diff --git a/DataFormats/HcalCalibObjects/BuildFile.xml b/DataFormats/HcalCalibObjects/BuildFile.xml index b2792319bb4ba..b441f4a017fa9 100644 --- a/DataFormats/HcalCalibObjects/BuildFile.xml +++ b/DataFormats/HcalCalibObjects/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/DataFormats/HcalDetId/BuildFile.xml b/DataFormats/HcalDetId/BuildFile.xml index 999497c1c512e..413691cdd4672 100644 --- a/DataFormats/HcalDetId/BuildFile.xml +++ b/DataFormats/HcalDetId/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/DataFormats/HcalDigi/BuildFile.xml b/DataFormats/HcalDigi/BuildFile.xml index c430468987945..bb59853d0bf07 100644 --- a/DataFormats/HcalDigi/BuildFile.xml +++ b/DataFormats/HcalDigi/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/DataFormats/HcalIsolatedTrack/BuildFile.xml b/DataFormats/HcalIsolatedTrack/BuildFile.xml index 3eedb2fc350e8..bec94fbfb57f1 100644 --- a/DataFormats/HcalIsolatedTrack/BuildFile.xml +++ b/DataFormats/HcalIsolatedTrack/BuildFile.xml @@ -4,7 +4,7 @@ - + diff --git a/DataFormats/HcalRecHit/BuildFile.xml b/DataFormats/HcalRecHit/BuildFile.xml index e76de2d48000d..aaa240de02620 100644 --- a/DataFormats/HcalRecHit/BuildFile.xml +++ b/DataFormats/HcalRecHit/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/DataFormats/HeavyIonEvent/BuildFile.xml b/DataFormats/HeavyIonEvent/BuildFile.xml index 4137ce2cc6f4a..373612e369dfe 100644 --- a/DataFormats/HeavyIonEvent/BuildFile.xml +++ b/DataFormats/HeavyIonEvent/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/DataFormats/Histograms/BuildFile.xml b/DataFormats/Histograms/BuildFile.xml index a92dd4a569bcc..14d0c9b47933a 100644 --- a/DataFormats/Histograms/BuildFile.xml +++ b/DataFormats/Histograms/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/DataFormats/JetReco/BuildFile.xml b/DataFormats/JetReco/BuildFile.xml index 1bb368b14ffcb..5b1acd73e180c 100644 --- a/DataFormats/JetReco/BuildFile.xml +++ b/DataFormats/JetReco/BuildFile.xml @@ -6,7 +6,7 @@ - + diff --git a/DataFormats/L1CSCTrackFinder/BuildFile.xml b/DataFormats/L1CSCTrackFinder/BuildFile.xml index 481aaaea21e48..728c52bf4f5db 100644 --- a/DataFormats/L1CSCTrackFinder/BuildFile.xml +++ b/DataFormats/L1CSCTrackFinder/BuildFile.xml @@ -3,7 +3,7 @@ - + diff --git a/DataFormats/L1CaloTrigger/BuildFile.xml b/DataFormats/L1CaloTrigger/BuildFile.xml index ef3acc2633f87..8338e8b9c0da0 100644 --- a/DataFormats/L1CaloTrigger/BuildFile.xml +++ b/DataFormats/L1CaloTrigger/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/DataFormats/L1DTTrackFinder/BuildFile.xml b/DataFormats/L1DTTrackFinder/BuildFile.xml index 6942cfe4e419f..cc4ecccc595cb 100644 --- a/DataFormats/L1DTTrackFinder/BuildFile.xml +++ b/DataFormats/L1DTTrackFinder/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/DataFormats/L1GlobalCaloTrigger/BuildFile.xml b/DataFormats/L1GlobalCaloTrigger/BuildFile.xml index 9fcef515b2f3c..57848d8679e9b 100644 --- a/DataFormats/L1GlobalCaloTrigger/BuildFile.xml +++ b/DataFormats/L1GlobalCaloTrigger/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/DataFormats/L1GlobalMuonTrigger/BuildFile.xml b/DataFormats/L1GlobalMuonTrigger/BuildFile.xml index 4fe63cd5cd811..0bf40c117104b 100644 --- a/DataFormats/L1GlobalMuonTrigger/BuildFile.xml +++ b/DataFormats/L1GlobalMuonTrigger/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/DataFormats/L1GlobalTrigger/BuildFile.xml b/DataFormats/L1GlobalTrigger/BuildFile.xml index dde3bacacf139..58dc97cd9c160 100644 --- a/DataFormats/L1GlobalTrigger/BuildFile.xml +++ b/DataFormats/L1GlobalTrigger/BuildFile.xml @@ -4,7 +4,7 @@ - + diff --git a/DataFormats/L1TCalorimeter/BuildFile.xml b/DataFormats/L1TCalorimeter/BuildFile.xml index 5a2e72c25b0f8..62bb44c3f8871 100644 --- a/DataFormats/L1TCalorimeter/BuildFile.xml +++ b/DataFormats/L1TCalorimeter/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/DataFormats/L1TGlobal/BuildFile.xml b/DataFormats/L1TGlobal/BuildFile.xml index 5a2e72c25b0f8..62bb44c3f8871 100644 --- a/DataFormats/L1TGlobal/BuildFile.xml +++ b/DataFormats/L1TGlobal/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/DataFormats/L1Trigger/BuildFile.xml b/DataFormats/L1Trigger/BuildFile.xml index 4841fc8749e5d..deb2141aec7e8 100644 --- a/DataFormats/L1Trigger/BuildFile.xml +++ b/DataFormats/L1Trigger/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/DataFormats/LTCDigi/BuildFile.xml b/DataFormats/LTCDigi/BuildFile.xml index b2792319bb4ba..b441f4a017fa9 100644 --- a/DataFormats/LTCDigi/BuildFile.xml +++ b/DataFormats/LTCDigi/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/DataFormats/Luminosity/BuildFile.xml b/DataFormats/Luminosity/BuildFile.xml index 1cbbbbe3530de..19a70f2cc3e82 100644 --- a/DataFormats/Luminosity/BuildFile.xml +++ b/DataFormats/Luminosity/BuildFile.xml @@ -1,4 +1,4 @@ - + diff --git a/DataFormats/METReco/BuildFile.xml b/DataFormats/METReco/BuildFile.xml index f29f5716fbe58..b625eabcd7f9e 100644 --- a/DataFormats/METReco/BuildFile.xml +++ b/DataFormats/METReco/BuildFile.xml @@ -3,7 +3,7 @@ - + diff --git a/DataFormats/Math/BuildFile.xml b/DataFormats/Math/BuildFile.xml index 2eb43cbc16e7d..776b2740ac222 100644 --- a/DataFormats/Math/BuildFile.xml +++ b/DataFormats/Math/BuildFile.xml @@ -1,6 +1,7 @@ + diff --git a/DataFormats/MuonDetId/BuildFile.xml b/DataFormats/MuonDetId/BuildFile.xml index d6eb3fa4ed57e..834da04ff1c57 100644 --- a/DataFormats/MuonDetId/BuildFile.xml +++ b/DataFormats/MuonDetId/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/DataFormats/MuonReco/BuildFile.xml b/DataFormats/MuonReco/BuildFile.xml index 135628b15614d..3148aa0399e07 100644 --- a/DataFormats/MuonReco/BuildFile.xml +++ b/DataFormats/MuonReco/BuildFile.xml @@ -5,7 +5,7 @@ - + diff --git a/DataFormats/MuonSeed/BuildFile.xml b/DataFormats/MuonSeed/BuildFile.xml index 201d974efd808..83f64622afea3 100644 --- a/DataFormats/MuonSeed/BuildFile.xml +++ b/DataFormats/MuonSeed/BuildFile.xml @@ -1,4 +1,4 @@ - + diff --git a/DataFormats/ParticleFlowCandidate/BuildFile.xml b/DataFormats/ParticleFlowCandidate/BuildFile.xml index ac29a74162aac..f270070c7fd4b 100644 --- a/DataFormats/ParticleFlowCandidate/BuildFile.xml +++ b/DataFormats/ParticleFlowCandidate/BuildFile.xml @@ -9,7 +9,7 @@ - + diff --git a/DataFormats/ParticleFlowReco/BuildFile.xml b/DataFormats/ParticleFlowReco/BuildFile.xml index cd68d8dff5426..ebc81bb68c72f 100644 --- a/DataFormats/ParticleFlowReco/BuildFile.xml +++ b/DataFormats/ParticleFlowReco/BuildFile.xml @@ -8,7 +8,7 @@ - + diff --git a/DataFormats/PatCandidates/BuildFile.xml b/DataFormats/PatCandidates/BuildFile.xml index 9599bae497db7..e973ed57d73fb 100644 --- a/DataFormats/PatCandidates/BuildFile.xml +++ b/DataFormats/PatCandidates/BuildFile.xml @@ -16,7 +16,7 @@ - + diff --git a/DataFormats/Phase2TrackerDigi/BuildFile.xml b/DataFormats/Phase2TrackerDigi/BuildFile.xml index b2792319bb4ba..b441f4a017fa9 100644 --- a/DataFormats/Phase2TrackerDigi/BuildFile.xml +++ b/DataFormats/Phase2TrackerDigi/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/DataFormats/RPCDigi/BuildFile.xml b/DataFormats/RPCDigi/BuildFile.xml index f9c3a20c5387a..1e3d901665500 100644 --- a/DataFormats/RPCDigi/BuildFile.xml +++ b/DataFormats/RPCDigi/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/DataFormats/RPCRecHit/BuildFile.xml b/DataFormats/RPCRecHit/BuildFile.xml index 4a170cd30016e..0b431e98854d6 100644 --- a/DataFormats/RPCRecHit/BuildFile.xml +++ b/DataFormats/RPCRecHit/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/DataFormats/RecoCandidate/BuildFile.xml b/DataFormats/RecoCandidate/BuildFile.xml index a358850aa3400..07c71f48df584 100644 --- a/DataFormats/RecoCandidate/BuildFile.xml +++ b/DataFormats/RecoCandidate/BuildFile.xml @@ -4,7 +4,7 @@ - + diff --git a/DataFormats/Scalers/BuildFile.xml b/DataFormats/Scalers/BuildFile.xml index 58a30006bd9e6..2534ed9f7c507 100644 --- a/DataFormats/Scalers/BuildFile.xml +++ b/DataFormats/Scalers/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/DataFormats/SiPixelCluster/BuildFile.xml b/DataFormats/SiPixelCluster/BuildFile.xml index b2792319bb4ba..b441f4a017fa9 100644 --- a/DataFormats/SiPixelCluster/BuildFile.xml +++ b/DataFormats/SiPixelCluster/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/DataFormats/SiPixelDetId/BuildFile.xml b/DataFormats/SiPixelDetId/BuildFile.xml index 32373b3d599b6..b5789e0ef2a2a 100644 --- a/DataFormats/SiPixelDetId/BuildFile.xml +++ b/DataFormats/SiPixelDetId/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/DataFormats/SiPixelDigi/BuildFile.xml b/DataFormats/SiPixelDigi/BuildFile.xml index 00838169c11a1..2e6becbe116a8 100644 --- a/DataFormats/SiPixelDigi/BuildFile.xml +++ b/DataFormats/SiPixelDigi/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/DataFormats/SiPixelRawData/BuildFile.xml b/DataFormats/SiPixelRawData/BuildFile.xml index b2792319bb4ba..b441f4a017fa9 100644 --- a/DataFormats/SiPixelRawData/BuildFile.xml +++ b/DataFormats/SiPixelRawData/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/DataFormats/SiStripCluster/BuildFile.xml b/DataFormats/SiStripCluster/BuildFile.xml index 58a30006bd9e6..2534ed9f7c507 100644 --- a/DataFormats/SiStripCluster/BuildFile.xml +++ b/DataFormats/SiStripCluster/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/DataFormats/SiStripCommon/BuildFile.xml b/DataFormats/SiStripCommon/BuildFile.xml index 6bbe5bcd3bd8f..d171455b931a4 100644 --- a/DataFormats/SiStripCommon/BuildFile.xml +++ b/DataFormats/SiStripCommon/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/DataFormats/SiStripDetId/BuildFile.xml b/DataFormats/SiStripDetId/BuildFile.xml index a383fe8ac0ceb..91f5b23b82a64 100644 --- a/DataFormats/SiStripDetId/BuildFile.xml +++ b/DataFormats/SiStripDetId/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/DataFormats/SiStripDigi/BuildFile.xml b/DataFormats/SiStripDigi/BuildFile.xml index 58a30006bd9e6..2534ed9f7c507 100644 --- a/DataFormats/SiStripDigi/BuildFile.xml +++ b/DataFormats/SiStripDigi/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/DataFormats/StdDictionaries/BuildFile.xml b/DataFormats/StdDictionaries/BuildFile.xml index 16e00489f386b..9fa5c3bbd2eae 100644 --- a/DataFormats/StdDictionaries/BuildFile.xml +++ b/DataFormats/StdDictionaries/BuildFile.xml @@ -1,4 +1,5 @@ - + + diff --git a/DataFormats/TauReco/BuildFile.xml b/DataFormats/TauReco/BuildFile.xml index 30ac70473d879..5832f6b48edd2 100644 --- a/DataFormats/TauReco/BuildFile.xml +++ b/DataFormats/TauReco/BuildFile.xml @@ -6,7 +6,7 @@ - + diff --git a/DataFormats/TrackCandidate/BuildFile.xml b/DataFormats/TrackCandidate/BuildFile.xml index b92373070fd33..7f1be48dbbbfb 100644 --- a/DataFormats/TrackCandidate/BuildFile.xml +++ b/DataFormats/TrackCandidate/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/DataFormats/TrackReco/BuildFile.xml b/DataFormats/TrackReco/BuildFile.xml index 7cbcb885b721c..6b612e95cc1d4 100644 --- a/DataFormats/TrackReco/BuildFile.xml +++ b/DataFormats/TrackReco/BuildFile.xml @@ -7,7 +7,7 @@ - + diff --git a/DataFormats/TrackerRecHit2D/BuildFile.xml b/DataFormats/TrackerRecHit2D/BuildFile.xml index 800b3add09aaf..ee024a5f10a8b 100644 --- a/DataFormats/TrackerRecHit2D/BuildFile.xml +++ b/DataFormats/TrackerRecHit2D/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/DataFormats/TrackingRecHit/BuildFile.xml b/DataFormats/TrackingRecHit/BuildFile.xml index cb9650cb976a2..8ca99d7c5c836 100644 --- a/DataFormats/TrackingRecHit/BuildFile.xml +++ b/DataFormats/TrackingRecHit/BuildFile.xml @@ -4,6 +4,7 @@ + diff --git a/DataFormats/TrackingSeed/BuildFile.xml b/DataFormats/TrackingSeed/BuildFile.xml index b2792319bb4ba..b441f4a017fa9 100644 --- a/DataFormats/TrackingSeed/BuildFile.xml +++ b/DataFormats/TrackingSeed/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/DataFormats/TrajectorySeed/BuildFile.xml b/DataFormats/TrajectorySeed/BuildFile.xml index b92373070fd33..7f1be48dbbbfb 100644 --- a/DataFormats/TrajectorySeed/BuildFile.xml +++ b/DataFormats/TrajectorySeed/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/DataFormats/TrajectoryState/BuildFile.xml b/DataFormats/TrajectoryState/BuildFile.xml index 32d705db1d2fb..1e6fd6129fdda 100644 --- a/DataFormats/TrajectoryState/BuildFile.xml +++ b/DataFormats/TrajectoryState/BuildFile.xml @@ -1,5 +1,6 @@ - + + diff --git a/DataFormats/V0Candidate/BuildFile.xml b/DataFormats/V0Candidate/BuildFile.xml index f36cab2a51915..faa3f640ba107 100644 --- a/DataFormats/V0Candidate/BuildFile.xml +++ b/DataFormats/V0Candidate/BuildFile.xml @@ -4,7 +4,7 @@ - + diff --git a/DataFormats/VZero/BuildFile.xml b/DataFormats/VZero/BuildFile.xml index 0052e48157c6b..9fde1c8979cf2 100644 --- a/DataFormats/VZero/BuildFile.xml +++ b/DataFormats/VZero/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/DataFormats/VertexReco/BuildFile.xml b/DataFormats/VertexReco/BuildFile.xml index fdf3608daab3a..e23687e4e863d 100644 --- a/DataFormats/VertexReco/BuildFile.xml +++ b/DataFormats/VertexReco/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/ElectroWeakAnalysis/Utilities/BuildFile.xml b/ElectroWeakAnalysis/Utilities/BuildFile.xml index 13955db0a3216..f30f988740c84 100644 --- a/ElectroWeakAnalysis/Utilities/BuildFile.xml +++ b/ElectroWeakAnalysis/Utilities/BuildFile.xml @@ -7,7 +7,7 @@ - + diff --git a/EventFilter/ESDigiToRaw/BuildFile.xml b/EventFilter/ESDigiToRaw/BuildFile.xml index a55ebd0d7e700..f83d799b2a386 100644 --- a/EventFilter/ESDigiToRaw/BuildFile.xml +++ b/EventFilter/ESDigiToRaw/BuildFile.xml @@ -5,4 +5,4 @@ - + diff --git a/EventFilter/ESRawToDigi/BuildFile.xml b/EventFilter/ESRawToDigi/BuildFile.xml index 644aa6ca0b1f1..5310f33587d71 100644 --- a/EventFilter/ESRawToDigi/BuildFile.xml +++ b/EventFilter/ESRawToDigi/BuildFile.xml @@ -6,6 +6,6 @@ - + diff --git a/EventFilter/EcalDigiToRaw/BuildFile.xml b/EventFilter/EcalDigiToRaw/BuildFile.xml index ebeae1544d9a4..015a8b41ccbf0 100644 --- a/EventFilter/EcalDigiToRaw/BuildFile.xml +++ b/EventFilter/EcalDigiToRaw/BuildFile.xml @@ -6,6 +6,6 @@ - + diff --git a/EventFilter/EcalRawToDigi/BuildFile.xml b/EventFilter/EcalRawToDigi/BuildFile.xml index 2840d916f0109..3bb940370c1f4 100644 --- a/EventFilter/EcalRawToDigi/BuildFile.xml +++ b/EventFilter/EcalRawToDigi/BuildFile.xml @@ -17,7 +17,7 @@ - + diff --git a/EventFilter/RPCRawToDigi/BuildFile.xml b/EventFilter/RPCRawToDigi/BuildFile.xml index 23a0f70844d86..cf32db6b3e3eb 100644 --- a/EventFilter/RPCRawToDigi/BuildFile.xml +++ b/EventFilter/RPCRawToDigi/BuildFile.xml @@ -6,7 +6,7 @@ - + diff --git a/FWCore/Skeletons/scripts/mkTemplates/DataPkg/BuildFile.xml b/FWCore/Skeletons/scripts/mkTemplates/DataPkg/BuildFile.xml index 169edbb34d6d4..8a94022902ae6 100644 --- a/FWCore/Skeletons/scripts/mkTemplates/DataPkg/BuildFile.xml +++ b/FWCore/Skeletons/scripts/mkTemplates/DataPkg/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/FWCore/Skeletons/scripts/mkTemplates/EventHypothesis/BuildFile.xml b/FWCore/Skeletons/scripts/mkTemplates/EventHypothesis/BuildFile.xml index 68ad7bd8cb051..49166277f32c8 100644 --- a/FWCore/Skeletons/scripts/mkTemplates/EventHypothesis/BuildFile.xml +++ b/FWCore/Skeletons/scripts/mkTemplates/EventHypothesis/BuildFile.xml @@ -1,7 +1,7 @@ - + - + diff --git a/FWCore/Utilities/BuildFile.xml b/FWCore/Utilities/BuildFile.xml index 57217e5fa4739..7b4ed5feecc18 100644 --- a/FWCore/Utilities/BuildFile.xml +++ b/FWCore/Utilities/BuildFile.xml @@ -3,7 +3,7 @@ - + diff --git a/FastSimDataFormats/External/BuildFile.xml b/FastSimDataFormats/External/BuildFile.xml index b2792319bb4ba..b441f4a017fa9 100644 --- a/FastSimDataFormats/External/BuildFile.xml +++ b/FastSimDataFormats/External/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/FastSimDataFormats/NuclearInteractions/BuildFile.xml b/FastSimDataFormats/NuclearInteractions/BuildFile.xml index 2149b8666285c..146e59a356238 100644 --- a/FastSimDataFormats/NuclearInteractions/BuildFile.xml +++ b/FastSimDataFormats/NuclearInteractions/BuildFile.xml @@ -1,4 +1,4 @@ - + diff --git a/FastSimDataFormats/PileUpEvents/BuildFile.xml b/FastSimDataFormats/PileUpEvents/BuildFile.xml index d36531733a219..59af8cc1fac04 100644 --- a/FastSimDataFormats/PileUpEvents/BuildFile.xml +++ b/FastSimDataFormats/PileUpEvents/BuildFile.xml @@ -1,4 +1,5 @@ - + + diff --git a/Fireworks/Muons/plugins/BuildFile.xml b/Fireworks/Muons/plugins/BuildFile.xml index 0169a79459a43..69f8bbee28571 100644 --- a/Fireworks/Muons/plugins/BuildFile.xml +++ b/Fireworks/Muons/plugins/BuildFile.xml @@ -15,7 +15,7 @@ - + diff --git a/Fireworks/Tracks/plugins/BuildFile.xml b/Fireworks/Tracks/plugins/BuildFile.xml index adec92c13dd1e..6c365833a5f62 100644 --- a/Fireworks/Tracks/plugins/BuildFile.xml +++ b/Fireworks/Tracks/plugins/BuildFile.xml @@ -14,7 +14,7 @@ - + diff --git a/GeneratorInterface/Hydjet2Interface/BuildFile.xml b/GeneratorInterface/Hydjet2Interface/BuildFile.xml index 4294ea61ea74d..5b31ef247ba27 100644 --- a/GeneratorInterface/Hydjet2Interface/BuildFile.xml +++ b/GeneratorInterface/Hydjet2Interface/BuildFile.xml @@ -19,7 +19,7 @@ - + diff --git a/HiggsAnalysis/HiggsToGammaGamma/BuildFile.xml b/HiggsAnalysis/HiggsToGammaGamma/BuildFile.xml index c69d42f323856..60b86c806b4e2 100644 --- a/HiggsAnalysis/HiggsToGammaGamma/BuildFile.xml +++ b/HiggsAnalysis/HiggsToGammaGamma/BuildFile.xml @@ -15,6 +15,6 @@ - + diff --git a/JetMETCorrections/JetParton/BuildFile.xml b/JetMETCorrections/JetParton/BuildFile.xml index 3ab9e12370a67..53e5f9a28822f 100644 --- a/JetMETCorrections/JetParton/BuildFile.xml +++ b/JetMETCorrections/JetParton/BuildFile.xml @@ -6,7 +6,7 @@ - + diff --git a/JetMETCorrections/TauJet/BuildFile.xml b/JetMETCorrections/TauJet/BuildFile.xml index 1f22572f9dfee..f73a5613ba48c 100644 --- a/JetMETCorrections/TauJet/BuildFile.xml +++ b/JetMETCorrections/TauJet/BuildFile.xml @@ -12,7 +12,7 @@ - + diff --git a/JetMETCorrections/TauJet/plugins/BuildFile.xml b/JetMETCorrections/TauJet/plugins/BuildFile.xml index 16311eea57882..b0e1da313a10a 100644 --- a/JetMETCorrections/TauJet/plugins/BuildFile.xml +++ b/JetMETCorrections/TauJet/plugins/BuildFile.xml @@ -5,7 +5,7 @@ - + diff --git a/L1Trigger/DTBti/BuildFile.xml b/L1Trigger/DTBti/BuildFile.xml index 15dadf599c207..5ecb4b75b0814 100644 --- a/L1Trigger/DTBti/BuildFile.xml +++ b/L1Trigger/DTBti/BuildFile.xml @@ -9,7 +9,7 @@ - + diff --git a/L1Trigger/DTSectorCollector/BuildFile.xml b/L1Trigger/DTSectorCollector/BuildFile.xml index ab72e5f7ff4f0..91c2252023078 100644 --- a/L1Trigger/DTSectorCollector/BuildFile.xml +++ b/L1Trigger/DTSectorCollector/BuildFile.xml @@ -9,7 +9,7 @@ - + diff --git a/L1Trigger/DTTraco/BuildFile.xml b/L1Trigger/DTTraco/BuildFile.xml index 698ffb9425a89..96633ff9a4a73 100644 --- a/L1Trigger/DTTraco/BuildFile.xml +++ b/L1Trigger/DTTraco/BuildFile.xml @@ -7,7 +7,7 @@ - + diff --git a/L1Trigger/DTTrigger/BuildFile.xml b/L1Trigger/DTTrigger/BuildFile.xml index 4ffc3d4a27f06..dbafe39713a23 100644 --- a/L1Trigger/DTTrigger/BuildFile.xml +++ b/L1Trigger/DTTrigger/BuildFile.xml @@ -15,5 +15,5 @@ - + diff --git a/L1Trigger/DTTriggerServerPhi/BuildFile.xml b/L1Trigger/DTTriggerServerPhi/BuildFile.xml index e02cb81df8843..9567f231a529f 100644 --- a/L1Trigger/DTTriggerServerPhi/BuildFile.xml +++ b/L1Trigger/DTTriggerServerPhi/BuildFile.xml @@ -6,7 +6,7 @@ - + diff --git a/L1Trigger/DTTriggerServerTheta/BuildFile.xml b/L1Trigger/DTTriggerServerTheta/BuildFile.xml index cad3b9582e5ea..0ec6c316b7620 100644 --- a/L1Trigger/DTTriggerServerTheta/BuildFile.xml +++ b/L1Trigger/DTTriggerServerTheta/BuildFile.xml @@ -6,7 +6,7 @@ - + diff --git a/L1Trigger/DTUtilities/BuildFile.xml b/L1Trigger/DTUtilities/BuildFile.xml index ed152fb0291b1..7357d1a9ba067 100644 --- a/L1Trigger/DTUtilities/BuildFile.xml +++ b/L1Trigger/DTUtilities/BuildFile.xml @@ -5,7 +5,7 @@ - + diff --git a/L1TriggerConfig/DTTPGConfig/BuildFile.xml b/L1TriggerConfig/DTTPGConfig/BuildFile.xml index ea6d51971bde7..a61db7425788c 100644 --- a/L1TriggerConfig/DTTPGConfig/BuildFile.xml +++ b/L1TriggerConfig/DTTPGConfig/BuildFile.xml @@ -3,7 +3,7 @@ - + diff --git a/L1TriggerConfig/DTTPGConfigProducers/BuildFile.xml b/L1TriggerConfig/DTTPGConfigProducers/BuildFile.xml index 8d46115507eaf..765b9dc3d1a06 100644 --- a/L1TriggerConfig/DTTPGConfigProducers/BuildFile.xml +++ b/L1TriggerConfig/DTTPGConfigProducers/BuildFile.xml @@ -14,6 +14,6 @@ - + diff --git a/MuonAnalysis/MomentumScaleCalibration/BuildFile.xml b/MuonAnalysis/MomentumScaleCalibration/BuildFile.xml index f406809d5349c..fb85ab56c07fa 100644 --- a/MuonAnalysis/MomentumScaleCalibration/BuildFile.xml +++ b/MuonAnalysis/MomentumScaleCalibration/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/PhysicsTools/Heppy/BuildFile.xml b/PhysicsTools/Heppy/BuildFile.xml index 94d4340b0cfa4..e1b45024eaf3f 100644 --- a/PhysicsTools/Heppy/BuildFile.xml +++ b/PhysicsTools/Heppy/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/PhysicsTools/HeppyCore/BuildFile.xml b/PhysicsTools/HeppyCore/BuildFile.xml index d624f3c1d2f28..b72f127aeeada 100644 --- a/PhysicsTools/HeppyCore/BuildFile.xml +++ b/PhysicsTools/HeppyCore/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/PhysicsTools/JetMCUtils/BuildFile.xml b/PhysicsTools/JetMCUtils/BuildFile.xml index 836576bfcd5f8..90a2435260c42 100644 --- a/PhysicsTools/JetMCUtils/BuildFile.xml +++ b/PhysicsTools/JetMCUtils/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/PhysicsTools/ParallelAnalysis/BuildFile.xml b/PhysicsTools/ParallelAnalysis/BuildFile.xml index 96e5cc568cc32..595bc61d063e7 100644 --- a/PhysicsTools/ParallelAnalysis/BuildFile.xml +++ b/PhysicsTools/ParallelAnalysis/BuildFile.xml @@ -4,7 +4,7 @@ - + diff --git a/PhysicsTools/SelectorUtils/BuildFile.xml b/PhysicsTools/SelectorUtils/BuildFile.xml index eb9a779129b8d..798751bdf601f 100644 --- a/PhysicsTools/SelectorUtils/BuildFile.xml +++ b/PhysicsTools/SelectorUtils/BuildFile.xml @@ -13,7 +13,7 @@ - + diff --git a/PhysicsTools/Utilities/BuildFile.xml b/PhysicsTools/Utilities/BuildFile.xml index ad0701a34cc2f..1f54829c15d08 100644 --- a/PhysicsTools/Utilities/BuildFile.xml +++ b/PhysicsTools/Utilities/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/RecoBTag/ImpactParameter/test/BuildFile.xml b/RecoBTag/ImpactParameter/test/BuildFile.xml index 0f66b54ca1b8e..cadcdb00201bf 100644 --- a/RecoBTag/ImpactParameter/test/BuildFile.xml +++ b/RecoBTag/ImpactParameter/test/BuildFile.xml @@ -1,4 +1,4 @@ - + diff --git a/RecoEgamma/ElectronIdentification/BuildFile.xml b/RecoEgamma/ElectronIdentification/BuildFile.xml index fca2e0716fbb4..9af0f9ecbdd2d 100644 --- a/RecoEgamma/ElectronIdentification/BuildFile.xml +++ b/RecoEgamma/ElectronIdentification/BuildFile.xml @@ -7,7 +7,7 @@ - + diff --git a/RecoHI/HiCentralityAlgos/BuildFile.xml b/RecoHI/HiCentralityAlgos/BuildFile.xml index 7ad78a3cb1438..d035747489468 100644 --- a/RecoHI/HiCentralityAlgos/BuildFile.xml +++ b/RecoHI/HiCentralityAlgos/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/RecoHI/HiEvtPlaneAlgos/BuildFile.xml b/RecoHI/HiEvtPlaneAlgos/BuildFile.xml index 2070776de1f4c..072bb484df156 100644 --- a/RecoHI/HiEvtPlaneAlgos/BuildFile.xml +++ b/RecoHI/HiEvtPlaneAlgos/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/RecoHI/HiMuonAlgos/BuildFile.xml b/RecoHI/HiMuonAlgos/BuildFile.xml index 976db47b4f02d..8314446a80c1b 100644 --- a/RecoHI/HiMuonAlgos/BuildFile.xml +++ b/RecoHI/HiMuonAlgos/BuildFile.xml @@ -23,7 +23,7 @@ - + diff --git a/RecoHI/HiMuonAlgos/plugins/BuildFile.xml b/RecoHI/HiMuonAlgos/plugins/BuildFile.xml index 108988b5406d3..6f262afb3d42c 100644 --- a/RecoHI/HiMuonAlgos/plugins/BuildFile.xml +++ b/RecoHI/HiMuonAlgos/plugins/BuildFile.xml @@ -1,5 +1,5 @@ - + diff --git a/RecoJets/FFTJetAlgorithms/BuildFile.xml b/RecoJets/FFTJetAlgorithms/BuildFile.xml index 1337ade5f8025..21b00856f6f04 100644 --- a/RecoJets/FFTJetAlgorithms/BuildFile.xml +++ b/RecoJets/FFTJetAlgorithms/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/RecoParticleFlow/PFClusterTools/BuildFile.xml b/RecoParticleFlow/PFClusterTools/BuildFile.xml index 1d217bc046f27..c21137bea2760 100644 --- a/RecoParticleFlow/PFClusterTools/BuildFile.xml +++ b/RecoParticleFlow/PFClusterTools/BuildFile.xml @@ -4,7 +4,7 @@ - + diff --git a/RecoRomanPot/RecoFP420/BuildFile.xml b/RecoRomanPot/RecoFP420/BuildFile.xml index 218c2afcf4348..6403acd578964 100644 --- a/RecoRomanPot/RecoFP420/BuildFile.xml +++ b/RecoRomanPot/RecoFP420/BuildFile.xml @@ -15,7 +15,7 @@ - + diff --git a/RecoTauTag/ImpactParameter/BuildFile.xml b/RecoTauTag/ImpactParameter/BuildFile.xml index abdae33bc77a7..6a806113cf774 100644 --- a/RecoTauTag/ImpactParameter/BuildFile.xml +++ b/RecoTauTag/ImpactParameter/BuildFile.xml @@ -5,7 +5,7 @@ - + diff --git a/RecoTauTag/ImpactParameter/plugins/BuildFile.xml b/RecoTauTag/ImpactParameter/plugins/BuildFile.xml index 5d3ba8c33c423..2c1fbd19de92a 100644 --- a/RecoTauTag/ImpactParameter/plugins/BuildFile.xml +++ b/RecoTauTag/ImpactParameter/plugins/BuildFile.xml @@ -5,7 +5,7 @@ - + diff --git a/RecoTracker/MeasurementDet/BuildFile.xml b/RecoTracker/MeasurementDet/BuildFile.xml index 1377ca14e49b1..6b1ded6d6e539 100644 --- a/RecoTracker/MeasurementDet/BuildFile.xml +++ b/RecoTracker/MeasurementDet/BuildFile.xml @@ -23,4 +23,4 @@ - + diff --git a/RecoTracker/NuclearSeedGenerator/BuildFile.xml b/RecoTracker/NuclearSeedGenerator/BuildFile.xml index f9fce6b53bc60..2f64410d16e7b 100644 --- a/RecoTracker/NuclearSeedGenerator/BuildFile.xml +++ b/RecoTracker/NuclearSeedGenerator/BuildFile.xml @@ -22,7 +22,7 @@ - + diff --git a/RecoTracker/TkSeedGenerator/BuildFile.xml b/RecoTracker/TkSeedGenerator/BuildFile.xml index 766957670ce0d..8ac61a7cd166f 100644 --- a/RecoTracker/TkSeedGenerator/BuildFile.xml +++ b/RecoTracker/TkSeedGenerator/BuildFile.xml @@ -18,7 +18,7 @@ - + diff --git a/RecoVertex/BeamSpotProducer/plugins/BuildFile.xml b/RecoVertex/BeamSpotProducer/plugins/BuildFile.xml index c0636fb8ae67e..06a58f25016c0 100644 --- a/RecoVertex/BeamSpotProducer/plugins/BuildFile.xml +++ b/RecoVertex/BeamSpotProducer/plugins/BuildFile.xml @@ -8,7 +8,7 @@ - + diff --git a/RecoVertex/BeamSpotProducer/test/BuildFile.xml b/RecoVertex/BeamSpotProducer/test/BuildFile.xml index b2467a1af73aa..72a4d83fb3719 100644 --- a/RecoVertex/BeamSpotProducer/test/BuildFile.xml +++ b/RecoVertex/BeamSpotProducer/test/BuildFile.xml @@ -7,7 +7,7 @@ - + diff --git a/SimDataFormats/CaloHit/BuildFile.xml b/SimDataFormats/CaloHit/BuildFile.xml index ae4a7a160ac9a..6c1a072c7e4a6 100644 --- a/SimDataFormats/CaloHit/BuildFile.xml +++ b/SimDataFormats/CaloHit/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/SimDataFormats/CaloTest/BuildFile.xml b/SimDataFormats/CaloTest/BuildFile.xml index 9fe995de2608a..4068b7b84d0d5 100644 --- a/SimDataFormats/CaloTest/BuildFile.xml +++ b/SimDataFormats/CaloTest/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/SimDataFormats/CrossingFrame/BuildFile.xml b/SimDataFormats/CrossingFrame/BuildFile.xml index 5120243f2f297..a732b7eeed9dc 100644 --- a/SimDataFormats/CrossingFrame/BuildFile.xml +++ b/SimDataFormats/CrossingFrame/BuildFile.xml @@ -9,7 +9,7 @@ - + diff --git a/SimDataFormats/DigiSimLinks/BuildFile.xml b/SimDataFormats/DigiSimLinks/BuildFile.xml index 29b0588b076fe..1d4330189da67 100644 --- a/SimDataFormats/DigiSimLinks/BuildFile.xml +++ b/SimDataFormats/DigiSimLinks/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/SimDataFormats/EcalTestBeam/BuildFile.xml b/SimDataFormats/EcalTestBeam/BuildFile.xml index 6f1b836c4cb99..8ee440dd3aeb6 100644 --- a/SimDataFormats/EcalTestBeam/BuildFile.xml +++ b/SimDataFormats/EcalTestBeam/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/SimDataFormats/EncodedEventId/BuildFile.xml b/SimDataFormats/EncodedEventId/BuildFile.xml index bdd134e67a1cb..f9c00311052f4 100644 --- a/SimDataFormats/EncodedEventId/BuildFile.xml +++ b/SimDataFormats/EncodedEventId/BuildFile.xml @@ -1,6 +1,7 @@ + diff --git a/SimDataFormats/Forward/BuildFile.xml b/SimDataFormats/Forward/BuildFile.xml index a71af06193909..28f9d1ce652a7 100644 --- a/SimDataFormats/Forward/BuildFile.xml +++ b/SimDataFormats/Forward/BuildFile.xml @@ -3,4 +3,4 @@ - + diff --git a/SimDataFormats/GeneratorProducts/BuildFile.xml b/SimDataFormats/GeneratorProducts/BuildFile.xml index e722e262a6157..d574a423eba08 100644 --- a/SimDataFormats/GeneratorProducts/BuildFile.xml +++ b/SimDataFormats/GeneratorProducts/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/SimDataFormats/HcalTestBeam/BuildFile.xml b/SimDataFormats/HcalTestBeam/BuildFile.xml index 5ea55e13ebc90..373b8541f9ce2 100644 --- a/SimDataFormats/HcalTestBeam/BuildFile.xml +++ b/SimDataFormats/HcalTestBeam/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/SimDataFormats/HiGenData/BuildFile.xml b/SimDataFormats/HiGenData/BuildFile.xml index e4c8b76582bc5..ee81090c0c7b7 100644 --- a/SimDataFormats/HiGenData/BuildFile.xml +++ b/SimDataFormats/HiGenData/BuildFile.xml @@ -1,4 +1,4 @@ - + diff --git a/SimDataFormats/JetMatching/BuildFile.xml b/SimDataFormats/JetMatching/BuildFile.xml index bff612d5e31a8..e8f59b102cdff 100644 --- a/SimDataFormats/JetMatching/BuildFile.xml +++ b/SimDataFormats/JetMatching/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/SimDataFormats/PileupSummaryInfo/BuildFile.xml b/SimDataFormats/PileupSummaryInfo/BuildFile.xml index 820d1ce2cd151..6fb1635a4b253 100644 --- a/SimDataFormats/PileupSummaryInfo/BuildFile.xml +++ b/SimDataFormats/PileupSummaryInfo/BuildFile.xml @@ -3,7 +3,7 @@ - + diff --git a/SimDataFormats/RPCDigiSimLink/BuildFile.xml b/SimDataFormats/RPCDigiSimLink/BuildFile.xml index 8e8dd42c6de15..a5783d9e04a99 100644 --- a/SimDataFormats/RPCDigiSimLink/BuildFile.xml +++ b/SimDataFormats/RPCDigiSimLink/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/SimDataFormats/RandomEngine/BuildFile.xml b/SimDataFormats/RandomEngine/BuildFile.xml index bcbf5e0f057c6..d678f70f416ab 100644 --- a/SimDataFormats/RandomEngine/BuildFile.xml +++ b/SimDataFormats/RandomEngine/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/SimDataFormats/Track/BuildFile.xml b/SimDataFormats/Track/BuildFile.xml index ce5cf540d0bf3..27df3b9f658f4 100644 --- a/SimDataFormats/Track/BuildFile.xml +++ b/SimDataFormats/Track/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/SimDataFormats/TrackerDigiSimLink/BuildFile.xml b/SimDataFormats/TrackerDigiSimLink/BuildFile.xml index ae4a7a160ac9a..6c1a072c7e4a6 100644 --- a/SimDataFormats/TrackerDigiSimLink/BuildFile.xml +++ b/SimDataFormats/TrackerDigiSimLink/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/SimDataFormats/TrackingAnalysis/BuildFile.xml b/SimDataFormats/TrackingAnalysis/BuildFile.xml index 083afbf6df7df..4876187dd2b6e 100644 --- a/SimDataFormats/TrackingAnalysis/BuildFile.xml +++ b/SimDataFormats/TrackingAnalysis/BuildFile.xml @@ -7,7 +7,7 @@ - + diff --git a/SimDataFormats/TrackingHit/BuildFile.xml b/SimDataFormats/TrackingHit/BuildFile.xml index e66284c535b60..c854a1dafdddc 100644 --- a/SimDataFormats/TrackingHit/BuildFile.xml +++ b/SimDataFormats/TrackingHit/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/SimDataFormats/ValidationFormats/BuildFile.xml b/SimDataFormats/ValidationFormats/BuildFile.xml index 19def4b03e3ca..e23d41ae0e505 100644 --- a/SimDataFormats/ValidationFormats/BuildFile.xml +++ b/SimDataFormats/ValidationFormats/BuildFile.xml @@ -2,7 +2,7 @@ - + diff --git a/SimDataFormats/Vertex/BuildFile.xml b/SimDataFormats/Vertex/BuildFile.xml index ce5cf540d0bf3..27df3b9f658f4 100644 --- a/SimDataFormats/Vertex/BuildFile.xml +++ b/SimDataFormats/Vertex/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/SimG4CMS/Calo/BuildFile.xml b/SimG4CMS/Calo/BuildFile.xml index 87e782dc5b476..459bb63f8f566 100644 --- a/SimG4CMS/Calo/BuildFile.xml +++ b/SimG4CMS/Calo/BuildFile.xml @@ -21,7 +21,7 @@ - + diff --git a/SimG4Core/Application/BuildFile.xml b/SimG4Core/Application/BuildFile.xml index 78fc6107786cc..0628fc82e07b1 100644 --- a/SimG4Core/Application/BuildFile.xml +++ b/SimG4Core/Application/BuildFile.xml @@ -24,7 +24,7 @@ - + diff --git a/SimMuon/GEMDigitizer/BuildFile.xml b/SimMuon/GEMDigitizer/BuildFile.xml index 185595e7c4985..23b4faa7b4ccd 100644 --- a/SimMuon/GEMDigitizer/BuildFile.xml +++ b/SimMuon/GEMDigitizer/BuildFile.xml @@ -23,7 +23,7 @@ - + diff --git a/SimMuon/MCTruth/BuildFile.xml b/SimMuon/MCTruth/BuildFile.xml index 63e4bbd70ac22..158770ee8c1fc 100644 --- a/SimMuon/MCTruth/BuildFile.xml +++ b/SimMuon/MCTruth/BuildFile.xml @@ -27,7 +27,7 @@ - + diff --git a/SimMuon/RPCDigitizer/BuildFile.xml b/SimMuon/RPCDigitizer/BuildFile.xml index 03b10ff0758dc..3cb1ee3e23a60 100644 --- a/SimMuon/RPCDigitizer/BuildFile.xml +++ b/SimMuon/RPCDigitizer/BuildFile.xml @@ -23,7 +23,7 @@ - + diff --git a/SimTracker/TrackAssociation/BuildFile.xml b/SimTracker/TrackAssociation/BuildFile.xml index b62736612d587..3f8e84c3883ac 100644 --- a/SimTracker/TrackAssociation/BuildFile.xml +++ b/SimTracker/TrackAssociation/BuildFile.xml @@ -21,7 +21,7 @@ - + diff --git a/TBDataFormats/EcalTBObjects/BuildFile.xml b/TBDataFormats/EcalTBObjects/BuildFile.xml index 77cacb8a92001..10056d6a57065 100644 --- a/TBDataFormats/EcalTBObjects/BuildFile.xml +++ b/TBDataFormats/EcalTBObjects/BuildFile.xml @@ -1,7 +1,7 @@ - + diff --git a/TBDataFormats/HcalTBObjects/BuildFile.xml b/TBDataFormats/HcalTBObjects/BuildFile.xml index 58a30006bd9e6..2534ed9f7c507 100644 --- a/TBDataFormats/HcalTBObjects/BuildFile.xml +++ b/TBDataFormats/HcalTBObjects/BuildFile.xml @@ -1,6 +1,6 @@ - + diff --git a/TrackingTools/PatternTools/BuildFile.xml b/TrackingTools/PatternTools/BuildFile.xml index 05ad6fe641029..abaadfaa2ef8f 100644 --- a/TrackingTools/PatternTools/BuildFile.xml +++ b/TrackingTools/PatternTools/BuildFile.xml @@ -11,7 +11,7 @@ - + diff --git a/TrackingTools/TrajectoryState/BuildFile.xml b/TrackingTools/TrajectoryState/BuildFile.xml index 22522671389fc..bf2532c1a57ef 100644 --- a/TrackingTools/TrajectoryState/BuildFile.xml +++ b/TrackingTools/TrajectoryState/BuildFile.xml @@ -9,7 +9,7 @@ - + diff --git a/Validation/RecoParticleFlow/BuildFile.xml b/Validation/RecoParticleFlow/BuildFile.xml index d2570f854309a..84588ea64cb42 100644 --- a/Validation/RecoParticleFlow/BuildFile.xml +++ b/Validation/RecoParticleFlow/BuildFile.xml @@ -2,6 +2,7 @@ + From c7726636159ee044aab312e616ed02b04e9816e1 Mon Sep 17 00:00:00 2001 From: Giulio Eulisse Date: Thu, 5 Mar 2015 17:13:54 +0100 Subject: [PATCH 22/22] Add extra dictionaries as requested by ROOT6. --- DataFormats/HcalDigi/src/classes_def.xml | 13 +++++++++++++ DataFormats/HcalRecHit/src/classes_def.xml | 8 ++++++++ 2 files changed, 21 insertions(+) diff --git a/DataFormats/HcalDigi/src/classes_def.xml b/DataFormats/HcalDigi/src/classes_def.xml index 1bd2212579cee..c6f9614ec67f8 100644 --- a/DataFormats/HcalDigi/src/classes_def.xml +++ b/DataFormats/HcalDigi/src/classes_def.xml @@ -74,6 +74,19 @@ + + + + + + + + + + + + + diff --git a/DataFormats/HcalRecHit/src/classes_def.xml b/DataFormats/HcalRecHit/src/classes_def.xml index b53f2bac5933b..9bad8c1e61b06 100644 --- a/DataFormats/HcalRecHit/src/classes_def.xml +++ b/DataFormats/HcalRecHit/src/classes_def.xml @@ -41,6 +41,14 @@ + + + + + + + +