diff --git a/CondCore/EcalPlugins/plugins/EcalPedestals_PayloadInspector.cc b/CondCore/EcalPlugins/plugins/EcalPedestals_PayloadInspector.cc index 1c80115f7e322..6341eceeec2ed 100644 --- a/CondCore/EcalPlugins/plugins/EcalPedestals_PayloadInspector.cc +++ b/CondCore/EcalPlugins/plugins/EcalPedestals_PayloadInspector.cc @@ -486,7 +486,7 @@ namespace { l_tagname[1] = l_tagname[0]; } run[1] = std::get<0>(lastiov); - for (int irun = 0; irun < nIOVs; irun++) { + for (int irun = 0; irun < 2; irun++) { std::shared_ptr payload; if (irun == 0) { payload = this->fetchPayload(std::get<1>(firstiov)); @@ -606,7 +606,7 @@ namespace { } } // loop over cellid } // barrel data present - if (payload->endcapItems().empty()) { + if (!payload->endcapItems().empty()) { // looping over the EE channels for (int iz = -1; iz < 2; iz = iz + 2) { // -1 or +1 for (int iy = IY_MIN; iy < IY_MAX + IY_MIN; iy++) { @@ -824,9 +824,9 @@ namespace { return true; } // fill method }; // class EcalPedestalsBase - using EcalPedestalsDiffOneTag = EcalPedestalsBase; + using EcalPedestalsDiffOneTag = EcalPedestalsBase; using EcalPedestalsDiffTwoTags = EcalPedestalsBase; - using EcalPedestalsRatioOneTag = EcalPedestalsBase; + using EcalPedestalsRatioOneTag = EcalPedestalsBase; using EcalPedestalsRatioTwoTags = EcalPedestalsBase; /************************************************* diff --git a/CondTools/RunInfo/interface/LHCInfoPerFillPopConSourceHandler.h b/CondTools/RunInfo/interface/LHCInfoPerFillPopConSourceHandler.h index 9a0a5185258fc..12af8d63dcc11 100644 --- a/CondTools/RunInfo/interface/LHCInfoPerFillPopConSourceHandler.h +++ b/CondTools/RunInfo/interface/LHCInfoPerFillPopConSourceHandler.h @@ -1,3 +1,5 @@ +#pragma once + #include "CondCore/PopCon/interface/PopConSourceHandler.h" #include "CondFormats/RunInfo/interface/LHCInfoPerFill.h" #include "CondTools/RunInfo/interface/OMSAccess.h" @@ -11,31 +13,64 @@ class LHCInfoPerFillPopConSourceHandler : public popcon::PopConSourceHandler findFillToProcess(cond::OMSService& oms, + const boost::posix_time::ptime& nextFillSearchTime, + bool inclusiveSearchTime); void addEmptyPayload(cond::Time_t iov); // Add payload to buffer and store corresponding lumiid IOV in m_timestampToLumiid map void addPayloadToBuffer(cond::OMSServiceResultRef& row); void convertBufferedIovsToLumiid(std::map timestampToLumiid); - size_t getLumiData(const cond::OMSService& oms, - unsigned short fillId, - const boost::posix_time::ptime& beginFillTime, - const boost::posix_time::ptime& endFillTime); + /** + * @return A tuple containing: + * - cond::OMSServiceResult: The result of the luminosity query. + * - bool: Indicates whether the query was successful. + * - std::unique_ptr: Owner object for the query. + * Query result resources are tied to its lifetime so it needs to be kept in the same scope. + */ + virtual std::tuple> executeLumiQuery( + const cond::OMSService& oms, + unsigned short fillId, + const boost::posix_time::ptime& beginFillTime, + const boost::posix_time::ptime& endFillTime) const; + + virtual void getLumiData(const cond::OMSService& oms, + unsigned short fillId, + const boost::posix_time::ptime& beginFillTime, + const boost::posix_time::ptime& endFillTime); + + virtual void getDipData(const cond::OMSService& oms, + const boost::posix_time::ptime& beginFillTime, + const boost::posix_time::ptime& endFillTime); - void getDipData(const cond::OMSService& oms, - const boost::posix_time::ptime& beginFillTime, - const boost::posix_time::ptime& endFillTime); + virtual bool getCTPPSData(cond::persistency::Session& session, + const boost::posix_time::ptime& beginFillTime, + const boost::posix_time::ptime& endFillTime); - bool getCTPPSData(cond::persistency::Session& session, - const boost::posix_time::ptime& beginFillTime, - const boost::posix_time::ptime& endFillTime); + virtual bool getEcalData(cond::persistency::Session& session, + const boost::posix_time::ptime& lowerTime, + const boost::posix_time::ptime& upperTime); - bool getEcalData(cond::persistency::Session& session, - const boost::posix_time::ptime& lowerTime, - const boost::posix_time::ptime& upperTime); + bool getCTPPSDataImpl(cond::persistency::Session& session, + const boost::posix_time::ptime& beginFillTime, + const boost::posix_time::ptime& endFillTime); -private: + bool getEcalDataImpl(cond::persistency::Session& session, + const boost::posix_time::ptime& lowerTime, + const boost::posix_time::ptime& upperTime); + +protected: + virtual std::tuple createSubsystemDbSessions() const; + virtual cond::Time_t getNextFillSearchTimestamp(cond::Time_t lastSince) const; + virtual cond::Time_t handleIfNewTagAndGetLastSince(); + virtual void fetchLastPayload(); + virtual boost::posix_time::ptime getExecutionTime() const; + void populateIovs(); + void handleInvalidPayloads(); bool m_debug; // starting date for sampling boost::posix_time::ptime m_startTime; @@ -46,6 +81,11 @@ class LHCInfoPerFillPopConSourceHandler : public popcon::PopConSourceHandler m_fillPayload; std::shared_ptr m_prevPayload; std::vector>> m_tmpBuffer; diff --git a/CondTools/RunInfo/interface/LHCInfoPerLSPopConSourceHandler.h b/CondTools/RunInfo/interface/LHCInfoPerLSPopConSourceHandler.h index 0578663626030..c0c87f640b02c 100644 --- a/CondTools/RunInfo/interface/LHCInfoPerLSPopConSourceHandler.h +++ b/CondTools/RunInfo/interface/LHCInfoPerLSPopConSourceHandler.h @@ -20,7 +20,7 @@ class LHCInfoPerLSPopConSourceHandler : public popcon::PopConSourceHandler m_fillPayload; std::shared_ptr m_prevPayload; - cond::Time_t m_startFillTime; - cond::Time_t m_endFillTime; - cond::Time_t m_prevEndFillTime = 0; - cond::Time_t m_prevStartFillTime; - cond::Time_t m_startStableBeamTime; - cond::Time_t m_endStableBeamTime; + cond::Time_t m_startFillTime{}; + cond::Time_t m_endFillTime{}; + cond::Time_t m_prevEndFillTime{}; + cond::Time_t m_prevStartFillTime{}; + cond::Time_t m_startStableBeamTime{}; + cond::Time_t m_endStableBeamTime{}; std::vector>> m_tmpBuffer; bool m_lastPayloadEmpty = false; // mapping of lumisections IDs (pairs of runnumber an LS number) found in OMS to diff --git a/CondTools/RunInfo/interface/TestLHCInfoPerFillPopConSourceHandler.h b/CondTools/RunInfo/interface/TestLHCInfoPerFillPopConSourceHandler.h new file mode 100644 index 0000000000000..49b0905ae90aa --- /dev/null +++ b/CondTools/RunInfo/interface/TestLHCInfoPerFillPopConSourceHandler.h @@ -0,0 +1,63 @@ +#pragma once + +#include "CondFormats/RunInfo/interface/LHCInfoPerFill.h" +#include "CondTools/RunInfo/interface/LHCInfoPerFillPopConSourceHandler.h" +#include "CondTools/RunInfo/interface/OMSAccess.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include +#include +#include +#include + +/* +* A mock PopCon source handler for testing LHCInfoPerFillPopCon logic without +* external dependencies (e.g. OMS, subsystem DBs, destination DB). +*/ + +class TestLHCInfoPerFillPopConSourceHandler : public LHCInfoPerFillPopConSourceHandler { +public: + TestLHCInfoPerFillPopConSourceHandler(edm::ParameterSet const& pset); + ~TestLHCInfoPerFillPopConSourceHandler() override = default; + + std::vector>> mockOmsFills; + std::map mockLumiData; + boost::posix_time::ptime mockExecutionTime; + + const Container& iovs() const { return m_iovs; } + +protected: + std::unique_ptr findFillToProcess(cond::OMSService& oms, + const boost::posix_time::ptime& nextFillSearchTime, + bool inclusiveSearchTime) override; + + cond::Time_t handleIfNewTagAndGetLastSince() override; + + void fetchLastPayload() override {}; + + boost::posix_time::ptime getExecutionTime() const override; + + std::tuple createSubsystemDbSessions() const override; + + void getDipData(const cond::OMSService& oms, + const boost::posix_time::ptime& beginFillTime, + const boost::posix_time::ptime& endFillTime) override {}; + + bool getCTPPSData(cond::persistency::Session& session, + const boost::posix_time::ptime& beginFillTime, + const boost::posix_time::ptime& endFillTime) override { + return true; + }; + + bool getEcalData(cond::persistency::Session& session, + const boost::posix_time::ptime& lowerTime, + const boost::posix_time::ptime& upperTime) override { + return true; + }; + + std::tuple> executeLumiQuery( + const cond::OMSService& oms, + unsigned short fillId, + const boost::posix_time::ptime& beginFillTime, + const boost::posix_time::ptime& endFillTime) const override; +}; diff --git a/CondTools/RunInfo/python/LHCInfoPerFillPopConAnalyzer_cfg.py b/CondTools/RunInfo/python/LHCInfoPerFillPopConAnalyzer_cfg.py index 22406260f051a..42eb9b7dea685 100644 --- a/CondTools/RunInfo/python/LHCInfoPerFillPopConAnalyzer_cfg.py +++ b/CondTools/RunInfo/python/LHCInfoPerFillPopConAnalyzer_cfg.py @@ -91,7 +91,19 @@ , """duringFill only: run-unique key for writing with OnlinePopCon (used for confirming proper upload)""" ) - +# checking for invalid energy values, duringFill mode specific +options.register('minEnergy', 450 + , VarParsing.VarParsing.multiplicity.singleton, VarParsing.VarParsing.varType.float + , """duringFill only: [GeV] min value of the range of valid values (inclusive). + If the value is outside of this range the payload is not uploaded""") +options.register('maxEnergy', 8000. + , VarParsing.VarParsing.multiplicity.singleton, VarParsing.VarParsing.varType.float + , """duringFill only: [GeV] max value of the range of valid values (inclusive). + If the value is outside of this range the payload is not uploaded""") +options.register('throwOnInvalid', False, # Intended production setup: False for endFill, True for duringFill + VarParsing.VarParsing.multiplicity.singleton, + VarParsing.VarParsing.varType.bool, + "duringFill only: If true, throw on invalid payloads; if false, filter them out.") # so far there was no need to use option, added just in case options.register( 'authenticationPath' @@ -106,6 +118,8 @@ raise ValueError("mode argument not provided. Supported modes are: duringFill endFill") if options.mode not in ("duringFill", "endFill"): raise ValueError("Wrong mode argument. Supported modes are: duringFill endFill") +if options.throwOnInvalid and options.mode != "duringFill": + raise ValueError("throwOnInvalid option can be True only in duringFill mode") CondDBConnection = CondDB.clone( connect = cms.string( options.destinationConnection ) ) CondDBConnection.DBParameters.messageLevel = cms.untracked.int32( options.messageLevel ) @@ -173,7 +187,10 @@ ecalConnectionString = cms.untracked.string(options.ecalConnection), omsBaseUrl = cms.untracked.string(options.oms), authenticationPath = cms.untracked.string(options.authenticationPath), - debug=cms.untracked.bool(False) + debug=cms.untracked.bool(False), + minEnergy = cms.untracked.double(options.minEnergy), + maxEnergy = cms.untracked.double(options.maxEnergy), + throwOnInvalid = cms.untracked.bool(options.throwOnInvalid) ), loggingOn = cms.untracked.bool(True), IsDestDbCheckedInQueryLog = cms.untracked.bool(False) diff --git a/CondTools/RunInfo/python/LHCInfoPerLSPopConAnalyzer_cfg.py b/CondTools/RunInfo/python/LHCInfoPerLSPopConAnalyzer_cfg.py index a58598f1d3ef1..5b7efdaf104b1 100644 --- a/CondTools/RunInfo/python/LHCInfoPerLSPopConAnalyzer_cfg.py +++ b/CondTools/RunInfo/python/LHCInfoPerLSPopConAnalyzer_cfg.py @@ -131,25 +131,28 @@ The default payload is inserted after the last processed fill has ended and there's no ongoing stable beam yet. """ ) - - +# checking for invalid values, duringFill mode specific # it's unlikely to ever use values different from the defaults, added as a parameter just in case options.register('minBetaStar', 0.1 , VarParsing.VarParsing.multiplicity.singleton, VarParsing.VarParsing.varType.float - , """duringFill only: [meters] min value of the range of valid values. + , """duringFill only: [meters] min value of the range of valid values (inclusive). If the value is outside of this range the payload is not uploaded""") options.register('maxBetaStar', 100. , VarParsing.VarParsing.multiplicity.singleton, VarParsing.VarParsing.varType.float - , """duringFill only: [meters] min value of the range of valid values. + , """duringFill only: [meters] max value of the range of valid values (inclusive). If the value is outside of this range the payload is not uploaded""") options.register('minCrossingAngle', 10. , VarParsing.VarParsing.multiplicity.singleton, VarParsing.VarParsing.varType.float - , """duringFill only: [urad] min value of the range of valid values. + , """duringFill only: [urad] min value of the range of valid values (inclusive). If the value is outside of this range the payload is not uploaded""") options.register('maxCrossingAngle', 500. , VarParsing.VarParsing.multiplicity.singleton, VarParsing.VarParsing.varType.float - , """duringFill only: [urad] min value of the range of valid values. + , """duringFill only: [urad] max value of the range of valid values (inclusive). If the value is outside of this range the payload is not uploaded""") +options.register('throwOnInvalid', False, # Intended production setup: False for endFill, True for duringFill + VarParsing.VarParsing.multiplicity.singleton, + VarParsing.VarParsing.varType.bool, + "duringFill only: If true, throw on invalid payloads; if false, filter them out.") # as the previous options, so far there was no need to use option, added just in case options.register( 'authenticationPath' @@ -164,6 +167,8 @@ raise ValueError("mode argument not provided. Supported modes are: duringFill endFill") if options.mode not in ("duringFill", "endFill"): raise ValueError("Wrong mode argument. Supported modes are: duringFill endFill") +if options.throwOnInvalid and options.mode != "duringFill": + raise ValueError("throwOnInvalid option can be True only in duringFill mode") CondDBConnection = CondDB.clone( connect = cms.string( options.destinationConnection ) ) CondDBConnection.DBParameters.messageLevel = cms.untracked.int32( options.messageLevel ) @@ -241,6 +246,7 @@ maxBetaStar = cms.untracked.double(options.maxBetaStar), minCrossingAngle = cms.untracked.double(options.minCrossingAngle), maxCrossingAngle = cms.untracked.double(options.maxCrossingAngle), + throwOnInvalid = cms.untracked.bool(options.throwOnInvalid) ), loggingOn = cms.untracked.bool(True), IsDestDbCheckedInQueryLog = cms.untracked.bool(False) diff --git a/CondTools/RunInfo/src/LHCInfoPerFillPopConSourceHandler.cc b/CondTools/RunInfo/src/LHCInfoPerFillPopConSourceHandler.cc index 84f3406d7b574..e2667d25baa28 100644 --- a/CondTools/RunInfo/src/LHCInfoPerFillPopConSourceHandler.cc +++ b/CondTools/RunInfo/src/LHCInfoPerFillPopConSourceHandler.cc @@ -108,6 +108,13 @@ namespace theLHCInfoPerFillImpl { targetPayload->setEndTime(beamDumpTime); targetPayload->setInjectionScheme(injectionScheme); ret = true; + + if (energy <= 0) { + // only log an error, do not fail the payload creation, the logic of skipping payloads with invalid energy is handled elsewhere + edm::LogError("LHCInfoPerFillPopConSourceHandler") + << "Received non-positive energy from OMS for fill " << currentFill << ": " << energy + << " GeV, string value: '" << row.get("energy") << "'."; + } } return ret; } @@ -205,6 +212,9 @@ LHCInfoPerFillPopConSourceHandler::LHCInfoPerFillPopConSourceHandler(edm::Parame m_ecalConnectionString(pset.getUntrackedParameter("ecalConnectionString", "")), m_authpath(pset.getUntrackedParameter("authenticationPath", "")), m_omsBaseUrl(pset.getUntrackedParameter("omsBaseUrl", "")), + m_minEnergy(pset.getUntrackedParameter("minEnergy", 450.)), + m_maxEnergy(pset.getUntrackedParameter("maxEnergy", 8000.)), + m_throwOnInvalid(pset.getUntrackedParameter("throwOnInvalid", false)), m_fillPayload(), m_prevPayload(), m_tmpBuffer() { @@ -221,7 +231,66 @@ LHCInfoPerFillPopConSourceHandler::LHCInfoPerFillPopConSourceHandler(edm::Parame } void LHCInfoPerFillPopConSourceHandler::getNewObjects() { - //if a new tag is created, transfer fake fill from 1 to the first fill for the first time + populateIovs(); + if (!m_endFillMode) { // duringFill mode + handleInvalidPayloads(); + } +} + +void LHCInfoPerFillPopConSourceHandler::handleInvalidPayloads() { + // note: at the moment used only in duringFill mode so the m_iovs is quaranteed to have size() <= 1 + // but iterating through the whole map is implemented just in case the way it's used changes + auto it = m_iovs.begin(); + while (it != m_iovs.end()) { + std::stringstream payloadData; + payloadData << "Fill = " << it->second->fillNumber() << ", Energy = " << it->second->energy(); + if (!isPayloadValid(*(it->second))) { + // define the message and then either throw or print log and filter out + std::string msg = "Skipping upload of payload with invalid values: " + payloadData.str(); + if (m_throwOnInvalid) { + throw cms::Exception("LHCInfoPerFillPopConSourceHandler") << msg; + } else { + edm::LogWarning(m_name) << msg; + } + // filter out (erase) invalid payloads + m_iovs.erase(it++); // note: post-increment necessary to avoid using invalidated iterators + } else { + edm::LogInfo(m_name) << "Payload to be uploaded: " << payloadData.str(); + ++it; + } + } +} + +bool LHCInfoPerFillPopConSourceHandler::isPayloadValid(const LHCInfoPerFill& payload) const { + return (m_minEnergy <= payload.energy() && payload.energy() <= m_maxEnergy); +} + +std::tuple +LHCInfoPerFillPopConSourceHandler::createSubsystemDbSessions() const { + cond::persistency::ConnectionPool connection; + //configure the connection + if (m_debug) { + connection.setMessageVerbosity(coral::Debug); + } else { + connection.setMessageVerbosity(coral::Error); + } + connection.setAuthenticationPath(m_authpath); + connection.configure(); + //create the sessions + cond::persistency::Session cttpsSession = connection.createSession(m_connectionString, false); + cond::persistency::Session ecalSession = connection.createSession(m_ecalConnectionString, false); + return std::make_tuple(std::move(cttpsSession), std::move(ecalSession)); +} + +cond::Time_t LHCInfoPerFillPopConSourceHandler::getNextFillSearchTimestamp(cond::Time_t lastSince) const { + cond::Time_t startTimestamp = m_startTime.is_not_a_date_time() ? 0 : cond::time::from_boost(m_startTime); + cond::Time_t nextFillSearchTimestamp = + std::max(startTimestamp, m_endFillMode ? lastSince : (m_prevPayload ? m_prevPayload->createTime() : 0)); + return nextFillSearchTimestamp; +} + +cond::Time_t LHCInfoPerFillPopConSourceHandler::handleIfNewTagAndGetLastSince() { + //print tag info if (tagInfo().size == 0) { edm::LogInfo(m_name) << "New tag " << tagInfo().name << "; from " << m_name << "::getNewObjects"; } else { @@ -235,49 +304,46 @@ void LHCInfoPerFillPopConSourceHandler::getNewObjects() { cond::Time_t lastSince = tagInfo().lastInterval.since; if (tagInfo().isEmpty()) { - // for a new or empty tag in endFill mode, an empty payload should be added on top with since=1 - addEmptyPayload(1); - lastSince = 1; - if (!m_endFillMode) { - edm::LogInfo(m_name) << "Empty or new tag: uploading a default payload and ending the job"; - return; + if (m_endFillMode) { + // for a new or empty tag in endFill mode, an empty payload should be added on top with since=1 + addEmptyPayload(1); + lastSince = 1; + } else { + // in duringFill mode, we don't upload empty payloads to the empty tag + lastSince = 0; // in duringFill mode, this value is not used when the tag is empty } } else { edm::LogInfo(m_name) << "The last Iov in tag " << tagInfo().name << " valid since " << lastSince << "from " << m_name << "::getNewObjects"; } - //retrieve the data from the relational database source - cond::persistency::ConnectionPool connection; - //configure the connection - if (m_debug) { - connection.setMessageVerbosity(coral::Debug); - } else { - connection.setMessageVerbosity(coral::Error); - } - connection.setAuthenticationPath(m_authpath); - connection.configure(); - //create the sessions - cond::persistency::Session session = connection.createSession(m_connectionString, false); - cond::persistency::Session session2 = connection.createSession(m_ecalConnectionString, false); - // fetch last payload when available + return lastSince; +} + +void LHCInfoPerFillPopConSourceHandler::fetchLastPayload() { if (!tagInfo().lastInterval.payloadId.empty()) { cond::persistency::Session session3 = dbSession(); session3.transaction().start(true); m_prevPayload = session3.fetchPayload(tagInfo().lastInterval.payloadId); session3.transaction().commit(); } +} - boost::posix_time::ptime executionTime = boost::posix_time::second_clock::local_time(); - cond::Time_t executionTimeIov = cond::time::from_boost(executionTime); - - cond::Time_t startTimestamp = m_startTime.is_not_a_date_time() ? 0 : cond::time::from_boost(m_startTime); - cond::Time_t nextFillSearchTimestamp = - std::max(startTimestamp, m_endFillMode ? lastSince : m_prevPayload->createTime()); +boost::posix_time::ptime LHCInfoPerFillPopConSourceHandler::getExecutionTime() const { + return boost::posix_time::second_clock::local_time(); +} +void LHCInfoPerFillPopConSourceHandler::populateIovs() { + cond::Time_t lastSince = handleIfNewTagAndGetLastSince(); + fetchLastPayload(); + cond::Time_t nextFillSearchTimestamp = getNextFillSearchTimestamp(lastSince); edm::LogInfo(m_name) << "Starting sampling at " << boost::posix_time::to_simple_string(cond::time::to_boost(nextFillSearchTimestamp)); + auto [cttpsSession, ecalSession] = createSubsystemDbSessions(); + boost::posix_time::ptime executionTime = getExecutionTime(); + cond::Time_t executionTimeIov = cond::time::from_boost(executionTime); + while (true) { if (nextFillSearchTimestamp >= executionTimeIov) { edm::LogInfo(m_name) << "Sampling ended at the time " @@ -290,26 +356,12 @@ void LHCInfoPerFillPopConSourceHandler::getNewObjects() { cond::OMSService oms; oms.connect(m_omsBaseUrl); - auto query = oms.query("fills"); - - edm::LogInfo(m_name) << "Searching new fill after " << boost::posix_time::to_simple_string(nextFillSearchTime); - query->filterNotNull("start_stable_beam").filterNotNull("fill_number"); - if (nextFillSearchTime > cond::time::to_boost(m_prevPayload->createTime())) { - query->filterGE("start_time", nextFillSearchTime); - } else { - query->filterGT("start_time", nextFillSearchTime); - } - query->filterLT("start_time", m_endTime); - if (m_endFillMode) - query->filterNotNull("end_time"); - else - query->filterEQ("end_time", cond::OMSServiceQuery::SNULL); + bool inclusiveSearchTime = + nextFillSearchTime > cond::time::to_boost(m_prevPayload ? m_prevPayload->createTime() : 0); + m_fillPayload = findFillToProcess(oms, nextFillSearchTime, inclusiveSearchTime); - bool foundFill = query->execute(); - if (foundFill) - foundFill = theLHCInfoPerFillImpl::makeFillPayload(m_fillPayload, query->result()); - if (!foundFill) { + if (!m_fillPayload) { edm::LogInfo(m_name) << "No fill found - END of job."; break; } @@ -336,12 +388,8 @@ void LHCInfoPerFillPopConSourceHandler::getNewObjects() { boost::posix_time::ptime flumiStart = cond::time::to_boost(m_tmpBuffer.front().first); boost::posix_time::ptime flumiStop = cond::time::to_boost(m_tmpBuffer.back().first); edm::LogInfo(m_name) << "First lumi starts at " << flumiStart << " last lumi starts at " << flumiStop; - session.transaction().start(true); - getCTPPSData(session, startSampleTime, endSampleTime); - session.transaction().commit(); - session2.transaction().start(true); - getEcalData(session2, startSampleTime, endSampleTime); - session2.transaction().commit(); + getCTPPSData(cttpsSession, startSampleTime, endSampleTime); + getEcalData(ecalSession, startSampleTime, endSampleTime); } } @@ -351,14 +399,11 @@ void LHCInfoPerFillPopConSourceHandler::getNewObjects() { << "More than 1 payload buffered for writing in duringFill mode.\ In this mode only up to 1 payload can be written"; } else if (m_tmpBuffer.size() == 1) { - if (theLHCInfoPerFillImpl::comparePayloads(*(m_tmpBuffer.begin()->second), *m_prevPayload)) { + if (m_prevPayload && theLHCInfoPerFillImpl::comparePayloads(*(m_tmpBuffer.begin()->second), *m_prevPayload)) { m_tmpBuffer.clear(); edm::LogInfo(m_name) << "The buffered payload has the same data as the previous payload in the tag. It will not be written."; } - } else if (m_tmpBuffer.empty()) { - addEmptyPayload( - cond::lhcInfoHelper::getFillLastLumiIOV(oms, lhcFill)); //the IOV doesn't matter when using OnlinePopCon } // In duringFill mode, convert the timestamp-type IOVs to lumiid-type IOVs // before transferring the payloads from the buffer to the final collection @@ -378,8 +423,6 @@ void LHCInfoPerFillPopConSourceHandler::getNewObjects() { if (m_prevPayload->fillNumber() and !ongoingFill) { if (m_endFillMode) { addEmptyPayload(endFillTime); - } else { - addEmptyPayload(cond::lhcInfoHelper::getFillLastLumiIOV(oms, lhcFill)); } } } @@ -387,6 +430,32 @@ void LHCInfoPerFillPopConSourceHandler::getNewObjects() { std::string LHCInfoPerFillPopConSourceHandler::id() const { return m_name; } +std::unique_ptr LHCInfoPerFillPopConSourceHandler::findFillToProcess( + cond::OMSService& oms, const boost::posix_time::ptime& nextFillSearchTime, bool inclusiveSearchTime) { + oms.connect(m_omsBaseUrl); + auto query = oms.query("fills"); + + edm::LogInfo(m_name) << "Searching new fill after " << boost::posix_time::to_simple_string(nextFillSearchTime); + query->filterNotNull("start_stable_beam").filterNotNull("fill_number"); + if (inclusiveSearchTime) { + query->filterGE("start_time", nextFillSearchTime); + } else { + query->filterGT("start_time", nextFillSearchTime); + } + + query->filterLT("start_time", m_endTime); + if (m_endFillMode) + query->filterNotNull("end_time"); + else + query->filterEQ("end_time", cond::OMSServiceQuery::SNULL); + + bool foundFill = query->execute(); + std::unique_ptr fillToBeProcessedPayload; + if (foundFill) + foundFill = theLHCInfoPerFillImpl::makeFillPayload(fillToBeProcessedPayload, query->result()); + return fillToBeProcessedPayload; +} + void LHCInfoPerFillPopConSourceHandler::addEmptyPayload(cond::Time_t iov) { bool add = false; if (m_iovs.empty()) { @@ -439,10 +508,11 @@ void LHCInfoPerFillPopConSourceHandler::convertBufferedIovsToLumiid( } } -size_t LHCInfoPerFillPopConSourceHandler::getLumiData(const cond::OMSService& oms, - unsigned short fillId, - const boost::posix_time::ptime& beginFillTime, - const boost::posix_time::ptime& endFillTime) { +std::tuple> +LHCInfoPerFillPopConSourceHandler::executeLumiQuery(const cond::OMSService& oms, + unsigned short fillId, + const boost::posix_time::ptime& beginFillTime, + const boost::posix_time::ptime& endFillTime) const { auto query = oms.query("lumisections"); query->addOutputVars( {"start_time", "delivered_lumi", "recorded_lumi", "beams_stable", "run_number", "lumisection_number"}); @@ -450,22 +520,38 @@ size_t LHCInfoPerFillPopConSourceHandler::getLumiData(const cond::OMSService& om query->filterGT("start_time", beginFillTime).filterLT("start_time", endFillTime); query->filterEQ("beams_stable", "true"); query->limit(cond::lhcInfoHelper::kLumisectionsQueryLimit); - if (query->execute()) { - auto queryResult = query->result(); - edm::LogInfo(m_name) << "Found " << queryResult.size() << " lumisections with STABLE BEAM during the fill " - << fillId; - if (!queryResult.empty()) { - if (m_endFillMode) { - auto firstRow = queryResult.front(); - addPayloadToBuffer(firstRow); - } + bool success = query->execute(); + return {(success ? query->result() : cond::OMSServiceResult()), success, std::move(query)}; +} - auto lastRow = queryResult.back(); - addPayloadToBuffer(lastRow); - } +void LHCInfoPerFillPopConSourceHandler::getLumiData(const cond::OMSService& oms, + unsigned short fillId, + const boost::posix_time::ptime& beginFillTime, + const boost::posix_time::ptime& endFillTime) { + // keeping the query ownerObject in scope is necessary as the lifetime of the queryResult resources is tied to it + auto [queryResult, success, ownerObject] = executeLumiQuery(oms, fillId, beginFillTime, endFillTime); + if (!success) { + edm::LogError(m_name) << "Failed to execute luminosity query."; + return; + } + edm::LogInfo(m_name) << "Found " << queryResult.size() << " lumisections with STABLE BEAM during the fill " << fillId; + + if (queryResult.empty()) { + edm::LogWarning(m_name) << "No lumisections with STABLE BEAM found during the fill " << fillId + << ". No payload will be added to buffer for writing."; + return; } - return 0; + + if (m_endFillMode) { + auto firstRow = queryResult.front(); + addPayloadToBuffer(firstRow); + } + + auto lastRow = queryResult.back(); + addPayloadToBuffer(lastRow); + + return; } void LHCInfoPerFillPopConSourceHandler::getDipData(const cond::OMSService& oms, @@ -530,12 +616,21 @@ void LHCInfoPerFillPopConSourceHandler::getDipData(const cond::OMSService& oms, } } -bool LHCInfoPerFillPopConSourceHandler::getCTPPSData(cond::persistency::Session& session, +bool LHCInfoPerFillPopConSourceHandler::getCTPPSData(cond::persistency::Session& cttpsSession, const boost::posix_time::ptime& beginFillTime, const boost::posix_time::ptime& endFillTime) { + cttpsSession.transaction().start(true); + auto ret = getCTPPSDataImpl(cttpsSession, beginFillTime, endFillTime); + cttpsSession.transaction().commit(); + return ret; +} + +bool LHCInfoPerFillPopConSourceHandler::getCTPPSDataImpl(cond::persistency::Session& cttpsSession, + const boost::posix_time::ptime& beginFillTime, + const boost::posix_time::ptime& endFillTime) { //run the fifth query against the CTPPS schema //Initializing the CMS_CTP_CTPPS_COND schema. - coral::ISchema& CTPPS = session.coralSession().schema("CMS_PPS_SPECT_COND"); + coral::ISchema& CTPPS = cttpsSession.coralSession().schema("CMS_PPS_SPECT_COND"); //execute query for CTPPS Data std::unique_ptr CTPPSDataQuery(CTPPS.newQuery()); //FROM clause @@ -637,12 +732,21 @@ bool LHCInfoPerFillPopConSourceHandler::getCTPPSData(cond::persistency::Session& return ret; } -bool LHCInfoPerFillPopConSourceHandler::getEcalData(cond::persistency::Session& session, +bool LHCInfoPerFillPopConSourceHandler::getEcalData(cond::persistency::Session& ecalSession, const boost::posix_time::ptime& lowerTime, const boost::posix_time::ptime& upperTime) { + ecalSession.transaction().start(true); + auto ret = getEcalDataImpl(ecalSession, lowerTime, upperTime); + ecalSession.transaction().commit(); + return ret; +} + +bool LHCInfoPerFillPopConSourceHandler::getEcalDataImpl(cond::persistency::Session& ecalSession, + const boost::posix_time::ptime& lowerTime, + const boost::posix_time::ptime& upperTime) { //run the sixth query against the CMS_DCS_ENV_PVSS_COND schema //Initializing the CMS_DCS_ENV_PVSS_COND schema. - coral::ISchema& ECAL = session.nominalSchema(); + coral::ISchema& ECAL = ecalSession.nominalSchema(); //start the transaction against the fill logging schema //execute query for ECAL Data std::unique_ptr ECALDataQuery(ECAL.newQuery()); diff --git a/CondTools/RunInfo/src/LHCInfoPerLSPopConSourceHandler.cc b/CondTools/RunInfo/src/LHCInfoPerLSPopConSourceHandler.cc index 8cb01ac930cf8..6e1531ab19262 100644 --- a/CondTools/RunInfo/src/LHCInfoPerLSPopConSourceHandler.cc +++ b/CondTools/RunInfo/src/LHCInfoPerLSPopConSourceHandler.cc @@ -130,9 +130,11 @@ LHCInfoPerLSPopConSourceHandler::LHCInfoPerLSPopConSourceHandler(edm::ParameterS m_maxBetaStar(pset.getUntrackedParameter("maxBetaStar", 100.)), m_minCrossingAngle(pset.getUntrackedParameter("minCrossingAngle", 10.)), m_maxCrossingAngle(pset.getUntrackedParameter("maxCrossingAngle", 500.)), + m_throwOnInvalid(pset.getUntrackedParameter("throwOnInvalid", false)), m_fillPayload(), m_prevPayload(), - m_tmpBuffer() { + m_tmpBuffer(), + m_lastPayloadEmpty(false) { if (!pset.getUntrackedParameter("startTime").empty()) { m_startTime = boost::posix_time::time_from_string(pset.getUntrackedParameter("startTime")); } @@ -153,11 +155,11 @@ LHCInfoPerLSPopConSourceHandler::~LHCInfoPerLSPopConSourceHandler() = default; void LHCInfoPerLSPopConSourceHandler::getNewObjects() { populateIovs(); if (!m_endFillMode) { // duringFill mode - filterInvalidPayloads(); + handleInvalidPayloads(); } } -void LHCInfoPerLSPopConSourceHandler::filterInvalidPayloads() { +void LHCInfoPerLSPopConSourceHandler::handleInvalidPayloads() { // note: at the moment used only in duringFill mode so the m_iovs is quaranteed to have size() <= 1 // but iterating through the whole map is implemented just in case the way it's used changes auto it = m_iovs.begin(); @@ -169,7 +171,12 @@ void LHCInfoPerLSPopConSourceHandler::filterInvalidPayloads() { << "beta*X = " << it->second->betaStarX() << " m, " << "beta*Y = " << it->second->betaStarY() << " m"; if (!isPayloadValid(*(it->second))) { - edm::LogWarning(m_name) << "Skipping upload of payload with invalid values: " << payloadData.str(); + std::string msg = "Skipping upload of payload with invalid values: " + payloadData.str(); + if (m_throwOnInvalid) { + throw cms::Exception("LHCInfoPerLSPopConSourceHandler") << msg; + } else { + edm::LogWarning(m_name) << msg; + } m_iovs.erase(it++); // note: post-increment necessary to avoid using invalidated iterators } else { edm::LogInfo(m_name) << "Payload to be uploaded: " << payloadData.str(); diff --git a/CondTools/RunInfo/src/TestLHCInfoPerFillPopConSourceHandler.cc b/CondTools/RunInfo/src/TestLHCInfoPerFillPopConSourceHandler.cc new file mode 100644 index 0000000000000..4cb353edbb948 --- /dev/null +++ b/CondTools/RunInfo/src/TestLHCInfoPerFillPopConSourceHandler.cc @@ -0,0 +1,47 @@ +#include "CondTools/RunInfo/interface/TestLHCInfoPerFillPopConSourceHandler.h" +#include + +TestLHCInfoPerFillPopConSourceHandler::TestLHCInfoPerFillPopConSourceHandler(edm::ParameterSet const& pset) + : LHCInfoPerFillPopConSourceHandler(pset) {} + +std::unique_ptr TestLHCInfoPerFillPopConSourceHandler::findFillToProcess( + cond::OMSService& oms, const boost::posix_time::ptime& nextFillSearchTime, bool inclusiveSearchTime) { + for (auto& fill : mockOmsFills) { + auto fillStartTime = cond::time::to_boost(fill.first); + if (inclusiveSearchTime ? (fillStartTime >= nextFillSearchTime) : (fillStartTime > nextFillSearchTime)) { + auto fillPayload = std::make_unique(*fill.second); + return fillPayload; + } + } + return nullptr; +} + +cond::Time_t TestLHCInfoPerFillPopConSourceHandler::handleIfNewTagAndGetLastSince() { + cond::Time_t lastSince = 0; + if (m_endFillMode) { + addEmptyPayload(1); + lastSince = 1; + } else { + lastSince = 0; + } + return lastSince; +} + +boost::posix_time::ptime TestLHCInfoPerFillPopConSourceHandler::getExecutionTime() const { return mockExecutionTime; } + +std::tuple +TestLHCInfoPerFillPopConSourceHandler::createSubsystemDbSessions() const { + return std::make_tuple(cond::persistency::Session(), cond::persistency::Session()); +} + +std::tuple> +TestLHCInfoPerFillPopConSourceHandler::executeLumiQuery(const cond::OMSService& oms, + unsigned short fillId, + const boost::posix_time::ptime& beginFillTime, + const boost::posix_time::ptime& endFillTime) const { + auto it = mockLumiData.find(fillId); + if (it != mockLumiData.end()) { + return std::make_tuple(it->second, true, nullptr); + } + return std::make_tuple(cond::OMSServiceResult(), false, nullptr); +} diff --git a/CondTools/RunInfo/test/BuildFile.xml b/CondTools/RunInfo/test/BuildFile.xml index ffb5d05f87a3b..a82310462748c 100644 --- a/CondTools/RunInfo/test/BuildFile.xml +++ b/CondTools/RunInfo/test/BuildFile.xml @@ -8,5 +8,9 @@ - + + + + + \ No newline at end of file diff --git a/CondTools/RunInfo/test/test_catch2_LHCInfoPerFillPopCon.cpp b/CondTools/RunInfo/test/test_catch2_LHCInfoPerFillPopCon.cpp new file mode 100644 index 0000000000000..554324ad5e79d --- /dev/null +++ b/CondTools/RunInfo/test/test_catch2_LHCInfoPerFillPopCon.cpp @@ -0,0 +1,629 @@ +#define CATCH_CONFIG_MAIN + +#include "catch.hpp" + +#include "CondTools/RunInfo/interface/LHCInfoPerFillPopConSourceHandler.h" +#include "CondTools/RunInfo/interface/TestLHCInfoPerFillPopConSourceHandler.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +struct LHCInfoPerFillPopConSourceHandlerProtectedAccessor : public LHCInfoPerFillPopConSourceHandler { + using LHCInfoPerFillPopConSourceHandler::addPayloadToBuffer; + using LHCInfoPerFillPopConSourceHandler::m_fillPayload; + using LHCInfoPerFillPopConSourceHandler::m_timestampToLumiid; + using LHCInfoPerFillPopConSourceHandler::m_tmpBuffer; + + LHCInfoPerFillPopConSourceHandlerProtectedAccessor(edm::ParameterSet const& pset) + : LHCInfoPerFillPopConSourceHandler(pset) {} +}; + +// Helper function to create a default ParameterSet +edm::ParameterSet createDefaultPSet() { + edm::ParameterSet pset; + pset.addUntrackedParameter("debug", true); + pset.addUntrackedParameter("startTime", "2023-01-01 00:00:00"); + pset.addUntrackedParameter("endTime", "2023-12-31 23:59:59"); + pset.addUntrackedParameter("name", "LHCInfoPerFillPopConSourceHandler"); + pset.addUntrackedParameter("connectionString", ""); + pset.addUntrackedParameter("ecalConnectionString", ""); + pset.addUntrackedParameter("authenticationPath", ""); + pset.addUntrackedParameter("omsBaseUrl", ""); + pset.addUntrackedParameter("minEnergy", 450.0); + pset.addUntrackedParameter("maxEnergy", 8000.0); + pset.addUntrackedParameter("throwOnInvalid", true); + return pset; +} + +TEST_CASE("LHCInfoPerFillPopConSourceHandler.isPayloadValid works", "[isPayloadValid]") { + //generate test for both endFill and duringFill modes + bool endFillMode = GENERATE(true, false); + edm::ParameterSet pset = createDefaultPSet(); + pset.addUntrackedParameter("endFill", endFillMode); + LHCInfoPerFillPopConSourceHandlerProtectedAccessor handler(pset); + + LHCInfoPerFill payload; + + SECTION("Energy within range is valid") { + payload.setEnergy(6500.0); + CHECK(handler.isPayloadValid(payload) == true); + } + + SECTION("Energy at lower bound is valid") { + payload.setEnergy(450.0); + CHECK(handler.isPayloadValid(payload) == true); + } + + SECTION("Energy at upper bound is valid") { + payload.setEnergy(8000.0); + CHECK(handler.isPayloadValid(payload) == true); + } + + SECTION("Energy below range is invalid") { + payload.setEnergy(400.0); + CHECK(handler.isPayloadValid(payload) == false); + } + + SECTION("Energy above range is invalid") { + payload.setEnergy(8500.0); + CHECK(handler.isPayloadValid(payload) == false); + } +} + +TEST_CASE("LHCInfoPerFillPopConSourceHandler.addPayloadToBuffer works", "[addPayloadToBuffer]") { + //generate test for both endFill and duringFill modes + bool endFillMode = GENERATE(true, false); + edm::ParameterSet pset = createDefaultPSet(); + pset.addUntrackedParameter("endFill", endFillMode); + LHCInfoPerFillPopConSourceHandlerProtectedAccessor handler(pset); + + // Create a mock OMSServiceResultRef + boost::property_tree::ptree mockRow; + + mockRow.put("start_time", "2023-06-01 12:00:00"); + mockRow.put("delivered_lumi", 100.0f); + mockRow.put("recorded_lumi", 80.0f); + mockRow.put("run_number", "3500"); + mockRow.put("lumisection_number", "150"); + cond::OMSServiceResultRef mockResultRef(&mockRow); + + // Set the m_fillPayload before calling addPayloadToBuffer + handler.m_fillPayload = std::make_unique(); + handler.m_fillPayload->setFillNumber(1234); + handler.m_fillPayload->setEnergy(6500.0); + + // Call the addPayloadToBuffer method + handler.addPayloadToBuffer(mockResultRef); + + //verify that the payload was added to the tmpBuffer + REQUIRE(handler.m_tmpBuffer.empty() == false); + CHECK(handler.m_tmpBuffer.size() == 1); + + SECTION("addPayloadToBuffer adds correct payload to buffer") { + auto& addedPayload = handler.m_tmpBuffer.front().second; + CHECK(addedPayload->delivLumi() == 100.0f); + CHECK(addedPayload->recLumi() == 80.0f); + CHECK(addedPayload->fillNumber() == 1234); + CHECK(addedPayload->energy() == 6500.0); + } + + SECTION("addPayloadToBuffer adds correct IOV to buffer") { + auto addedIov = handler.m_tmpBuffer.front().first; + CHECK(addedIov == cond::time::from_boost(boost::posix_time::time_from_string("2023-06-01 12:00:00"))); + } + + if (!endFillMode) { + SECTION("addPayloadToBuffer updates timestampToLumiid map in duringFill mode") { + CAPTURE(endFillMode); + REQUIRE(handler.m_timestampToLumiid.empty() == false); + CHECK(handler.m_timestampToLumiid.size() == 1); + auto it = handler.m_timestampToLumiid.begin(); + CHECK(it->first == cond::time::from_boost(boost::posix_time::time_from_string("2023-06-01 12:00:00"))); + CHECK(it->second == cond::time::lumiTime(3500, 150)); + } + } +} + +TEST_CASE("LHCInfoPerFillPopConSourceHandler.getNewObjects fills IOVs correctly: endFill mode", "[populate]") { + std::cout << "\nTEST: getNewObjects fills IOVs correctly: endfill mode" << std::endl; + edm::setStandAloneMessageThreshold(edm::messagelogger::ELinfo); + + bool endFillMode = true; + edm::ParameterSet pset = createDefaultPSet(); + pset.addUntrackedParameter("endFill", endFillMode); + TestLHCInfoPerFillPopConSourceHandler handler(pset); + + // Set up mock data + std::vector mockOmsFills; + std::map mockLumiData; + + // Populate mock data + std::vector fillNumbers = {1000, 1001, 1002}; + std::vector energies = {6500.0, 6600.0, 6700.0}; + std::vector fillStartTimes /* force formatting */ = { + boost::posix_time::time_from_string("2023-06-01 11:30:00"), + boost::posix_time::time_from_string("2023-06-01 12:30:00"), + boost::posix_time::time_from_string("2023-06-01 13:30:00")}; + std::vector fillStableBeamBeginTimes = { + boost::posix_time::time_from_string("2023-06-01 12:00:00"), + boost::posix_time::time_from_string("2023-06-01 13:00:00"), + boost::posix_time::time_from_string("2023-06-01 14:00:00")}; + std::vector fillEndTimes /* force formatting */ = { + boost::posix_time::time_from_string("2023-06-01 12:30:00"), + boost::posix_time::time_from_string("2023-06-01 13:29:00"), + boost::posix_time::time_from_string("2023-06-01 14:30:00")}; + + for (size_t i = 0; i < fillNumbers.size(); ++i) { + auto fillPayload = std::make_shared(); + fillPayload->setFillNumber(fillNumbers[i]); + fillPayload->setEnergy(energies[i]); + fillPayload->setCreationTime(cond::time::from_boost(fillStartTimes[i])); + fillPayload->setBeginTime(cond::time::from_boost(fillStableBeamBeginTimes[i])); + fillPayload->setEndTime(cond::time::from_boost(fillEndTimes[i])); + handler.mockOmsFills.emplace_back(std::make_pair(cond::time::from_boost(fillStartTimes[i]), fillPayload)); + } + + // populate json mockLumiData for each fill + // OMSServiceResult cannot be initialized directly from vector of OMSServiceResultRef + // Instead we need to prepare the data in json format and parse it using OMSServiceResult::parseData + std::vector lumiJsons = { + R"delimiter( +{ + "data": [ + { + "id": "354496_113", + "type": "lumisections", + "attributes": { + "beams_stable": true, + "start_time": "2023-06-01T12:00:00Z", + "run_number": 354496, + "recorded_lumi": 0, + "delivered_lumi": 0, + "lumisection_number": 113 + } + }, + { + "id": "354496_114", + "type": "lumisections", + "attributes": { + "beams_stable": true, + "start_time": "2023-06-01T12:00:00Z", + "run_number": 354496, + "recorded_lumi": 1, + "delivered_lumi": 1, + "lumisection_number": 114 + } + }, + { + "id": "354496_115", + "type": "lumisections", + "attributes": { + "beams_stable": true, + "start_time": "2023-06-01T12:00:46Z", + "run_number": 354496, + "recorded_lumi": 123, + "delivered_lumi": 123, + "lumisection_number": 115 + } + } + ] +} +)delimiter", + R"delimiter( +{ + "data": [ + { + "id": "354496_113", + "type": "lumisections", + "attributes": { + "beams_stable": true, + "start_time": "2023-06-01T13:00:00Z", + "run_number": 354496, + "recorded_lumi": 0, + "delivered_lumi": 0, + "lumisection_number": 200 + } + }, + { + "id": "354496_114", + "type": "lumisections", + "attributes": { + "beams_stable": true, + "start_time": "2023-06-01T13:00:23Z", + "run_number": 354496, + "recorded_lumi": 0, + "delivered_lumi": 0, + "lumisection_number": 201 + } + } + ] +} +)delimiter", + R"delimiter( +{ + "data": [ + { + "id": "354496_113", + "type": "lumisections", + "attributes": { + "beams_stable": true, + "start_time": "2023-06-01T14:00:00Z", + "run_number": 354497, + "recorded_lumi": 0, + "delivered_lumi": 0, + "lumisection_number": 100 + } + }, + { + "id": "354496_114", + "type": "lumisections", + "attributes": { + "beams_stable": true, + "start_time": "2023-06-01T14:00:23Z", + "run_number": 354497, + "recorded_lumi": 0, + "delivered_lumi": 0, + "lumisection_number": 101 + } + } + ] +} +)delimiter"}; + + std::cout << "lumiJsons size: " << lumiJsons.size() << std::endl; + + for (size_t i = 0; i < fillNumbers.size(); ++i) { + handler.mockLumiData[fillNumbers[i]] = cond::OMSServiceResult(); + handler.mockLumiData[fillNumbers[i]].parseData(lumiJsons[i]); + } + + // Run the populate function + REQUIRE_NOTHROW(handler.getNewObjects()); + REQUIRE(handler.iovs().empty() == false); + + REQUIRE(handler.iovs().size() == 8); + + // Check that IOVs were populated correctly + auto it = handler.iovs().begin(); + auto end = handler.iovs().end(); + + auto to_since = [](const char* ts) { return cond::time::from_boost(boost::posix_time::time_from_string(ts)); }; + + // Helper lambda to check and advance iterator safely + auto check_iov = [&](decltype(it)& iter, + auto expected_since, + auto expected_fill, + auto expected_energy, + auto expected_delivLumi, + auto expected_recLumi) { + REQUIRE(iter != end); + std::cout << "IOV since: " << iter->first << ", Fill: " << iter->second->fillNumber() + << ", Energy: " << iter->second->energy() << ", delivLumi: " << iter->second->delivLumi() + << ", recLumi: " << iter->second->recLumi() << std::endl; + CHECK(iter->first == (unsigned long long)expected_since); + CHECK(iter->second->fillNumber() == expected_fill); + CHECK(iter->second->energy() == expected_energy); + CHECK(iter->second->delivLumi() == expected_delivLumi); + CHECK(iter->second->recLumi() == expected_recLumi); + ++iter; + }; + + check_iov(it, 1, 0, 0.0, 0.0f, 0.0f); // empty payload added to empty tag + check_iov(it, to_since("2023-06-01 12:00:00"), 1000, 6500.0, 0.0f, 0.0f); // first payload of SB of fill 1000 + check_iov(it, to_since("2023-06-01 12:00:46"), 1000, 6500.0, 123.0f, 123.0f); // last payload of SB of fill 1000 + check_iov(it, to_since("2023-06-01 12:30:00"), 0, 0.0, 0.0f, 0.0f); // empty payload between fills + check_iov(it, to_since("2023-06-01 13:00:00"), 1001, 6600.0, 0.0f, 0.0f); + // only one payload of fill 1001 because of same data + check_iov(it, to_since("2023-06-01 13:29:00"), 0, 0.0, 0.0f, 0.0f); + check_iov(it, to_since("2023-06-01 14:00:00"), 1002, 6700.0, 0.0f, 0.0f); + // only one payload of fill 1002 because of same data + check_iov(it, to_since("2023-06-01 14:30:00"), 0, 0.0, 0.0f, 0.0f); +} + +TEST_CASE("LHCInfoPerFillPopConSourceHandler.getNewObjects fills IOVs correctly in duringFill mode", "[populate]") { + std::cout << "\nTEST: getNewObjects fills IOVs correctly in duringFill mode" << std::endl; + edm::setStandAloneMessageThreshold(edm::messagelogger::ELinfo); + + bool endFillMode = false; + edm::ParameterSet pset = createDefaultPSet(); + pset.addUntrackedParameter("endFill", endFillMode); + TestLHCInfoPerFillPopConSourceHandler handler(pset); + + // Set up mock data + std::vector mockOmsFills; + std::map mockLumiData; + //set mock execution time + handler.mockExecutionTime = boost::posix_time::time_from_string("2023-06-01 12:10:00"); + + // Populate mock data + std::vector fillNumbers = {1000}; + std::vector energies = {GENERATE(450.0, 6600.0, 8000.0)}; + std::vector fillStartTimes = {boost::posix_time::time_from_string("2023-06-01 11:30:00")}; + std::vector fillStableBeamBeginTimes = { + boost::posix_time::time_from_string("2023-06-01 12:00:00")}; + std::vector fillEndTimes = {boost::posix_time::time_from_string("2023-06-01 12:30:00")}; + + for (size_t i = 0; i < fillNumbers.size(); ++i) { + auto fillPayload = std::make_shared(); + fillPayload->setFillNumber(fillNumbers[i]); + fillPayload->setEnergy(energies[i]); + fillPayload->setCreationTime(cond::time::from_boost(fillStartTimes[i])); + fillPayload->setBeginTime(cond::time::from_boost(fillStableBeamBeginTimes[i])); + fillPayload->setEndTime(0LL); + handler.mockOmsFills.emplace_back(std::make_pair(cond::time::from_boost(fillStartTimes[i]), fillPayload)); + } + + std::vector lumiJsons = { + R"delimiter( +{ + "data": [ + { + "id": "354496_113", + "type": "lumisections", + "attributes": { + "beams_stable": true, + "start_time": "2023-06-01T12:00:00Z", + "run_number": 354496, + "recorded_lumi": 0, + "delivered_lumi": 0, + "lumisection_number": 113 + } + }, + { + "id": "354496_114", + "type": "lumisections", + "attributes": { + "beams_stable": true, + "start_time": "2023-06-01T12:00:23Z", + "run_number": 354496, + "recorded_lumi": 123, + "delivered_lumi": 123, + "lumisection_number": 114 + } + } + ] +} +)delimiter"}; + + for (size_t i = 0; i < fillNumbers.size(); ++i) { + handler.mockLumiData[fillNumbers[i]] = cond::OMSServiceResult(); + handler.mockLumiData[fillNumbers[i]].parseData(lumiJsons[i]); + } + + // Run the populate function + REQUIRE_NOTHROW(handler.getNewObjects()); + REQUIRE(handler.iovs().empty() == false); + + REQUIRE(handler.iovs().size() == 1); + // Check that IOVs were populated correctly + + auto it = handler.iovs().begin(); + auto end = handler.iovs().end(); + + // Helper lambda to check and advance iterator safely + auto check_iov = + [&](decltype(it)& iter, auto expected_fill, auto expected_energy, auto expected_delivLumi, auto expected_recLumi) { + REQUIRE(iter != end); + std::cout << "IOV since: " << iter->first << ", Fill: " << iter->second->fillNumber() + << ", Energy: " << iter->second->energy() << ", delivLumi: " << iter->second->delivLumi() + << ", recLumi: " << iter->second->recLumi() << std::endl; + // we don't check IOV since in duringFill mode + CHECK(iter->second->fillNumber() == expected_fill); + CHECK(iter->second->energy() == expected_energy); + CHECK(iter->second->delivLumi() == expected_delivLumi); + CHECK(iter->second->recLumi() == expected_recLumi); + ++iter; + }; + + check_iov(it, 1000, energies.front(), 123.0f, 123.0f); +} + +TEST_CASE( + "LHCInfoPerFillPopConSourceHandler.getNewObjects doesn't upload payloads with invalid energy in duringFill mode", + "[populate]") { + std::cout << "\nTEST: getNewObjects doesn't upload payloads with invalid energy in duringFill mode" << std::endl; + edm::setStandAloneMessageThreshold(edm::messagelogger::ELinfo); + + bool endFillMode = false; + edm::ParameterSet pset = createDefaultPSet(); + pset.addUntrackedParameter("endFill", endFillMode); + TestLHCInfoPerFillPopConSourceHandler handler(pset); + + // Set up mock data + std::vector mockOmsFills; + std::map mockLumiData; + //set mock execution time + handler.mockExecutionTime = boost::posix_time::time_from_string("2023-06-01 12:10:00"); + + // Populate mock data + std::vector fillNumbers = {1000}; + std::vector energies = {GENERATE(-6800., -1., 0., 449.9, 8000.1)}; // invalid energy + std::vector fillStartTimes = {boost::posix_time::time_from_string("2023-06-01 11:30:00")}; + std::vector fillStableBeamBeginTimes = { + boost::posix_time::time_from_string("2023-06-01 12:00:00")}; + + for (size_t i = 0; i < fillNumbers.size(); ++i) { + auto fillPayload = std::make_shared(); + fillPayload->setFillNumber(fillNumbers[i]); + fillPayload->setEnergy(energies[i]); + fillPayload->setCreationTime(cond::time::from_boost(fillStartTimes[i])); + fillPayload->setBeginTime(cond::time::from_boost(fillStableBeamBeginTimes[i])); + fillPayload->setEndTime(0LL); + handler.mockOmsFills.emplace_back(std::make_pair(cond::time::from_boost(fillStartTimes[i]), fillPayload)); + } + + std::vector lumiJsons = { + R"delimiter( +{ + "data": [ + { + "id": "354496_113", + "type": "lumisections", + "attributes": { + "beams_stable": true, + "start_time": "2023-06-01T12:00:00Z", + "run_number": 354496, + "recorded_lumi": 0, + "delivered_lumi": 0, + "lumisection_number": 113 + } + }, + { + "id": "354496_114", + "type": "lumisections", + "attributes": { + "beams_stable": true, + "start_time": "2023-06-01T12:00:23Z", + "run_number": 354496, + "recorded_lumi": 123, + "delivered_lumi": 123, + "lumisection_number": 114 + } + } + ] +} +)delimiter"}; + + for (size_t i = 0; i < fillNumbers.size(); ++i) { + handler.mockLumiData[fillNumbers[i]] = cond::OMSServiceResult(); + handler.mockLumiData[fillNumbers[i]].parseData(lumiJsons[i]); + } + + // Run the populate function + REQUIRE_THROWS(handler.getNewObjects()); + // test that the exception message contains "Invalid energy" + try { + handler.getNewObjects(); + } catch (const cms::Exception& e) { + std::string what = e.what(); + CHECK(what.find("Skipping upload of payload with invalid values: Fill = 1000, Energy = ") != std::string::npos); + } +} + +TEST_CASE("LHCInfoPerFillPopConSourceHandler.getNewObjects during fill mode: doesn't upload payloads for ended fills", + "[populate]") { + std::cout << "\nTEST: getNewObjects during fill mode: doesn't upload payloads for ended fills" << std::endl; + edm::setStandAloneMessageThreshold(edm::messagelogger::ELinfo); + + bool endFillMode = false; + edm::ParameterSet pset = createDefaultPSet(); + pset.addUntrackedParameter("endFill", endFillMode); + TestLHCInfoPerFillPopConSourceHandler handler(pset); + + // Set up mock data + std::vector mockOmsFills; + std::map mockLumiData; + //set mock execution time + handler.mockExecutionTime = boost::posix_time::time_from_string("2023-06-01 12:30:01"); + + // Populate mock data + std::vector fillNumbers = {1000}; + std::vector energies = {6800}; + std::vector fillStartTimes = {boost::posix_time::time_from_string("2023-06-01 11:30:00")}; + std::vector fillStableBeamBeginTimes = { + boost::posix_time::time_from_string("2023-06-01 12:00:00")}; + std::vector fillEndTimes = {boost::posix_time::time_from_string("2023-06-01 12:30:00")}; + + for (size_t i = 0; i < fillNumbers.size(); ++i) { + auto fillPayload = std::make_shared(); + fillPayload->setFillNumber(fillNumbers[i]); + fillPayload->setEnergy(energies[i]); + fillPayload->setCreationTime(cond::time::from_boost(fillStartTimes[i])); + fillPayload->setBeginTime(cond::time::from_boost(fillStableBeamBeginTimes[i])); + fillPayload->setEndTime(cond::time::from_boost(fillEndTimes[i])); + handler.mockOmsFills.emplace_back(std::make_pair(cond::time::from_boost(fillStartTimes[i]), fillPayload)); + } + + std::vector lumiJsons = { + R"delimiter( +{ + "data": [ + { + "id": "354496_113", + "type": "lumisections", + "attributes": { + "beams_stable": true, + "start_time": "2023-06-01T12:00:00Z", + "run_number": 354496, + "recorded_lumi": 0, + "delivered_lumi": 0, + "lumisection_number": 113 + } + }, + { + "id": "354496_114", + "type": "lumisections", + "attributes": { + "beams_stable": true, + "start_time": "2023-06-01T12:00:23Z", + "run_number": 354496, + "recorded_lumi": 123, + "delivered_lumi": 123, + "lumisection_number": 114 + } + } + ] +} +)delimiter"}; + + for (size_t i = 0; i < fillNumbers.size(); ++i) { + handler.mockLumiData[fillNumbers[i]] = cond::OMSServiceResult(); + handler.mockLumiData[fillNumbers[i]].parseData(lumiJsons[i]); + } + + handler.getNewObjects(); + CHECK(handler.iovs().size() == 0); +} + +TEST_CASE( + "LHCInfoPerFillPopConSourceHandler.getNewObjects during fill mode: doesn't upload payloads for fills with no " + "lumisections", + "[populate]") { + std::cout << "\nTEST: getNewObjects during fill mode: doesn't upload payloads for fills with no lumisections" + << std::endl; + edm::setStandAloneMessageThreshold(edm::messagelogger::ELinfo); + + bool endFillMode = false; + edm::ParameterSet pset = createDefaultPSet(); + pset.addUntrackedParameter("endFill", endFillMode); + TestLHCInfoPerFillPopConSourceHandler handler(pset); + + // Set up mock data + std::vector mockOmsFills; + std::map mockLumiData; + //set mock execution time + handler.mockExecutionTime = boost::posix_time::time_from_string("2023-06-01 12:00:01"); + + // Populate mock data + std::vector fillNumbers = {1000}; + std::vector energies = {6800}; + std::vector fillStartTimes = {boost::posix_time::time_from_string("2023-06-01 11:30:00")}; + std::vector fillStableBeamBeginTimes = { + boost::posix_time::time_from_string("2023-06-01 12:00:00")}; + // no need for fillEndTimes, end time of the fill is set to 0 + + for (size_t i = 0; i < fillNumbers.size(); ++i) { + auto fillPayload = std::make_shared(); + fillPayload->setFillNumber(fillNumbers[i]); + fillPayload->setEnergy(energies[i]); + fillPayload->setCreationTime(cond::time::from_boost(fillStartTimes[i])); + fillPayload->setBeginTime(cond::time::from_boost(fillStableBeamBeginTimes[i])); + fillPayload->setEndTime(0LL); + handler.mockOmsFills.emplace_back(std::make_pair(cond::time::from_boost(fillStartTimes[i]), fillPayload)); + } + + std::vector lumiJsons = { + R"delimiter( +{ + "data": [ + ] +} +)delimiter"}; + + for (size_t i = 0; i < fillNumbers.size(); ++i) { + handler.mockLumiData[fillNumbers[i]] = cond::OMSServiceResult(); + handler.mockLumiData[fillNumbers[i]].parseData(lumiJsons[i]); + } + + REQUIRE_NOTHROW(handler.getNewObjects()); + CHECK(handler.iovs().size() == 0); +} diff --git a/CondTools/RunInfo/test/test_lhcInfoNewPopCon.sh b/CondTools/RunInfo/test/test_lhcInfoNewPopCon.sh index 20f3b52ede667..aa2e1a3f379e7 100755 --- a/CondTools/RunInfo/test/test_lhcInfoNewPopCon.sh +++ b/CondTools/RunInfo/test/test_lhcInfoNewPopCon.sh @@ -54,7 +54,7 @@ cmsRun ${SCRIPTS_DIR}/LHCInfoPerFillPopConAnalyzer_cfg.py mode=duringFill \ startTime="2022-10-24 01:00:00.000" endTime="2022-10-24 20:00:00.000" \ lastLumiFile=last_lumi.txt \ tag=fill_during_test > fill_during_test.log || die "cmsRun LHCInfoPerFillPopConAnalyzer_cfg.py" $? "fill_during_test.log" -assert_equal 1 `cat fill_during_test.log | grep -E 'uploaded with since' | \ +assert_equal 0 `cat fill_during_test.log | grep -E 'uploaded with since' | \ wc -l` "LHCInfoPerFillPopConAnalyzer in DuringFill written wrong number of payloads" "fill_during_test.log" echo "testing LHCInfoPerLSPopConAnalyzer in duringFill mode for startTime=\"2022-10-24 01:00:00.000\" endTime=\"2022-10-24 20:00:00.000\"" diff --git a/Configuration/Applications/python/ConfigBuilder.py b/Configuration/Applications/python/ConfigBuilder.py index 5fbd200704d0f..e25dd9dc66057 100644 --- a/Configuration/Applications/python/ConfigBuilder.py +++ b/Configuration/Applications/python/ConfigBuilder.py @@ -1098,7 +1098,7 @@ def define_Configs(self): self.VALIDATIONDefaultSeq='' self.ENDJOBDefaultSeq='endOfProcess' self.REPACKDefaultSeq='DigiToRawRepack' - self.PATDefaultSeq='miniAOD' + self.PATDefaultSeq='patTask' self.PATGENDefaultSeq='miniGEN' #TODO: Check based of file input self.NANODefaultSeq='nanoSequence' @@ -1118,7 +1118,6 @@ def define_Configs(self): if self._options.isMC==True: self.RAW2DIGIDefaultCFF="Configuration/StandardSequences/RawToDigi_cff" self.RECODefaultCFF="Configuration/StandardSequences/Reconstruction_cff" - self.PATDefaultCFF="Configuration/StandardSequences/PATMC_cff" self.PATGENDefaultCFF="Configuration/StandardSequences/PATGEN_cff" self.DQMOFFLINEDefaultCFF="DQMOffline/Configuration/DQMOfflineMC_cff" self.ALCADefaultCFF="Configuration/StandardSequences/AlCaRecoStreamsMC_cff" @@ -1745,12 +1744,6 @@ def prepare_RAW2DIGI(self, stepSpec = "RawToDigi"): self.scheduleSequence(_raw2digiSeq,'raw2digi_step') return - def prepare_PATFILTER(self, stepSpec = None): - self.loadAndRemember("PhysicsTools/PatAlgos/slimming/metFilterPaths_cff") - from PhysicsTools.PatAlgos.slimming.metFilterPaths_cff import allMetFilterPaths - for filt in allMetFilterPaths: - self.schedule.append(getattr(self.process,'Flag_'+filt)) - def prepare_L1HwVal(self, stepSpec = 'L1HwVal'): ''' Enrich the schedule with L1 HW validation ''' self.loadDefaultOrSpecifiedCFF(stepSpec,self.L1HwValDefaultCFF) @@ -1822,18 +1815,20 @@ def prepare_RECOBEFMIX(self, stepSpec = "reconstruction"): self.scheduleSequence(_recobefmixSeq,'reconstruction_befmix_step') return - def prepare_PAT(self, stepSpec = "miniAOD"): + def prepare_PAT(self, stepSpec = "patTask"): ''' Enrich the schedule with PAT ''' - self.prepare_PATFILTER(self) - self.loadDefaultOrSpecifiedCFF(stepSpec,self.PATDefaultCFF) - self.labelsToAssociate.append('patTask') + _,pat_sequence,pat_cff = self.loadDefaultOrSpecifiedCFF(stepSpec,self.PATDefaultCFF) + ## handle the noise filters as Flag_* path that were loaded + for existing_path,path_ in self.process.paths_().items(): + if existing_path.startswith('Flag_'): + print(f'scheduling {existing_path} as part of PAT configuration') + self.schedule.append( path_ ) + + self.labelsToAssociate.append(pat_sequence) if self._options.isData: - self._options.customisation_file_unsch.insert(0,"PhysicsTools/PatAlgos/slimming/miniAOD_tools.miniAOD_customizeAllData") + self._options.customisation_file_unsch.insert(0,f"{pat_cff}.miniAOD_customizeAllData") else: - if self._options.fast: - self._options.customisation_file_unsch.insert(0,"PhysicsTools/PatAlgos/slimming/miniAOD_tools.miniAOD_customizeAllMCFastSim") - else: - self._options.customisation_file_unsch.insert(0,"PhysicsTools/PatAlgos/slimming/miniAOD_tools.miniAOD_customizeAllMC") + self._options.customisation_file_unsch.insert(0,f"{pat_cff}.miniAOD_customizeAllMC") if self._options.hltProcess: self._customise_coms.append( f'process.patTrigger.processName = "{self._options.hltProcess}"') diff --git a/Configuration/Applications/python/cmsDriverOptions.py b/Configuration/Applications/python/cmsDriverOptions.py index 99deeadca50cd..0714c4fcd3966 100755 --- a/Configuration/Applications/python/cmsDriverOptions.py +++ b/Configuration/Applications/python/cmsDriverOptions.py @@ -10,6 +10,7 @@ from Configuration.Applications.ConfigBuilder import ConfigBuilder, defaultOptions import traceback from functools import reduce +import shlex def checkModifier(era): from FWCore.ParameterSet.Config import Modifier, ModifierChain @@ -35,7 +36,7 @@ def OptionsFromCommandLine(): import sys options=OptionsFromItems(sys.argv[1:]) # memorize the command line arguments - options.arguments = reduce(lambda x, y: x+' '+y, sys.argv[1:]) + options.arguments = " ".join(shlex.quote(arg) for arg in sys.argv[1:]) return options def OptionsFromItems(items): diff --git a/Configuration/Eras/python/Era_Run3_2023_cff.py b/Configuration/Eras/python/Era_Run3_2023_cff.py index 8b0911446723b..fe3cf605b4095 100644 --- a/Configuration/Eras/python/Era_Run3_2023_cff.py +++ b/Configuration/Eras/python/Era_Run3_2023_cff.py @@ -2,6 +2,6 @@ from Configuration.Eras.Era_Run3_cff import Run3 from Configuration.Eras.Modifier_run3_egamma_2023_cff import run3_egamma_2023 -from Configuration.Eras.Modifier_run3_scouting_nanoAOD_2023_cff import run3_scouting_nanoAOD_2023 +from Configuration.Eras.Modifier_run3_scouting_2023_cff import run3_scouting_2023 -Run3_2023 = cms.ModifierChain(Run3, run3_egamma_2023, run3_scouting_nanoAOD_2023) +Run3_2023 = cms.ModifierChain(Run3, run3_egamma_2023, run3_scouting_2023) diff --git a/Configuration/Eras/python/Era_Run3_2024_cff.py b/Configuration/Eras/python/Era_Run3_2024_cff.py index 8d597707c5330..228b259d51ce6 100644 --- a/Configuration/Eras/python/Era_Run3_2024_cff.py +++ b/Configuration/Eras/python/Era_Run3_2024_cff.py @@ -2,6 +2,6 @@ from Configuration.Eras.Era_Run3_cff import Run3 from Configuration.Eras.Modifier_stage2L1Trigger_2024_cff import stage2L1Trigger_2024 -from Configuration.Eras.Modifier_run3_scouting_nanoAOD_2024_cff import run3_scouting_nanoAOD_2024 +from Configuration.Eras.Modifier_run3_scouting_2024_cff import run3_scouting_2024 -Run3_2024 = cms.ModifierChain(Run3, stage2L1Trigger_2024, run3_scouting_nanoAOD_2024) +Run3_2024 = cms.ModifierChain(Run3, stage2L1Trigger_2024, run3_scouting_2024) diff --git a/Configuration/Eras/python/Era_Run3_2025_cff.py b/Configuration/Eras/python/Era_Run3_2025_cff.py index 72b0e3851c440..2f02b9bf75c4b 100644 --- a/Configuration/Eras/python/Era_Run3_2025_cff.py +++ b/Configuration/Eras/python/Era_Run3_2025_cff.py @@ -6,8 +6,9 @@ from Configuration.Eras.Modifier_stage2L1Trigger_2025_cff import stage2L1Trigger_2025 from Configuration.Eras.Modifier_run3_SiPixel_2025_cff import run3_SiPixel_2025 from Configuration.Eras.Modifier_run3_nanoAOD_2025_cff import run3_nanoAOD_2025 +from Configuration.Eras.Modifier_run3_scouting_2025_cff import run3_scouting_2025 from Configuration.ProcessModifiers.ecal_cctiming_cff import ecal_cctiming from Configuration.ProcessModifiers.siPixelGoodEdgeAlgo_cff import siPixelGoodEdgeAlgo from Configuration.ProcessModifiers.siPixelDigiMorphing_cff import siPixelDigiMorphing -Run3_2025 = cms.ModifierChain(Run3_2024, run3_GEM_2025, stage2L1Trigger_2025, run3_SiPixel_2025, run3_CSC_2025, run3_nanoAOD_2025, ecal_cctiming, siPixelGoodEdgeAlgo, siPixelDigiMorphing) +Run3_2025 = cms.ModifierChain(Run3_2024, run3_GEM_2025, stage2L1Trigger_2025, run3_SiPixel_2025, run3_CSC_2025, run3_nanoAOD_2025, run3_scouting_2025, ecal_cctiming, siPixelGoodEdgeAlgo, siPixelDigiMorphing) diff --git a/Configuration/Eras/python/Modifier_run3_scouting_2023_cff.py b/Configuration/Eras/python/Modifier_run3_scouting_2023_cff.py new file mode 100644 index 0000000000000..f4ae11faed320 --- /dev/null +++ b/Configuration/Eras/python/Modifier_run3_scouting_2023_cff.py @@ -0,0 +1,3 @@ +import FWCore.ParameterSet.Config as cms + +run3_scouting_2023 = cms.Modifier() diff --git a/Configuration/Eras/python/Modifier_run3_scouting_2024_cff.py b/Configuration/Eras/python/Modifier_run3_scouting_2024_cff.py new file mode 100644 index 0000000000000..1c96a3e93cf84 --- /dev/null +++ b/Configuration/Eras/python/Modifier_run3_scouting_2024_cff.py @@ -0,0 +1,3 @@ +import FWCore.ParameterSet.Config as cms + +run3_scouting_2024 = cms.Modifier() diff --git a/Configuration/Eras/python/Modifier_run3_scouting_2025_cff.py b/Configuration/Eras/python/Modifier_run3_scouting_2025_cff.py new file mode 100644 index 0000000000000..145788d96598f --- /dev/null +++ b/Configuration/Eras/python/Modifier_run3_scouting_2025_cff.py @@ -0,0 +1,3 @@ +import FWCore.ParameterSet.Config as cms + +run3_scouting_2025 = cms.Modifier() diff --git a/Configuration/Eras/python/Modifier_run3_scouting_nanoAOD_2023_cff.py b/Configuration/Eras/python/Modifier_run3_scouting_nanoAOD_2023_cff.py deleted file mode 100644 index 6f93e9aae37ff..0000000000000 --- a/Configuration/Eras/python/Modifier_run3_scouting_nanoAOD_2023_cff.py +++ /dev/null @@ -1,3 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -run3_scouting_nanoAOD_2023 = cms.Modifier() diff --git a/Configuration/Eras/python/Modifier_run3_scouting_nanoAOD_2024_cff.py b/Configuration/Eras/python/Modifier_run3_scouting_nanoAOD_2024_cff.py deleted file mode 100644 index c468cc109c616..0000000000000 --- a/Configuration/Eras/python/Modifier_run3_scouting_nanoAOD_2024_cff.py +++ /dev/null @@ -1,3 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -run3_scouting_nanoAOD_2024 = cms.Modifier() diff --git a/Configuration/Geometry/python/GeometryDD4hepExtendedRun4D500Reco_cff.py b/Configuration/Geometry/python/GeometryDD4hepExtendedRun4D500Reco_cff.py new file mode 100644 index 0000000000000..de1d4ff03fec3 --- /dev/null +++ b/Configuration/Geometry/python/GeometryDD4hepExtendedRun4D500Reco_cff.py @@ -0,0 +1,16 @@ +import FWCore.ParameterSet.Config as cms + +# This config was generated automatically using generateRun4Geometry.py +# If you notice a mistake, please update the generating script, not just this config + +from Configuration.Geometry.GeometryDD4hepExtendedRun4D500_cff import * + +# tracker +from Geometry.CommonTopologies.globalTrackingGeometry_cfi import * +from RecoTracker.GeometryESProducer.TrackerRecoGeometryESProducer_cfi import * +from Geometry.TrackerGeometryBuilder.TrackerAdditionalParametersPerDet_cfi import * +from Geometry.TrackerGeometryBuilder.trackerParameters_cff import * +from Geometry.TrackerNumberingBuilder.trackerTopology_cfi import * +from Geometry.TrackerGeometryBuilder.idealForDigiTrackerGeometry_cff import * +trackerGeometry.applyAlignment = True + diff --git a/Configuration/Geometry/python/GeometryDD4hepExtendedRun4D500_cff.py b/Configuration/Geometry/python/GeometryDD4hepExtendedRun4D500_cff.py new file mode 100644 index 0000000000000..79c99ca38250f --- /dev/null +++ b/Configuration/Geometry/python/GeometryDD4hepExtendedRun4D500_cff.py @@ -0,0 +1,10 @@ +import FWCore.ParameterSet.Config as cms + +# This config was generated automatically using generateRun4Geometry.py +# If you notice a mistake, please update the generating script, not just this config + +from Configuration.Geometry.GeometryDD4hep_cff import * +DDDetectorESProducer.confGeomXMLFiles = cms.FileInPath("Geometry/CMSCommonData/data/dd4hep/cmsExtendedGeometryRun4D500.xml") + +from Geometry.TrackerNumberingBuilder.trackerNumberingGeometry_cff import * +from SLHCUpgradeSimulations.Geometry.fakePhase2OuterTrackerConditions_cff import * diff --git a/Configuration/Geometry/python/GeometryExtendedRun4D500Reco_cff.py b/Configuration/Geometry/python/GeometryExtendedRun4D500Reco_cff.py new file mode 100644 index 0000000000000..f5626300e232e --- /dev/null +++ b/Configuration/Geometry/python/GeometryExtendedRun4D500Reco_cff.py @@ -0,0 +1,16 @@ +import FWCore.ParameterSet.Config as cms + +# This config was generated automatically using generateRun4Geometry.py +# If you notice a mistake, please update the generating script, not just this config + +from Configuration.Geometry.GeometryExtendedRun4D500_cff import * + +# tracker +from Geometry.CommonTopologies.globalTrackingGeometry_cfi import * +from RecoTracker.GeometryESProducer.TrackerRecoGeometryESProducer_cfi import * +from Geometry.TrackerGeometryBuilder.TrackerAdditionalParametersPerDet_cfi import * +from Geometry.TrackerGeometryBuilder.trackerParameters_cff import * +from Geometry.TrackerNumberingBuilder.trackerTopology_cfi import * +from Geometry.TrackerGeometryBuilder.idealForDigiTrackerGeometry_cff import * +trackerGeometry.applyAlignment = True + diff --git a/Configuration/Geometry/python/GeometryExtendedRun4D500_cff.py b/Configuration/Geometry/python/GeometryExtendedRun4D500_cff.py new file mode 100644 index 0000000000000..04d0287953b6f --- /dev/null +++ b/Configuration/Geometry/python/GeometryExtendedRun4D500_cff.py @@ -0,0 +1,8 @@ +import FWCore.ParameterSet.Config as cms + +# This config was generated automatically using generateRun4Geometry.py +# If you notice a mistake, please update the generating script, not just this config + +from Geometry.CMSCommonData.cmsExtendedGeometryRun4D500XML_cfi import * +from Geometry.TrackerNumberingBuilder.trackerNumberingGeometry_cff import * +from SLHCUpgradeSimulations.Geometry.fakePhase2OuterTrackerConditions_cff import * diff --git a/Configuration/Geometry/python/dictCRACKIIGeometry.py b/Configuration/Geometry/python/dictCRACKIIGeometry.py new file mode 100644 index 0000000000000..7983a10da81d2 --- /dev/null +++ b/Configuration/Geometry/python/dictCRACKIIGeometry.py @@ -0,0 +1,64 @@ +maxSections = 1 + +commonDict = { + "abbrev" : "O", + "name" : "common", + "default" : 9, + "O10" : { + 1 : [ + 'Geometry/CMSCommonData/data/materials/2021/v1/materials.xml', + 'Geometry/TrackerCommonData/data/trackermaterial/2021/v2/trackermaterial.xml', + 'Geometry/CMSCommonData/data/rotations.xml', + 'Geometry/CMSCommonData/data/extend/v2/cmsextent.xml', + 'Geometry/CMSCommonData/data/cavernData/2021/v1/cavernData.xml', + 'Geometry/CMSCommonData/data/cms/2030/v5/cms.xml', + #'Geometry/TrackerCommonData/data/CRack_PhaseII/cms.xml' + 'Geometry/CMSCommonData/data/cmsMother.xml', + 'Geometry/CMSCommonData/data/eta3/etaMax.xml', + 'Geometry/CMSCommonData/data/cmsTracker.xml', + + ], + 5 : [ + 'Geometry/CMSCommonData/data/FieldParameters.xml', + ], + "era" : "phase2_common, phase2_trigger", + }, +} + + +trackerDict = { + "abbrev" : "T", + "name" : "tracker", + "default" : 34, + "TCRACK" : { + 1 : [ + 'Geometry/TrackerCommonData/data/PhaseII/TFPXTEPXReordered/trackerParameters.xml', + 'Geometry/TrackerCommonData/data/trackermaterial.xml', + 'Geometry/TrackerCommonData/data/CRack_PhaseII/tracker.xml', + 'Geometry/TrackerCommonData/data/CRack_PhaseII/tob.xml', + 'Geometry/TrackerCommonData/data/CRack_PhaseII/trackersens.xml', + 'Geometry/TrackerCommonData/data/CRack_PhaseII/trackerStructureTopology.xml', + + ], + "sim" : [ + 'from Geometry.TrackerNumberingBuilder.trackerNumberingGeometry_cff import *', + 'from SLHCUpgradeSimulations.Geometry.fakePhase2OuterTrackerConditions_cff import *', + ], + "reco" : [ + 'from Geometry.CommonTopologies.globalTrackingGeometry_cfi import *', + 'from RecoTracker.GeometryESProducer.TrackerRecoGeometryESProducer_cfi import *', + 'from Geometry.TrackerGeometryBuilder.TrackerAdditionalParametersPerDet_cfi import *', + 'from Geometry.TrackerGeometryBuilder.trackerParameters_cff import *', + 'from Geometry.TrackerNumberingBuilder.trackerTopology_cfi import *', + 'from Geometry.TrackerGeometryBuilder.idealForDigiTrackerGeometry_cff import *', + 'trackerGeometry.applyAlignment = True', + ], + "era" : "phase2_tracker, phase2_3DPixels, trackingPhase2PU140", + }, +} + +allDicts = [commonDict,trackerDict] + +detectorVersionDict = { + ("O10","TCRACK") : "D500", +} diff --git a/Configuration/Geometry/scripts/generateCRACKIIGeometry.py b/Configuration/Geometry/scripts/generateCRACKIIGeometry.py new file mode 100644 index 0000000000000..62cc3fa728812 --- /dev/null +++ b/Configuration/Geometry/scripts/generateCRACKIIGeometry.py @@ -0,0 +1,7 @@ +from Configuration.Geometry.dictCRACKIIGeometry import * +from Configuration.Geometry.generateGeometry import * + +if __name__ == "__main__": + # create geometry generator object w/ Run4 content and run it + generatorRun4 = GeometryGenerator("generateRun4Geometry.py",999,"D","Run4",maxSections,allDicts,detectorVersionDict) + generatorRun4.run() diff --git a/Configuration/ProcessModifiers/python/run2_miniAOD_miniAODUL_cff.py b/Configuration/ProcessModifiers/python/run2_miniAOD_miniAODUL_cff.py new file mode 100644 index 0000000000000..2830b81edf5cc --- /dev/null +++ b/Configuration/ProcessModifiers/python/run2_miniAOD_miniAODUL_cff.py @@ -0,0 +1,6 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier is for common settings to run miniAOD on top of +# ultra-legacy (during LS2) Run-2 MINIAOD + +run2_miniAOD_miniAODUL = cms.Modifier() diff --git a/Configuration/ProcessModifiers/python/run3_miniAOD_miniAODpre142X_cff.py b/Configuration/ProcessModifiers/python/run3_miniAOD_miniAODpre142X_cff.py new file mode 100644 index 0000000000000..c069e482dbab0 --- /dev/null +++ b/Configuration/ProcessModifiers/python/run3_miniAOD_miniAODpre142X_cff.py @@ -0,0 +1,6 @@ +import FWCore.ParameterSet.Config as cms + +# This modifier is for common settings to run miniAOD on top of +# Run-3 MINIAOD produced prior to 14.2 release + +run3_miniAOD_miniAODpre142X = cms.Modifier() diff --git a/Configuration/PyReleaseValidation/python/relval_nano.py b/Configuration/PyReleaseValidation/python/relval_nano.py index 482c01834a52d..4a77aa9f11379 100644 --- a/Configuration/PyReleaseValidation/python/relval_nano.py +++ b/Configuration/PyReleaseValidation/python/relval_nano.py @@ -79,23 +79,60 @@ def next(self, index: int = None) -> None: '--customise': '"Configuration/DataProcessing/Utils.addMonitoring"' }]) _HARVEST_mc = merge([_HARVEST_nano, {'--mc': ''}]) +## the validation sequence VALIDATION:@miniAODValidation will not function on M2M, because it requires AOD-bound collections TBF +## the dqm sequence DQM:@miniAODDQM will not function on M2M, because it requires AOD-bound collections TBF +#_MINI_from_MINI = {'-s': 'PAT:Configuration/StandardSequences/REMINI_cff.patAlgosToolsTask,DQM:@miniAODDQM', +# '--process': 'M2M'} +_MINI_from_MINI = {'-s': 'PAT:Configuration/StandardSequences/REMINI_cff.patAlgosToolsTask', + '--eventcontent' : 'MINIAODSIM', + '--datatier' : 'MINIAODSIM', + '--process': 'M2M'} +_MINI_from_MINI_data = merge([{'--data': '', + '--eventcontent' : 'MINIAOD', + '--datatier' : 'MINIAOD'}, + _MINI_from_MINI]) steps['HRV_NANO_mc'] = _HARVEST_mc +steps['HRV3_NANO_mc'] = merge([{'--filein':'file:step3_inDQM.root'}, + _HARVEST_mc]) steps['HRV_NANO_data'] = _HARVEST_data +steps['HRV3_NANO_data'] = merge([{'--filein':'file:step3_inDQM.root'}, + _HARVEST_data]) ################################################################ # 10.6 INPUT and workflows +steps['TTbarAOD10.6_UL16APV'] = {'INPUT': InputInfo( + location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL16RECOAPV-106X_mcRun2_asymptotic_preVFP_v8-v2/AODSIM')} +steps['MINI_mc10.6ul16APV'] = merge([{'--procModifiers':'run2_miniAOD_UL'}, steps['REMINIAOD_mc2016UL_preVFP']]) +steps['M2M_mc10.6ul16APV'] = merge([_MINI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul16APV']]) +steps['TTbarMINIAOD10.6_UL16APVv2'] = {'INPUT': InputInfo( + location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL16MiniAODAPVv2-106X_mcRun2_asymptotic_preVFP_v11-v2/MINIAODSIM')} +steps['NANO_mc10.6ul16APVv2'] = merge([{'--era': 'Run2_2016_HIPM,run2_nanoAOD_106Xv2', + '--conditions': 'auto:run2_mc'}, + _NANO_mc]) +steps['TTbarAOD10.6_UL16'] = {'INPUT': InputInfo( + location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL16RECO-106X_mcRun2_asymptotic_v13-v2/AODSIM')} +steps['MINI_mc10.6ul16'] = merge([{'--procModifiers':'run2_miniAOD_UL'}, steps['REMINIAOD_mc2016UL_postVFP']]) +steps['M2M_mc10.6ul16'] = merge([_MINI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul16']]) steps['TTbarMINIAOD10.6_UL16v2'] = {'INPUT': InputInfo( location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL16MiniAODv2-106X_mcRun2_asymptotic_v17-v2/MINIAODSIM')} steps['NANO_mc10.6ul16v2'] = merge([{'--era': 'Run2_2016,run2_nanoAOD_106Xv2', '--conditions': 'auto:run2_mc'}, _NANO_mc]) # 2017 looking Monte-Carlo: two versions in 10.6 +steps['TTbarAOD10.6_UL17'] = {'INPUT': InputInfo( + location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL17RECO-106X_mc2017_realistic_v6-v2/AODSIM')} +steps['MINI_mc10.6ul17'] = merge([{'--procModifiers':'run2_miniAOD_UL'}, steps['REMINIAOD_mc2017UL']]) +steps['M2M_mc10.6ul17'] = merge([_MINI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul17']]) steps['TTbarMINIAOD10.6_UL17v2'] = {'INPUT': InputInfo( location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL17MiniAODv2-106X_mc2017_realistic_v9-v2/MINIAODSIM')} steps['NANO_mc10.6ul17v2'] = merge([{'--era': 'Run2_2017,run2_nanoAOD_106Xv2', '--conditions': 'auto:phase1_2017_realistic'}, _NANO_mc]) +steps['TTbarAOD10.6_UL18'] = {'INPUT': InputInfo( + location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL18RECO-106X_upgrade2018_realistic_v11_L1v1-v2/AODSIM')} +steps['MINI_mc10.6ul18'] = merge([{'--procModifiers':'run2_miniAOD_UL'}, steps['REMINIAOD_mc2018UL']]) +steps['M2M_mc10.6ul18'] = merge([_MINI_from_MINI, {'--procModifiers':'run2_miniAOD_miniAODUL'} ,steps['MINI_mc10.6ul18']]) steps['TTbarMINIAOD10.6_UL18v2'] = {'INPUT': InputInfo( location='STD', dataSet='/TTJets_SingleLeptFromT_TuneCP5_13TeV-madgraphMLM-pythia8/RunIISummer20UL18MiniAODv2-106X_upgrade2018_realistic_v16_L1v1-v2/MINIAODSIM')} steps['NANO_mc10.6ul18v2'] = merge([{'--era': 'Run2_2018,run2_nanoAOD_106Xv2', @@ -105,12 +142,14 @@ def next(self, index: int = None) -> None: # HIPM_UL2016_MiniAODv2 campaign is CMSSW_10_6_25 steps['MuonEG2016MINIAOD10.6v2'] = {'INPUT': InputInfo(location='STD', ls=run2_lumis, dataSet='/MuonEG/Run2016E-HIPM_UL2016_MiniAODv2-v2/MINIAOD')} +steps['M2M_data10.6ul16'] = merge([_MINI_from_MINI_data, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2016UL']]) steps['NANO_data10.6ul16v2'] = merge([{'--era': 'Run2_2016_HIPM,run2_nanoAOD_106Xv2', '--conditions': 'auto:run2_data'}, _NANO_data]) # UL2017_MiniAODv2 campaign is CMSSW_10_6_20 steps['MuonEG2017MINIAOD10.6v2'] = {'INPUT': InputInfo(location='STD', ls=run2_lumis, dataSet='/MuonEG/Run2017F-UL2017_MiniAODv2-v1/MINIAOD')} +steps['M2M_data10.6ul17'] = merge([_MINI_from_MINI_data, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2017UL']]) steps['NANO_data10.6ul17v2'] = merge([{'--era': 'Run2_2017,run2_nanoAOD_106Xv2', '--conditions': 'auto:run2_data'}, _NANO_data]) @@ -118,12 +157,14 @@ def next(self, index: int = None) -> None: # UL2018_MiniAODv2 campaign is CMSSW_10_6_20 steps['MuonEG2018MINIAOD10.6v2'] = {'INPUT': InputInfo(location='STD', ls=run2_lumis, dataSet='/MuonEG/Run2018D-UL2018_MiniAODv2-v1/MINIAOD')} +steps['M2M_data10.6ul18'] = merge([_MINI_from_MINI_data, {'--procModifiers':'run2_miniAOD_miniAODUL'}, steps['REMINIAOD_data2018UL']]) steps['NANO_data10.6ul18v2'] = merge([{'--era': 'Run2_2018,run2_nanoAOD_106Xv2', '--conditions': 'auto:run2_data'}, _NANO_data]) ################################################################ # Run2UL re-MINI/NANO +## below: nano steps in current release, using MINI redone with the current release, either from AOD or MINIAOD steps['NANO_mc_UL16APVreMINI'] = merge([{'--era': 'Run2_2016_HIPM', '--conditions': 'auto:run2_mc_pre_vfp'}, _NANO_mc]) @@ -150,26 +191,58 @@ def next(self, index: int = None) -> None: '--conditions': 'auto:run2_data'}, _NANO_data]) +################################################################ +# 12.4 workflows -- data +steps['ScoutingPFRun3_Run2022D_RAW_124X'] = {'INPUT': InputInfo( + dataSet='/ScoutingPFRun3/Run2022D-v1/RAW', label='2022D', events=100000, location='STD', ls=Run2022D)} + +steps['ScoutingPFMonitor_Run2022D_RAW_124X'] = {'INPUT': InputInfo( + dataSet='/ScoutingPFMonitor/Run2022D-v1/RAW', label='2022D', events=100000, location='STD', ls=Run2022D)} + +steps['NANO_data12.4'] = merge([{'--era': 'Run3,run3_nanoAOD_pre142X', '--conditions': 'auto:run3_data'}, + _NANO_data]) + +steps['scoutingNANO_data12.4'] = merge([{'-s': 'NANO:@Scout'}, + steps['NANO_data12.4']]) + +steps['scoutingNANO_monitor_data12.4'] = merge([{'-s': 'NANO:@ScoutMonitor'}, + steps['NANO_data12.4']]) + ################################################################ # 13.0 workflows steps['TTbarMINIAOD13.0'] = {'INPUT': InputInfo( location='STD', dataSet='/TTtoLNu2Q_TuneCP5_13p6TeV_powheg-pythia8/Run3Summer23MiniAODv4-130X_mcRun3_2023_realistic_v14-v2/MINIAODSIM')} - +steps['M2M_mc13.0s23'] = merge([{'--era': 'Run3', '--conditions': 'auto:phase1_2023_realistic', '--procModifier': 'run3_miniAOD_miniAODpre142X'}, + steps['M2M_mc10.6ul18']]) steps['NANO_mc13.0'] = merge([{'--era': 'Run3,run3_nanoAOD_pre142X', '--conditions': 'auto:phase1_2023_realistic'}, _NANO_mc]) - +## below: nano steps in current release, using MINI redone with the current release, either from AOD or MINIAOD +steps['NANO_mc_S23reMINI'] = merge([{'--era': 'Run3', '--conditions': 'auto:phase1_2023_realistic'}, + _NANO_mc]) +#steps['NANO_mc_S22reMINI'] = merge([{'--era': 'Run3', '--conditions': 'auto:phase1_2023_realistic'},## fig GT +# _NANO_mc]) +#steps['NANO_mc_S22EEreMINI'] = merge([{'--era': 'Run3', '--conditions': 'auto:phase1_2023_realistic'},## fig GT +# _NANO_mc]) +#steps['NANO_mc_S23reMINI'] = merge([{'--era': 'Run3_2023', '--conditions': 'auto:phase1_2023_realistic'},## fit GT +# _NANO_mc]) +#steps['NANO_mc_S23BPixreMINI'] = merge([{'--era': 'Run3_2023', '--conditions': 'auto:phase1_2023_realistic'},## fix GT +# _NANO_mc]) # 13.0 workflows -- data steps['MuonEG2023MINIAOD13.0'] = {'INPUT': InputInfo(location='STD', ls={368489: [[46, 546]]}, dataSet='/MuonEG/Run2023C-22Sep2023_v4-v1/MINIAOD')} -steps['ScoutingPFRun32022RAW13.0'] = {'INPUT': InputInfo( - dataSet='/ScoutingPFRun3/Run2022D-v1/RAW', label='2022D', events=100000, location='STD', ls=Run2022D)} +steps['ScoutingPFRun3_Run2023D_RAW_130X'] = {'INPUT': InputInfo( + dataSet='/ScoutingPFRun3/Run2023D-v1/RAW', label='2023D', events=100000, location='STD', ls=Run2023D)} +steps['ScoutingPFMonitor_Run2023D_RAW_130X'] = {'INPUT': InputInfo( + dataSet='/ScoutingPFMonitor/Run2023D-v1/RAW', label='2023D', events=100000, location='STD', ls=Run2023D)} -steps['NANO_data13.0'] = merge([{'--era': 'Run3,run3_nanoAOD_pre142X', '--conditions': 'auto:run3_data'}, +steps['M2M_data13.0'] = merge([_MINI_from_MINI_data, {'--era': 'Run3', '--conditions': 'auto:run3_data', '--procModifier': 'run3_miniAOD_miniAODpre142X'}]) +steps['NANO_data13.0'] = merge([{'--era': 'Run3_2023,run3_nanoAOD_pre142X', '--conditions': 'auto:run3_data'}, _NANO_data]) - +steps['NANO_data_23reMINI'] = merge([{'--era': 'Run3_2023', '--conditions': 'auto:run3_data'}, + _NANO_data]) steps['NANO_data13.0_prompt'] = merge([{'-s': 'NANO:@Prompt,DQM:@nanoAODDQM', '-n': '1000'}, steps['NANO_data13.0']]) @@ -177,6 +250,9 @@ def next(self, index: int = None) -> None: steps['scoutingNANO_data13.0'] = merge([{'-s': 'NANO:@Scout'}, steps['NANO_data13.0']]) +steps['scoutingNANO_monitor_data13.0'] = merge([{'-s': 'NANO:@ScoutMonitor'}, + steps['NANO_data13.0']]) + ################################################################ # current release cycle workflows : 14.0 @@ -264,8 +340,11 @@ def next(self, index: int = None) -> None: steps['scoutingNANO_data14.0'] = merge([{'-s': 'NANO:@Scout'}, steps['NANO_data14.0']]) -steps['scoutingNANO_withPrompt_data14.0'] = merge([{'-s': 'NANO:@Prompt+@ScoutMonitor'}, - steps['NANO_data14.0']]) +steps['scoutingNANO_monitor_data14.0'] = merge([{'-s': 'NANO:@Prompt+@ScoutMonitor'}, + steps['NANO_data14.0']]) + +steps['scoutingNANO_monitorWithPrompt_data14.0'] = merge([{'-s': 'NANO:@Prompt+@ScoutMonitor'}, + steps['NANO_data14.0']]) steps['l1ScoutingNANO_data14.0'] = merge([{'-s': 'NANO:@L1Scout', '-n': '1000'}, steps['NANO_data14.0']]) @@ -381,8 +460,11 @@ def next(self, index: int = None) -> None: steps['scoutingNANO_data15.0'] = merge([{'-s': 'NANO:@Scout'}, steps['NANO_data15.0']]) -steps['scoutingNANO_withPrompt_data15.0'] = merge([{'-s': 'NANO:@Prompt+@ScoutMonitor'}, - steps['NANO_data15.0']]) +steps['scoutingNANO_monitor_data15.0'] = merge([{'-s': 'NANO:@ScoutMonitor'}, + steps['NANO_data15.0']]) + +steps['scoutingNANO_monitorWithPrompt_data15.0'] = merge([{'-s': 'NANO:@Prompt+@ScoutMonitor'}, + steps['NANO_data15.0']]) ################################################################ # NANOGEN @@ -400,6 +482,7 @@ def next(self, index: int = None) -> None: ######## 2500.0xxx ######## # Run2, 10_6_X MiniAOD input (current recommendation for 2016--2018) workflows[_wfn()] = ['NANOmc106Xul16v2', ['TTbarMINIAOD10.6_UL16v2', 'NANO_mc10.6ul16v2', 'HRV_NANO_mc']] +workflows[_wfn()] = ['NANOmc106Xul16APVv2', ['TTbarMINIAOD10.6_UL16APVv2', 'NANO_mc10.6ul16APVv2', 'HRV_NANO_mc']] workflows[_wfn()] = ['NANOmc106Xul17v2', ['TTbarMINIAOD10.6_UL17v2', 'NANO_mc10.6ul17v2', 'HRV_NANO_mc']] workflows[_wfn()] = ['NANOmc106Xul18v2', ['TTbarMINIAOD10.6_UL18v2', 'NANO_mc10.6ul18v2', 'HRV_NANO_mc']] @@ -410,16 +493,27 @@ def next(self, index: int = None) -> None: # Run2, 10_6_X AOD, reMINI+reNANO _wfn.subnext() -workflows[_wfn()] = ['NANOmcUL16APVreMINI', ['TTbar_13_reminiaod2016UL_preVFP_INPUT', 'REMINIAOD_mc2016UL_preVFP', 'NANO_mc_UL16APVreMINI', 'HRV_NANO_mc']] # noqa -workflows[_wfn()] = ['NANOmcUL16reMINI', ['TTbar_13_reminiaod2016UL_postVFP_INPUT', 'REMINIAOD_mc2016UL_postVFP', 'NANO_mc_UL16reMINI', 'HRV_NANO_mc']] # noqa -workflows[_wfn()] = ['NANOmcUL17reMINI', ['TTbar_13_reminiaod2017UL_INPUT', 'REMINIAOD_mc2017UL', 'NANO_mc_UL17reMINI', 'HRV_NANO_mc']] # noqa -workflows[_wfn()] = ['NANOmcUL18reMINI', ['TTbar_13_reminiaod2018UL_INPUT', 'REMINIAOD_mc2018UL', 'NANO_mc_UL18reMINI', 'HRV_NANO_mc']] # noqa +workflows[_wfn()] = ['NANOmcUL16APVreMINI', ['TTbarAOD10.6_UL16APV', 'MINI_mc10.6ul16APV', 'NANO_mc_UL16APVreMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL16reMINI', ['TTbarAOD10.6_UL16', 'MINI_mc10.6ul16', 'NANO_mc_UL16reMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL17reMINI', ['TTbarAOD10.6_UL17', 'MINI_mc10.6ul17', 'NANO_mc_UL17reMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL18reMINI', ['TTbarAOD10.6_UL18', 'MINI_mc10.6ul18', 'NANO_mc_UL18reMINI', 'HRV3_NANO_mc']] + +_wfn.subnext() +workflows[_wfn()] = ['NANOdataUL16APVreMINI', ['RunJetHT2016E_reminiaodUL', 'REMINIAOD_data2016UL_HIPM', 'NANO_data_UL16APVreMINI', 'HRV3_NANO_data']] # noqa +workflows[_wfn()] = ['NANOdataUL16reMINI', ['RunJetHT2016H_reminiaodUL', 'REMINIAOD_data2016UL', 'NANO_data_UL16reMINI', 'HRV3_NANO_data']] # noqa +workflows[_wfn()] = ['NANOdataUL17reMINI', ['RunJetHT2017F_reminiaodUL', 'REMINIAOD_data2017UL', 'NANO_data_UL17reMINI', 'HRV3_NANO_data']] # noqa +workflows[_wfn()] = ['NANOdataUL18reMINI', ['RunJetHT2018D_reminiaodUL', 'REMINIAOD_data2018UL', 'NANO_data_UL18reMINI', 'HRV3_NANO_data']] # noqa _wfn.subnext() -workflows[_wfn()] = ['NANOdataUL16APVreMINI', ['RunJetHT2016E_reminiaodUL', 'REMINIAOD_data2016UL_HIPM', 'NANO_data_UL16APVreMINI', 'HRV_NANO_data']] # noqa -workflows[_wfn()] = ['NANOdataUL16reMINI', ['RunJetHT2016H_reminiaodUL', 'REMINIAOD_data2016UL', 'NANO_data_UL16reMINI', 'HRV_NANO_data']] # noqa -workflows[_wfn()] = ['NANOdataUL17reMINI', ['RunJetHT2017F_reminiaodUL', 'REMINIAOD_data2017UL', 'NANO_data_UL17reMINI', 'HRV_NANO_data']] # noqa -workflows[_wfn()] = ['NANOdataUL18reMINI', ['RunJetHT2018D_reminiaodUL', 'REMINIAOD_data2018UL', 'NANO_data_UL18reMINI', 'HRV_NANO_data']] # noqa +workflows[_wfn()] = ['NANOmcUL16APVMini2Mini', ['TTbarMINIAOD10.6_UL16APVv2', 'M2M_mc10.6ul16APV', 'NANO_mc_UL16APVreMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL16Mini2Mini', ['TTbarMINIAOD10.6_UL16v2', 'M2M_mc10.6ul16', 'NANO_mc_UL16reMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL17Mini2Mini', ['TTbarMINIAOD10.6_UL17v2', 'M2M_mc10.6ul17', 'NANO_mc_UL17reMINI', 'HRV3_NANO_mc']] +workflows[_wfn()] = ['NANOmcUL18Mini2Mini', ['TTbarMINIAOD10.6_UL18v2', 'M2M_mc10.6ul18', 'NANO_mc_UL18reMINI', 'HRV3_NANO_mc']] + +_wfn.subnext() +workflows[_wfn()] = ['NANOdataUL16Mini2Mini', ['MuonEG2016MINIAOD10.6v2', 'M2M_data10.6ul16', 'NANO_data_UL16reMINI', 'HRV3_NANO_data']] +workflows[_wfn()] = ['NANOdataUL17Mini2Mini', ['MuonEG2017MINIAOD10.6v2', 'M2M_data10.6ul17', 'NANO_data_UL17reMINI', 'HRV3_NANO_data']] +workflows[_wfn()] = ['NANOdataUL18Mini2Mini', ['MuonEG2018MINIAOD10.6v2', 'M2M_data10.6ul18', 'NANO_data_UL18reMINI', 'HRV3_NANO_data']] _wfn.next(1) ######## 2500.1xxx ######## @@ -429,12 +523,21 @@ def next(self, index: int = None) -> None: _wfn.subnext() workflows[_wfn()] = ['NANOdata130Xrun3', ['MuonEG2023MINIAOD13.0', 'NANO_data13.0', 'HRV_NANO_data']] +_wfn.subnext() +workflows[_wfn()] = ['NANOmc23Mini2Mini', ['TTbarMINIAOD13.0', 'M2M_mc13.0s23', 'NANO_mc_S23reMINI', 'HRV3_NANO_mc']] + +_wfn.subnext() +workflows[_wfn()] = ['NANOdata23Mini2Mini', ['MuonEG2023MINIAOD13.0', 'M2M_data13.0', 'NANO_data_23reMINI', 'HRV3_NANO_data']] + # POG/PAG custom NANOs, MC _wfn.subnext() # POG/PAG custom NANOs, data _wfn.subnext() -workflows[_wfn()] = ['ScoutingNANOdata130Xrun3', ['ScoutingPFRun32022RAW13.0', 'scoutingNANO_data13.0']] +workflows[_wfn()] = ['ScoutingNANOdata124Xrun3', ['ScoutingPFRun3_Run2022D_RAW_124X', 'scoutingNANO_data12.4']] +workflows[_wfn()] = ['ScoutingNANOmonitordata124Xrun3', ['ScoutingPFMonitor_Run2022D_RAW_124X', 'scoutingNANO_monitor_data12.4']] +workflows[_wfn()] = ['ScoutingNANOdata130Xrun3', ['ScoutingPFRun3_Run2023D_RAW_130X', 'scoutingNANO_data13.0']] +workflows[_wfn()] = ['ScoutingNANOmonitordata130Xrun3', ['ScoutingPFMonitor_Run2023D_RAW_130X', 'scoutingNANO_monitor_data13.0']] # DPG custom NANOs, data _wfn.subnext() @@ -467,7 +570,8 @@ def next(self, index: int = None) -> None: _wfn() # workflows[_wfn()] = ['jmeNANOrePuppidata140Xrun3', ['MuonEG2024MINIAOD14.0', 'jmeNANO_rePuppi_data14.0']] workflows[_wfn()] = ['lepTrackInfoNANOdata140Xrun3', ['MuonEG2024MINIAOD14.0', 'lepTrackInfoNANO_data14.0']] workflows[_wfn()] = ['ScoutingNANOdata140Xrun3', ['ScoutingPFRun32024RAW14.0', 'scoutingNANO_data14.0']] -workflows[_wfn()] = ['ScoutingNANOwithPromptdata140Xrun3', ['ScoutingPFMonitor2024MINIAOD14.0', 'scoutingNANO_withPrompt_data14.0']] +workflows[_wfn()] = ['ScoutingNANOmonitordata140Xrun3', ['ScoutingPFMonitor2024MINIAOD14.0', 'scoutingNANO_monitor_data14.0']] +workflows[_wfn()] = ['ScoutingNANOmonitorWithPromptdata140Xrun3', ['ScoutingPFMonitor2024MINIAOD14.0', 'scoutingNANO_monitorWithPrompt_data14.0']] workflows[_wfn()] = ['L1ScoutingNANOdata140Xrun3', ['L1Scouting2024RAW14.0', 'l1ScoutingNANO_data14.0']] workflows[_wfn()] = ['L1ScoutingSelectionNANOdata140Xrun3', ['L1ScoutingSelection2024RAW14.0', 'l1ScoutingSelectionNANO_data14.0']] @@ -488,11 +592,11 @@ def next(self, index: int = None) -> None: # MINIv6+NANOv15, MC _wfn.subnext() -workflows[_wfn()] = ['NANOmc2024reMINI', ['TTbar_13p6_Summer24_AOD_140X', 'REMINIAOD_mc2024', 'NANO_mc_Summer24_reMINI', 'HRV_NANO_mc']] # noqa +workflows[_wfn()] = ['NANOmc2024reMINI', ['TTbar_13p6_Summer24_AOD_140X', 'REMINIAOD_mc2024', 'NANO_mc_Summer24_reMINI', 'HRV3_NANO_mc']] # noqa # MINIv6+NANOv15, data _wfn.subnext() -workflows[_wfn()] = ['NANOdata2024reMINI', ['JetMET1_Run2024H_AOD_140X', 'REMINIAOD_data2024', 'NANO_data_2024_reMINI', 'HRV_NANO_data']] # noqa +workflows[_wfn()] = ['NANOdata2024reMINI', ['JetMET1_Run2024H_AOD_140X', 'REMINIAOD_data2024', 'NANO_data_2024_reMINI', 'HRV3_NANO_data']] # noqa _wfn.next(3) ######## 2500.3xxx ######## @@ -526,7 +630,8 @@ def next(self, index: int = None) -> None: workflows[_wfn()] = ['jmeNANOrePuppidata150Xrun3', ['JetMET1_Run2025C_MINIAOD_150X', 'jmeNANO_rePuppi_data15.0']] workflows[_wfn()] = ['lepTrackInfoNANOdata150Xrun3', ['JetMET1_Run2025C_MINIAOD_150X', 'lepTrackInfoNANO_data15.0']] workflows[_wfn()] = ['ScoutingNANOdata150Xrun3', ['ScoutingPFRun3_Run2025C_HLTSCOUT_150X', 'scoutingNANO_data15.0']] -workflows[_wfn()] = ['ScoutingNANOwithPromptdata150Xrun3', ['ScoutingPFMonitor_Run2025C_MINIAOD_150X', 'scoutingNANO_withPrompt_data15.0']] # noqa +workflows[_wfn()] = ['ScoutingNANOmonitordata150Xrun3', ['ScoutingPFMonitor_Run2025C_MINIAOD_150X', 'scoutingNANO_monitor_data15.0']] # noqa +workflows[_wfn()] = ['ScoutingNANOmonitorWithPromptdata150Xrun3', ['ScoutingPFMonitor_Run2025C_MINIAOD_150X', 'scoutingNANO_monitorWithPrompt_data15.0']] # noqa workflows[_wfn()] = ['BPHNANOdata150Xrun3', ['JetMET1_Run2025C_MINIAOD_150X', 'BPHNANO_data15.0']] # DPG custom NANOs, data diff --git a/Configuration/PyReleaseValidation/scripts/das-up-to-nevents.py b/Configuration/PyReleaseValidation/scripts/das-up-to-nevents.py index 976de3b8bb214..1526931391f06 100755 --- a/Configuration/PyReleaseValidation/scripts/das-up-to-nevents.py +++ b/Configuration/PyReleaseValidation/scripts/das-up-to-nevents.py @@ -13,6 +13,7 @@ import sys import itertools import json +import re ## Helpers base_cert_url = "https://cms-service-dqmdc.web.cern.ch/CAF/certification/" @@ -143,35 +144,31 @@ def no_intersection(): elif "HI" in PD: cert_type = "Collisions" + str(year) + "HI" - cert_path = base_cert_cvmfs + cert_type + "/" - web_fallback = True - + cvmfs_path = base_cert_cvmfs + cert_type + "/" + eos_path = "" + web_path = "" + json_list_full = [] ## if we have access to cvmfs we get from there ... - if os.path.isdir(cert_path): - cert_path = cert_path + "/latest/" - web_fallback = False - json_list = os.listdir(cert_path) - if len(json_list) == 0: - web_fallback == True - json_list = [c for c in json_list if "golden" in c.lower() and "era" not in c.lower() and "ppref" not in c.lower()] - json_list = [c for c in json_list if c.lower().startswith("cert_c") and c.endswith("json")] - + if os.path.isdir(cvmfs_path): + cvmfs_path = cvmfs_path + "/latest/" + json_list_full = os.listdir(cvmfs_path) ## ... if not we try eos ... - if web_fallback and os.path.isdir(base_cert_eos + cert_type +"/"): - web_fallback = False - cert_path = base_cert_eos + cert_type +"/" - json_list = os.listdir(cert_path) - if len(json_list) == 0: - web_fallback == True - json_list = [c for c in json_list if "golden" in c.lower() and "era" not in c.lower() and "ppref" not in c.lower()] - json_list = [c for c in json_list if c.lower().startswith("cert_c") and c.endswith("json")] - + if len(json_list_full)==0: + eos_path = base_cert_eos + cert_type + "/" + if os.path.isdir(eos_path): + json_list_full = os.listdir(eos_path) ## ... if not we go to the website - if web_fallback: - cert_url = base_cert_url + cert_type + "/" - json_list = get_url_clean(cert_url).split("\n") - json_list = [c for c in json_list if "golden" in c.lower() and "era" not in c.lower() and "cert_c" in c.lower() and "ppref" not in c.lower()] - json_list = [[cc for cc in c.split(" ") if cc.lower().startswith("cert_c") and cc.endswith("json")][0] for c in json_list] + if len(json_list_full)==0: + web_path = base_cert_url + cert_type + "/" + json_list_full = get_url_clean(web_path).split("\n") + pattern = re.compile("(cert_collisions\d{4}_\d*_\d*_golden.json)(\s|$)", re.IGNORECASE) + json_list = [match.group(1) for entry in json_list_full for match in [re.search(pattern, entry)] if match and match.group(1)] + if len(json_list)==0: + raise RuntimeError("No matching JSON files found from {source} ({path}). The full list was:\n{list_full}".format( + source="web" if web_path else "eos" if eos_path else "cvmfs", + path=web_path if web_path else eos_path if eos_path else cvmfs_path, + list_full='\n'.join(json_list_full), + )) # the larger the better, assuming file naming schema # Cert_X_RunStart_RunFinish_Type.json @@ -179,11 +176,11 @@ def no_intersection(): run_ranges = [int(c.split("_")[-2]) - int(c.split("_")[-3]) for c in json_list] latest_json = np.array(json_list[np.argmax(run_ranges)]).reshape(1,-1)[0].astype(str) best_json = str(latest_json[0]) - if not web_fallback: - with open(cert_path + "/" + best_json) as js: + if not web_path: + with open((eos_path if eos_path else cvmfs_path) + "/" + best_json) as js: golden = json.load(js) else: - golden = get_url_clean(cert_url + best_json) + golden = get_url_clean(web_path + best_json) golden = ast.literal_eval(golden) #converts string to dict # skim for runs in input diff --git a/Configuration/StandardSequences/python/GeometryConf.py b/Configuration/StandardSequences/python/GeometryConf.py index b2c8bd1c940c4..b1e7766f40347 100644 --- a/Configuration/StandardSequences/python/GeometryConf.py +++ b/Configuration/StandardSequences/python/GeometryConf.py @@ -144,4 +144,6 @@ 'DD4hepExtendedRun4D122' : 'DD4hepExtendedRun4D122,DD4hepExtendedRun4D122Reco', 'ExtendedRun4D123' : 'ExtendedRun4D123,ExtendedRun4D123Reco', 'DD4hepExtendedRun4D123' : 'DD4hepExtendedRun4D123,DD4hepExtendedRun4D123Reco', + 'ExtendedRun4D500' : 'ExtendedRun4D500,ExtendedRun4D500Reco', + 'DD4hepExtendedRun4D500' : 'DD4hepExtendedRun4D500,DD4hepExtendedRun4D500Reco', } diff --git a/Configuration/StandardSequences/python/PATMC_cff.py b/Configuration/StandardSequences/python/PATMC_cff.py deleted file mode 100644 index 7927523f55a75..0000000000000 --- a/Configuration/StandardSequences/python/PATMC_cff.py +++ /dev/null @@ -1,15 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -from PhysicsTools.PatAlgos.producersLayer1.patCandidates_cff import * -from PhysicsTools.PatAlgos.selectionLayer1.selectedPatCandidates_cff import * -from PhysicsTools.PatAlgos.slimming.slimming_cff import * -from RecoLuminosity.LumiProducer.bunchSpacingProducer_cfi import * - -patTask = cms.Task( - patCandidatesTask, - selectedPatCandidatesTask, - slimmingTask, - bunchSpacingProducer -) - -miniAOD=cms.Sequence() diff --git a/Configuration/StandardSequences/python/PAT_cff.py b/Configuration/StandardSequences/python/PAT_cff.py index 7927523f55a75..5d0fe3f406e17 100644 --- a/Configuration/StandardSequences/python/PAT_cff.py +++ b/Configuration/StandardSequences/python/PAT_cff.py @@ -12,4 +12,8 @@ bunchSpacingProducer ) -miniAOD=cms.Sequence() +from PhysicsTools.PatAlgos.slimming.miniAOD_tools import miniAOD_customizeAllData +from PhysicsTools.PatAlgos.slimming.miniAOD_tools import miniAOD_customizeAllMC + +## include cms.Path defined from event filters +from PhysicsTools.PatAlgos.slimming.metFilterPaths_cff import * diff --git a/Configuration/StandardSequences/python/REMINI_cff.py b/Configuration/StandardSequences/python/REMINI_cff.py new file mode 100644 index 0000000000000..6f0a979dc67d9 --- /dev/null +++ b/Configuration/StandardSequences/python/REMINI_cff.py @@ -0,0 +1,7 @@ +import FWCore.ParameterSet.Config as cms + +patAlgosToolsTask = cms.Task() + +from PhysicsTools.PatAlgos.slimming.miniAODFromMiniAOD_tools import miniAODFromMiniAOD_customizeAllData as miniAOD_customizeAllData +from PhysicsTools.PatAlgos.slimming.miniAODFromMiniAOD_tools import miniAODFromMiniAOD_customizeAllMC as miniAOD_customizeAllMC + diff --git a/DQMOffline/JetMET/python/jetMETDQMOfflineSource_cff.py b/DQMOffline/JetMET/python/jetMETDQMOfflineSource_cff.py index d92b4a5e59a4f..d8fcb47ab0fd3 100644 --- a/DQMOffline/JetMET/python/jetMETDQMOfflineSource_cff.py +++ b/DQMOffline/JetMET/python/jetMETDQMOfflineSource_cff.py @@ -9,12 +9,21 @@ from RecoJets.JetProducers.QGTagger_cfi import * from RecoMET.METFilters.metFilters_cff import* -HcalStripHaloFilterDQM=HcalStripHaloFilter.clone(taggingMode = True) -CSCTightHaloFilterDQM=CSCTightHaloFilter.clone(taggingMode = True) -CSCTightHalo2015FilterDQM=CSCTightHalo2015Filter.clone(taggingMode = True) -eeBadScFilterDQM=eeBadScFilter.clone(taggingMode = True) -EcalDeadCellTriggerPrimitiveFilterDQM=EcalDeadCellTriggerPrimitiveFilter.clone(taggingMode = True) -EcalDeadCellBoundaryEnergyFilterDQM=EcalDeadCellBoundaryEnergyFilter.clone(taggingMode = True) + +## interferes with fastSim sequence that replaced these modules by an HLTBool module +## is it sufficient to have them scheduled with cms.ignore, and not need for tagging mode? +def clone_in_tagging_mode( m ): + if hasattr( m , 'taggingMode'): + return m.clone(taggingMode = True) + else: + return m.clone() + +HcalStripHaloFilterDQM = clone_in_tagging_mode( HcalStripHaloFilter ) +CSCTightHaloFilterDQM = clone_in_tagging_mode( CSCTightHaloFilter ) +CSCTightHalo2015FilterDQM = clone_in_tagging_mode( CSCTightHalo2015Filter ) +eeBadScFilterDQM = clone_in_tagging_mode( eeBadScFilter ) +EcalDeadCellTriggerPrimitiveFilterDQM = clone_in_tagging_mode( EcalDeadCellTriggerPrimitiveFilter ) +EcalDeadCellBoundaryEnergyFilterDQM = clone_in_tagging_mode( EcalDeadCellBoundaryEnergyFilter ) pileupJetIdCalculatorDQM=pileupJetIdCalculator.clone( jets = "ak4PFJets", diff --git a/DataFormats/PatCandidates/interface/Electron.h b/DataFormats/PatCandidates/interface/Electron.h index 860a470c142cf..177fa0bd7fc13 100644 --- a/DataFormats/PatCandidates/interface/Electron.h +++ b/DataFormats/PatCandidates/interface/Electron.h @@ -47,6 +47,7 @@ namespace reco { // Class definition namespace pat { class PATElectronSlimmer; + class PATElectronCandidatesRekeyer; class Electron : public Lepton { public: @@ -269,6 +270,7 @@ namespace pat { } friend class PATElectronSlimmer; + friend class PATElectronCandidatesRekeyer; protected: /// init impact parameter defaults (for use in a constructor) diff --git a/DataFormats/PatCandidates/interface/Muon.h b/DataFormats/PatCandidates/interface/Muon.h index 144985c46534e..a9054c8927350 100644 --- a/DataFormats/PatCandidates/interface/Muon.h +++ b/DataFormats/PatCandidates/interface/Muon.h @@ -47,6 +47,7 @@ namespace reco { namespace pat { class PATMuonSlimmer; + class PATMuonCandidatesRekeyer; class Muon : public Lepton { public: @@ -272,6 +273,7 @@ namespace pat { friend std::ostream& reco::operator<<(std::ostream& out, const pat::Muon& obj); friend class PATMuonSlimmer; + friend class PATMuonCandidatesRekeyer; float pfEcalEnergy() const { return pfEcalEnergy_; } void setPfEcalEnergy(float pfEcalEnergy) { pfEcalEnergy_ = pfEcalEnergy; } diff --git a/DataFormats/PatCandidates/interface/Photon.h b/DataFormats/PatCandidates/interface/Photon.h index 4f661bf68c632..4ce2d99821825 100644 --- a/DataFormats/PatCandidates/interface/Photon.h +++ b/DataFormats/PatCandidates/interface/Photon.h @@ -42,6 +42,7 @@ namespace reco { // Class definition namespace pat { class PATPhotonSlimmer; + class PATPhotonCandidatesRekeyer; class Photon : public PATObject { public: @@ -328,6 +329,7 @@ namespace pat { reco::CandidatePtr sourceCandidatePtr(size_type i) const override; friend class PATPhotonSlimmer; + friend class PATPhotonCandidatesRekeyer; protected: // ---- for content embedding ---- diff --git a/EventFilter/Utilities/interface/EvFDaqDirector.h b/EventFilter/Utilities/interface/EvFDaqDirector.h index 74c99b1a3eede..ccc45166c7b94 100644 --- a/EventFilter/Utilities/interface/EvFDaqDirector.h +++ b/EventFilter/Utilities/interface/EvFDaqDirector.h @@ -139,8 +139,12 @@ namespace evf { bool requireHeader, bool retry, bool closeFile); + + uint16_t frdFileDataType(const void* buf) const; + int grabNextJsonFromRaw(std::string const& rawSourcePath, int& rawFd, + uint16_t& rawDataType, uint16_t& rawHeaderSize, int64_t& fileSizeFromHeader, bool& fileFound, @@ -157,6 +161,7 @@ namespace evf { unsigned int& ls, std::string& nextFile, int& rawFd, + uint16_t& rawDataType, uint16_t& rawHeaderSize, int32_t& serverEventsInNewFile_, int64_t& fileSize, diff --git a/EventFilter/Utilities/interface/SourceRawFile.h b/EventFilter/Utilities/interface/SourceRawFile.h index 5ec3840d603d6..f9d110b47c160 100644 --- a/EventFilter/Utilities/interface/SourceRawFile.h +++ b/EventFilter/Utilities/interface/SourceRawFile.h @@ -95,6 +95,7 @@ class InputFile { std::vector bufferEnds_; std::vector fileSizes_; std::vector fileOrder_; + std::vector fileDataType_; bool deleteFile_; int rawFd_; uint64_t fileSize_; @@ -115,6 +116,7 @@ class InputFile { std::string const& name = std::string(), bool deleteFile = true, int rawFd = -1, + uint16_t rawDataType = 0, uint64_t fileSize = 0, uint16_t rawHeaderSize = 0, uint16_t nChunks = 0, @@ -134,6 +136,7 @@ class InputFile { nProcessed_(0) { fileNames_.push_back(name); fileOrder_.push_back(fileOrder_.size()); + fileDataType_.push_back(rawDataType); diskFileSizes_.push_back(fileSize); fileSizes_.push_back(0); bufferOffsets_.push_back(0); @@ -159,6 +162,7 @@ class InputFile { numFiles_++; fileNames_.push_back(name); fileOrder_.push_back(fileOrder_.size()); + fileDataType_.push_back(0); diskFileSizes_.push_back(size); fileSizes_.push_back(0); bufferOffsets_.push_back(prevOffset + prevSize); @@ -205,6 +209,13 @@ class InputFile { throw cms::Exception("InputFile") << "buffers are inconsistent for input files with primary " << fileName_; return complete > 0; } + void setFileDataType(unsigned int j, uint16_t dataType) { fileDataType_[j] = dataType; } + int daqRunEndFlagIndex() const { + for (unsigned j = 0; j < fileDataType_.size(); j++) + if (fileDataType_[j] == 0xffff) + return (int)j; + return -1; + } }; class DAQSource; @@ -216,12 +227,14 @@ class RawInputFile : public InputFile { std::string const& name = std::string(), bool deleteFile = true, int rawFd = -1, + uint16_t rawDataType = 0, uint64_t fileSize = 0, uint16_t rawHeaderSize = 0, uint32_t nChunks = 0, int nEvents = 0, DAQSource* parent = nullptr) - : InputFile(status, lumi, name, deleteFile, rawFd, fileSize, rawHeaderSize, nChunks, nEvents, nullptr), + : InputFile( + status, lumi, name, deleteFile, rawFd, rawDataType, fileSize, rawHeaderSize, nChunks, nEvents, nullptr), sourceParent_(parent) {} bool advance(std::mutex& m, std::condition_variable& cv, unsigned char*& dataPosition, const size_t size); void advance(const size_t size) { diff --git a/EventFilter/Utilities/plugins/RawEventFileWriterForBU.cc b/EventFilter/Utilities/plugins/RawEventFileWriterForBU.cc index 5052af2ed8beb..4526c72335eb5 100644 --- a/EventFilter/Utilities/plugins/RawEventFileWriterForBU.cc +++ b/EventFilter/Utilities/plugins/RawEventFileWriterForBU.cc @@ -25,6 +25,7 @@ using namespace edm::streamer; RawEventFileWriterForBU::RawEventFileWriterForBU(edm::ParameterSet const& ps) : microSleep_(ps.getParameter("microSleep")), frdFileVersion_(ps.getParameter("frdFileVersion")), + dataType_(ps.getUntrackedParameter("dataType")), writeEoR_(ps.getUntrackedParameter("writeEoR")), writeToOpen_(ps.getUntrackedParameter("writeToOpen")) { if (edm::Service().isAvailable()) @@ -247,7 +248,8 @@ void RawEventFileWriterForBU::finishFileWrite(unsigned int ls) { << " and size " << perFileSize_.value(); } else if (frdFileVersion_ == 2) { lseek(outfd_, 0, SEEK_SET); - FRDFileHeader_v2 frdFileHeader(0, perFileEventCount_.value(), (uint32_t)run_, (uint32_t)ls, perFileSize_.value()); + FRDFileHeader_v2 frdFileHeader( + (uint16_t)(dataType_ & 0xffff), perFileEventCount_.value(), (uint32_t)run_, (uint32_t)ls, perFileSize_.value()); write(outfd_, (char*)&frdFileHeader, sizeof(FRDFileHeader_v2)); closefd(); //move raw file from open to run directory @@ -342,5 +344,6 @@ void RawEventFileWriterForBU::stop() { void RawEventFileWriterForBU::extendDescription(edm::ParameterSetDescription& desc) { desc.add("microSleep", 0); desc.add("frdFileVersion", 0); + desc.addUntracked("dataType", 0)->setComment("data typw field in FRD file header v2"); desc.addUntracked("writeEoR", true); } diff --git a/EventFilter/Utilities/plugins/RawEventFileWriterForBU.h b/EventFilter/Utilities/plugins/RawEventFileWriterForBU.h index e1bfc6cc49ba0..2919def148ba2 100644 --- a/EventFilter/Utilities/plugins/RawEventFileWriterForBU.h +++ b/EventFilter/Utilities/plugins/RawEventFileWriterForBU.h @@ -88,6 +88,7 @@ class RawEventFileWriterForBU { int microSleep_; unsigned int frdFileVersion_; + unsigned int dataType_; bool writeEoR_; bool writeToOpen_; diff --git a/EventFilter/Utilities/src/DAQSource.cc b/EventFilter/Utilities/src/DAQSource.cc index 5c6d2d84a4f25..53c1d4a232aad 100644 --- a/EventFilter/Utilities/src/DAQSource.cc +++ b/EventFilter/Utilities/src/DAQSource.cc @@ -464,7 +464,21 @@ evf::EvFDaqDirector::FileStatus DAQSource::getNextDataBlock() { heldFilesCount_--; //release last chunk (it is never released elsewhere) freeChunks_.push(currentFile_->chunks_[currentFile_->currentChunk_]); - if (currentFile_->nEvents_ >= 0 && currentFile_->nEvents_ != int(currentFile_->nProcessed_)) { + + bool filesIncomplete = currentFile_->nEvents_ >= 0 && currentFile_->nEvents_ != int(currentFile_->nProcessed_); + bool retRunEnd = false; + + int runEndFlagIndex = currentFile_->daqRunEndFlagIndex(); + if (runEndFlagIndex != -1) { + if (filesIncomplete) + edm::LogError("DAQSource::getNextDataBlock") + << "Detected DAQ Run End flag in RAW file " << currentFile_->fileNames_[runEndFlagIndex]; + else + edm::LogError("DAQSource::getNextDataBlock") + << "Detected DAQ Run End flag in RAW file " << currentFile_->fileNames_[runEndFlagIndex] + << " but files appear to be complete"; + retRunEnd = true; + } else if (filesIncomplete) { std::stringstream str; for (auto& s : currentFile_->fileNames_) { struct stat bufs; @@ -499,7 +513,10 @@ evf::EvFDaqDirector::FileStatus DAQSource::getNextDataBlock() { currentFile_.reset(); } setMonState(inProcessingFile); - return evf::EvFDaqDirector::noFile; + if (retRunEnd) + return evf::EvFDaqDirector::runEnded; + else + return evf::EvFDaqDirector::noFile; } //handle RAW file header in new file @@ -794,6 +811,7 @@ void DAQSource::readSupervisor() { uint32_t lsFromRaw = 0; int32_t serverEventsInNewFile = -1; int rawFd = -1; + uint16_t rawDataType = 0; int backoff_exp = 0; @@ -838,7 +856,6 @@ void DAQSource::readSupervisor() { //return LS if LS not set, otherwise return file status = getFile(ls, nextFile, thisLockWaitTimeUs); if (status == evf::EvFDaqDirector::newFile) { - uint16_t rawDataType; if (evf::EvFDaqDirector::parseFRDFileHeader(nextFile, rawFd, rawHeaderSize, ///possibility to use by new formats @@ -866,6 +883,7 @@ void DAQSource::readSupervisor() { ls, nextFile, rawFd, + rawDataType, rawHeaderSize, //which format? serverEventsInNewFile, fileSizeFromMetadata, @@ -1058,6 +1076,7 @@ void DAQSource::readSupervisor() { rawFile, !fileListMode_, rawFd, + rawDataType, fileSize, rawHeaderSize, //for which format 0, @@ -1347,6 +1366,7 @@ void DAQSource::readWorker(unsigned int tid) { size_t skipped = bufferLeft; auto start = std::chrono::high_resolution_clock::now(); + for (unsigned int i = 0; i < readBlocks; i++) { ssize_t last; edm::LogInfo("DAQSource") << "readWorker read -: " << (int64_t)(chunk->usedSize_ - bufferLeft) << " or " @@ -1408,8 +1428,7 @@ void DAQSource::readWorker(unsigned int tid) { LogDebug("DAQSource") << " finished reading block -: " << (bufferLeft >> 20) << " MB" << " in " << msec.count() << " ms (" << (bufferLeft >> 20) / double(msec.count()) << " GB/s)"; - }; - //END primary function + }; //END primary function //SECONDARY files function auto readSecondary = [&](uint64_t bufferLeft, unsigned int j) { @@ -1446,6 +1465,11 @@ void DAQSource::readWorker(unsigned int tid) { close(fileDescriptor); break; } + if (i == 0) { + uint16_t dataType = daqDirector_->frdFileDataType(chunk->buf_ + bufferLeft); + if (dataType) + file->setFileDataType(j, dataType); + } if (last > 0) { bufferLeft += last; fileLen += last; diff --git a/EventFilter/Utilities/src/EvFDaqDirector.cc b/EventFilter/Utilities/src/EvFDaqDirector.cc index b143702f830ac..e80703c6ba0e0 100644 --- a/EventFilter/Utilities/src/EvFDaqDirector.cc +++ b/EventFilter/Utilities/src/EvFDaqDirector.cc @@ -1226,8 +1226,22 @@ namespace evf { return false; } + uint16_t EvFDaqDirector::frdFileDataType(const void* buf) const { + //v2 is the largest possible read + const FRDFileHeader_v2* hdr = static_cast(buf); + + const FRDFileHeaderIdentifier* fileId = (const FRDFileHeaderIdentifier*)hdr; + uint16_t frd_version = getFRDFileHeaderVersion(fileId->id_, fileId->version_); + + if (frd_version == 2) { + return hdr->c_.dataType_; + } + return 0; + } + int EvFDaqDirector::grabNextJsonFromRaw(std::string const& rawSourcePath, int& rawFd, + uint16_t& rawDataType, uint16_t& rawHeaderSize, int64_t& fileSizeFromHeader, bool& fileFound, @@ -1255,7 +1269,6 @@ namespace evf { uint32_t lsFromRaw; int32_t nbEventsWrittenRaw; int64_t fileSizeFromRaw; - uint16_t rawDataType; auto ret = parseFRDFileHeader(rawSourcePath, rawFd, rawHeaderSize, @@ -2068,6 +2081,7 @@ namespace evf { unsigned int& ls, std::string& nextFileRaw, int& rawFd, + uint16_t& rawDataType, uint16_t& rawHeaderSize, int32_t& serverEventsInNewFile, int64_t& fileSizeFromMetadata, @@ -2166,8 +2180,15 @@ namespace evf { //error reading header, set to -1 and trigger error downstream serverEventsInNewFile = -1; } else if (rawHeader) { - serverEventsInNewFile = grabNextJsonFromRaw( - nextFileRaw, rawFd, rawHeaderSize, fileSizeFromMetadata, fileFound, serverLS, false, requireHeader); + serverEventsInNewFile = grabNextJsonFromRaw(nextFileRaw, + rawFd, + rawDataType, + rawHeaderSize, + fileSizeFromMetadata, + fileFound, + serverLS, + false, + requireHeader); } else if (eventCounter) { //there is no header: then try to use model to count events serverEventsInNewFile = eventCounter(nextFileRaw, rawFd, fileSizeFromMetadata, serverLS, fileFound); diff --git a/EventFilter/Utilities/src/FedRawDataInputSource.cc b/EventFilter/Utilities/src/FedRawDataInputSource.cc index be7754d531a1f..0dad45de16f9b 100644 --- a/EventFilter/Utilities/src/FedRawDataInputSource.cc +++ b/EventFilter/Utilities/src/FedRawDataInputSource.cc @@ -850,6 +850,7 @@ void FedRawDataInputSource::readSupervisor() { uint32_t lsFromRaw = 0; int32_t serverEventsInNewFile = -1; int rawFd = -1; + uint16_t rawDataType = 0; int backoff_exp = 0; @@ -895,7 +896,6 @@ void FedRawDataInputSource::readSupervisor() { //return LS if LS not set, otherwise return file status = getFile(ls, nextFile, fileSizeIndex, thisLockWaitTimeUs); if (status == evf::EvFDaqDirector::newFile) { - uint16_t rawDataType; if (evf::EvFDaqDirector::parseFRDFileHeader(nextFile, rawFd, rawHeaderSize, @@ -922,6 +922,7 @@ void FedRawDataInputSource::readSupervisor() { ls, nextFile, rawFd, + rawDataType, rawHeaderSize, serverEventsInNewFile, fileSizeFromMetadata, @@ -1102,7 +1103,7 @@ void FedRawDataInputSource::readSupervisor() { uint16_t rawHeaderCheck; bool fileFound; eventsInNewFile = daqDirector_->grabNextJsonFromRaw( - nextFile, rawFdEmpty, rawHeaderCheck, fileSizeFromMetadata, fileFound, 0, true); + nextFile, rawFdEmpty, rawDataType, rawHeaderCheck, fileSizeFromMetadata, fileFound, 0, true); assert(fileFound && rawHeaderCheck == rawHeaderSize); daqDirector_->unlockFULocal(); } else @@ -1125,6 +1126,7 @@ void FedRawDataInputSource::readSupervisor() { rawFile, !fileListMode_, rawFd, + rawDataType, fileSize, rawHeaderSize, neededChunks, diff --git a/EventFilter/Utilities/test/startBU.py b/EventFilter/Utilities/test/startBU.py index 3e14eff964617..b64c24e417936 100644 --- a/EventFilter/Utilities/test/startBU.py +++ b/EventFilter/Utilities/test/startBU.py @@ -82,7 +82,11 @@ VarParsing.VarParsing.varType.int, # string, int, or float "Write only to open directory") - +options.register ('eventDataType', + 0, + VarParsing.VarParsing.multiplicity.singleton, + VarParsing.VarParsing.varType.int, + "Event data type value in FRD file header v2") options.parseArguments() @@ -161,6 +165,7 @@ numEventsPerFile = cms.uint32(options.eventsPerFile), frdVersion = cms.uint32(6), frdFileVersion = cms.uint32(options.frdFileVersion), + dataType = cms.untracked.uint32(options.eventDataType), writeToOpen = cms.untracked.bool(True if options.writeToOpen else False) ) @@ -178,6 +183,7 @@ numEventsPerFile = cms.uint32(options.eventsPerFile), frdVersion = cms.uint32(0), frdFileVersion = cms.uint32(0), + dataType = cms.untracked.uint32(options.eventDataType), sourceIdList = cms.untracked.vuint32(66,1511), rawProductName = cms.untracked.string("RawDataBuffer") ) diff --git a/EventFilter/Utilities/test/testIncompleteSFB.sh b/EventFilter/Utilities/test/testIncompleteSFB.sh new file mode 100755 index 0000000000000..4d825e721243a --- /dev/null +++ b/EventFilter/Utilities/test/testIncompleteSFB.sh @@ -0,0 +1,96 @@ +#!/bin/bash +SCRIPTDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" + +function diebu { echo Failure $1: status $2 ; echo "" ; echo "----- Error -----"; echo ""; cat out_2_bu.log; rm -rf $3/{ramdisk,data,dqmdisk,ecalInDir,*.py}; exit $2 ; } +function diefu { echo Failure $1: status $2 ; echo "" ; echo "----- Error -----"; echo ""; cat out_2_fu.log; rm -rf $3/{ramdisk,data,dqmdisk,ecalInDir,*.py}; exit $2 ; } +function diedqm { echo Failure $1: status $2 ; echo "" ; echo "----- Error -----"; echo ""; cat out_2_dqm.log; rm -rf $3/{ramdisk,data,dqmdisk,ecalInDir,*.py}; exit $2 ; } +function dieecal { echo Failure $1: status $2 ; echo "" ; echo "----- Error -----"; echo ""; cat out_2_ecal.log; rm -rf $3/{ramdisk,data,dqmdisk,ecalInDir,*.py}; exit $2 ; } + +copy_index_files() { + directory=$1 + sourceid=$2 + del_orig=$3 + shopt -s nullglob + for file in "$directory"/*_index*.raw; do + filename=$(basename "$file") + if [[ "$filename" =~ ^(.*)_index([0-9]+)\.raw$ ]]; then + base="${BASH_REMATCH[1]}" + x="${BASH_REMATCH[2]}" + new_name="${base}_index${x}_source${sourceid}.raw" + cp -- "$file" "$directory/$new_name" + #echo "Copied: $filename -> $new_name" + if [[ $del_orig -eq 1 ]]; then + rm -rf $file + fi + fi + done + shopt -u nullglob +} + +copy_json_files() { + directory=$1 + sourceid=$2 + shopt -s nullglob + for file in "$directory"/*.jsn; do + filename=$(basename "$file") + if [[ "$filename" =~ ^(.*)_EoR.jsn$ ]]; then + base="${BASH_REMATCH[1]}" + x="${BASH_REMATCH[2]}" + new_name="${base}_EoR_source${sourceid}.jsn" + mv "$file" "$directory/$new_name" + fi + if [[ "$filename" =~ ^(.*)_EoLS.jsn$ ]]; then + base="${BASH_REMATCH[1]}" + x="${BASH_REMATCH[2]}" + new_name="${base}_EoLS_source${sourceid}.jsn" + mv "$file" "$directory/$new_name" + fi + done + shopt -u nullglob +} + +FUSCRIPT="startFU.py" + +if [ -z ${SCRAM_TEST_PATH} ]; then +SCRAM_TEST_PATH="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" +fi +echo "SCRAM_TEST_PATH = ${SCRAM_TEST_PATH}" + +RC=0 +P=$$ +PREFIX=results_${USER}${P} +OUTDIR=${PWD}/${PREFIX} + +echo "OUT_TMP_DIR = $OUTDIR" + +mkdir ${OUTDIR} +cp ${SCRIPTDIR}/startBU.py ${OUTDIR} +cp ${SCRIPTDIR}/startFU.py ${OUTDIR} +cp ${SCRIPTDIR}/ufu2.py ${OUTDIR} +cp ${SCRIPTDIR}/startFU_daqsource.py ${OUTDIR} +cp ${SCRIPTDIR}/unittest_FU_daqsource.py ${OUTDIR} +cp ${SCRIPTDIR}/startFU_ds_multi.py ${OUTDIR} +cp ${SCRIPTDIR}/test_dqmstream.py ${OUTDIR} +cp ${SCRIPTDIR}/testECALCalib_cfg.py ${OUTDIR} +cd ${OUTDIR} + +rm -rf $OUTDIR/{ramdisk,data,dqmdisk,ecalInDir,*.log} + +runnumber="100101" + +################ +echo "Running fileListMode test" + +echo "running DAQSource test with striped event FRD (SFB)" +CMDLINE_STARTBU="cmsRun startBU.py runNumber=${runnumber} fffBaseDir=${OUTDIR} maxLS=2 fedMeanSize=128 eventsPerFile=20 eventsPerLS=35 frdFileVersion=2 buBaseDir=ramdisk1 subsystems=TCDS,SiPixel,ECAL,RPC" +#CMDLINE_STARTBU="cmsRun startBU.py runNumber=${runnumber} fffBaseDir=${OUTDIR} maxLS=2 fedMeanSize=128 eventsPerFile=20 eventsPerLS=35 frdFileVersion=2 buBaseDir=ramdisk1 subsystems=TCDS,SiPixel,ECAL,RPC eventDataType=65535" +${CMDLINE_STARTBU} +CMDLINE_STARTBU="cmsRun startBU.py runNumber=${runnumber} fffBaseDir=${OUTDIR} maxLS=2 fedMeanSize=128 eventsPerFile=20 eventsPerLS=35 frdFileVersion=2 buBaseDir=ramdisk2 subsystems=SiStrip,HCAL,DT,CSC eventDataType=65535" +#CMDLINE_STARTBU="cmsRun startBU.py runNumber=${runnumber} fffBaseDir=${OUTDIR} maxLS=2 fedMeanSize=128 eventsPerFile=20 eventsPerLS=35 frdFileVersion=2 buBaseDir=ramdisk2 subsystems=SiStrip,HCAL,DT,CSC" +${CMDLINE_STARTBU} +#run reader +CMDLINE_STARTFU="cmsRun startFU_daqsource.py daqSourceMode=FRDStriped runNumber=${runnumber} fffBaseDir=${OUTDIR} numRamdisks=2" +${CMDLINE_STARTFU} + +rm -rf $OUTDIR +exit ${RC} diff --git a/FWCore/FWLite/test/ref_t.cppunit.cpp b/FWCore/FWLite/test/ref_t.cppunit.cpp index 865be3ca8e929..4b5aaff90165a 100644 --- a/FWCore/FWLite/test/ref_t.cppunit.cpp +++ b/FWCore/FWLite/test/ref_t.cppunit.cpp @@ -216,6 +216,7 @@ void testRefInROOT::testGoodChain() { TChain eventChain(edm::poolNames::eventTreeName().c_str()); eventChain.Add("good.root"); eventChain.Add("good_delta5.root"); + eventChain.LoadTree(0); edm::Wrapper* pOthers = nullptr; TBranch* othersBranch = nullptr; diff --git a/Geometry/CMSCommonData/data/dd4hep/cmsExtendedGeometryRun4D500.xml b/Geometry/CMSCommonData/data/dd4hep/cmsExtendedGeometryRun4D500.xml new file mode 100644 index 0000000000000..65d73ca5d8779 --- /dev/null +++ b/Geometry/CMSCommonData/data/dd4hep/cmsExtendedGeometryRun4D500.xml @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Geometry/CMSCommonData/python/cmsExtendedGeometryRun4D500XML_cfi.py b/Geometry/CMSCommonData/python/cmsExtendedGeometryRun4D500XML_cfi.py new file mode 100644 index 0000000000000..972f76ce4304f --- /dev/null +++ b/Geometry/CMSCommonData/python/cmsExtendedGeometryRun4D500XML_cfi.py @@ -0,0 +1,25 @@ +import FWCore.ParameterSet.Config as cms + +# This config was generated automatically using generateRun4Geometry.py +# If you notice a mistake, please update the generating script, not just this config + +XMLIdealGeometryESSource = cms.ESSource("XMLIdealGeometryESSource", + geomXMLFiles = cms.vstring( + 'Geometry/CMSCommonData/data/materials/2021/v1/materials.xml', + 'Geometry/TrackerCommonData/data/trackermaterial/2021/v2/trackermaterial.xml', + 'Geometry/CMSCommonData/data/rotations.xml', + 'Geometry/CMSCommonData/data/extend/v2/cmsextent.xml', + 'Geometry/CMSCommonData/data/cavernData/2021/v1/cavernData.xml', + 'Geometry/CMSCommonData/data/cms/2030/v5/cms.xml', + 'Geometry/CMSCommonData/data/cmsMother.xml', + 'Geometry/CMSCommonData/data/eta3/etaMax.xml', + 'Geometry/CMSCommonData/data/cmsTracker.xml', + 'Geometry/TrackerCommonData/data/PhaseII/TFPXTEPXReordered/trackerParameters.xml', + 'Geometry/TrackerCommonData/data/trackermaterial.xml', + 'Geometry/TrackerCommonData/data/CRack_PhaseII/tracker.xml', + 'Geometry/TrackerCommonData/data/CRack_PhaseII/tob.xml', + 'Geometry/TrackerCommonData/data/CRack_PhaseII/trackersens.xml', + 'Geometry/TrackerCommonData/data/CRack_PhaseII/trackerStructureTopology.xml', + ), + rootNodeName = cms.string('cms:OCMS') +) diff --git a/Geometry/HGCalGeometry/data/missingIDsV19.txt b/Geometry/HGCalGeometry/data/missingIDsV19.txt new file mode 100644 index 0000000000000..fe4d43b09aa18 --- /dev/null +++ b/Geometry/HGCalGeometry/data/missingIDsV19.txt @@ -0,0 +1,2704 @@ +2283021352 +2283021384 +2283021416 +2283021448 +2283021480 +2283021512 +2283021544 +2283021576 +2283021608 +2283021640 +2283021672 +2283021704 +2283021736 +2283021768 +2283021800 +2283021353 +2283021385 +2283021417 +2283021449 +2283021481 +2283021513 +2283021545 +2283021577 +2283021609 +2283021641 +2283021673 +2283021705 +2283021737 +2283021769 +2283021801 +2283021386 +2283021418 +2283021450 +2283021482 +2283021514 +2283021546 +2283021578 +2283021610 +2283021642 +2283021674 +2283021706 +2283021738 +2283021770 +2283021802 +2283021419 +2283021451 +2283021483 +2283021515 +2283021547 +2283021579 +2283021611 +2283021643 +2283021675 +2283021707 +2283021739 +2283021771 +2283021803 +2283021452 +2283021484 +2283021516 +2283021548 +2283021580 +2283021612 +2283021644 +2283021676 +2283021708 +2283021740 +2283021772 +2283021804 +2283021485 +2283021517 +2283021549 +2283021581 +2283021613 +2283021645 +2283021677 +2283021709 +2283021741 +2283021773 +2283021805 +2283021518 +2283021550 +2283021582 +2283021614 +2283021646 +2283021678 +2283021710 +2283021742 +2283021774 +2283021806 +2283021551 +2283021583 +2283021615 +2283021647 +2283021679 +2283021711 +2283021743 +2283021775 +2283021807 +2282956928 +2282956960 +2282956992 +2282957024 +2282956929 +2282956961 +2282956993 +2282957025 +2282957057 +2282956962 +2282956994 +2282957026 +2282957058 +2282957090 +2282956963 +2282956995 +2282957027 +2282957059 +2282957091 +2282957123 +2282956996 +2282957028 +2282957060 +2282957092 +2282957124 +2282957156 +2282956997 +2282957029 +2282957061 +2282957093 +2282957125 +2282957157 +2282957189 +2282957030 +2282957062 +2282957094 +2282957126 +2282957158 +2282957190 +2282957222 +2282957031 +2282957063 +2282957095 +2282957127 +2282957159 +2282957191 +2282957223 +2282957255 +2282957064 +2282957096 +2282957128 +2282957160 +2282957192 +2282957224 +2282957256 +2282957288 +2282957065 +2282957097 +2282957129 +2282957161 +2282957193 +2282957225 +2282957257 +2282957289 +2282957098 +2282957130 +2282957162 +2282957194 +2282957226 +2282957258 +2282957290 +2282957099 +2282957131 +2282957163 +2282957195 +2282957227 +2282957259 +2282957291 +2282957132 +2282957164 +2282957196 +2282957228 +2282957260 +2282957292 +2282957133 +2282957165 +2282957197 +2282957229 +2282957261 +2282957293 +2282957166 +2282957198 +2282957230 +2282957262 +2282957294 +2282957167 +2282957199 +2282957231 +2282957263 +2282957295 +2283623552 +2283623584 +2283623616 +2283623648 +2283623553 +2283623585 +2283623617 +2283623649 +2283623681 +2283623586 +2283623618 +2283623650 +2283623682 +2283623714 +2283623587 +2283623619 +2283623651 +2283623683 +2283623715 +2283623747 +2283623620 +2283623652 +2283623684 +2283623716 +2283623748 +2283623780 +2283623621 +2283623653 +2283623685 +2283623717 +2283623749 +2283623781 +2283623813 +2283623654 +2283623686 +2283623718 +2283623750 +2283623782 +2283623814 +2283623846 +2283623655 +2283623687 +2283623719 +2283623751 +2283623783 +2283623815 +2283623847 +2283623879 +2283623688 +2283623720 +2283623752 +2283623784 +2283623816 +2283623848 +2283623880 +2283623912 +2283623689 +2283623721 +2283623753 +2283623785 +2283623817 +2283623849 +2283623881 +2283623913 +2283623722 +2283623754 +2283623786 +2283623818 +2283623850 +2283623882 +2283623914 +2283623723 +2283623755 +2283623787 +2283623819 +2283623851 +2283623883 +2283623915 +2283623756 +2283623788 +2283623820 +2283623852 +2283623884 +2283623916 +2283623757 +2283623789 +2283623821 +2283623853 +2283623885 +2283623917 +2283623790 +2283623822 +2283623854 +2283623886 +2283623918 +2283623791 +2283623823 +2283623855 +2283623887 +2283623919 +2283622528 +2283622560 +2283622592 +2283622624 +2283622529 +2283622561 +2283622593 +2283622625 +2283622657 +2283622562 +2283622594 +2283622626 +2283622658 +2283622690 +2283622563 +2283622595 +2283622627 +2283622659 +2283622691 +2283622723 +2283622596 +2283622628 +2283622660 +2283622692 +2283622724 +2283622756 +2283622597 +2283622629 +2283622661 +2283622693 +2283622725 +2283622757 +2283622789 +2283622630 +2283622662 +2283622694 +2283622726 +2283622758 +2283622790 +2283622822 +2283622631 +2283622663 +2283622695 +2283622727 +2283622759 +2283622791 +2283622823 +2283622855 +2283622664 +2283622696 +2283622728 +2283622760 +2283622792 +2283622824 +2283622856 +2283622888 +2283622665 +2283622697 +2283622729 +2283622761 +2283622793 +2283622825 +2283622857 +2283622889 +2283622698 +2283622730 +2283622762 +2283622794 +2283622826 +2283622858 +2283622890 +2283622699 +2283622731 +2283622763 +2283622795 +2283622827 +2283622859 +2283622891 +2283622732 +2283622764 +2283622796 +2283622828 +2283622860 +2283622892 +2283622733 +2283622765 +2283622797 +2283622829 +2283622861 +2283622893 +2283622766 +2283622798 +2283622830 +2283622862 +2283622894 +2283622767 +2283622799 +2283622831 +2283622863 +2283622895 +2283625472 +2283625504 +2283625536 +2283625568 +2283625473 +2283625505 +2283625537 +2283625569 +2283625601 +2283625474 +2283625506 +2283625538 +2283625570 +2283625602 +2283625475 +2283625507 +2283625539 +2283625571 +2283625603 +2283625635 +2283625476 +2283625508 +2283625540 +2283625572 +2283625604 +2283625636 +2283625477 +2283625509 +2283625541 +2283625573 +2283625605 +2283625637 +2283625669 +2283625478 +2283625510 +2283625542 +2283625574 +2283625606 +2283625638 +2283625670 +2283625479 +2283625511 +2283625543 +2283625575 +2283625607 +2283625639 +2283625671 +2283625703 +2283625480 +2283625512 +2283625544 +2283625576 +2283625608 +2283625640 +2283625672 +2283625704 +2283625513 +2283625545 +2283625577 +2283625609 +2283625641 +2283625673 +2283625705 +2283625737 +2283625546 +2283625578 +2283625610 +2283625642 +2283625674 +2283625706 +2283625738 +2283625579 +2283625611 +2283625643 +2283625675 +2283625707 +2283625739 +2283625771 +2283625612 +2283625644 +2283625676 +2283625708 +2283625740 +2283625772 +2283625645 +2283625677 +2283625709 +2283625741 +2283625773 +2283625805 +2283625678 +2283625710 +2283625742 +2283625774 +2283625806 +2283625711 +2283625743 +2283625775 +2283625807 +2283625839 +2283624448 +2283624480 +2283624512 +2283624544 +2283624449 +2283624481 +2283624513 +2283624545 +2283624577 +2283624450 +2283624482 +2283624514 +2283624546 +2283624578 +2283624451 +2283624483 +2283624515 +2283624547 +2283624579 +2283624611 +2283624452 +2283624484 +2283624516 +2283624548 +2283624580 +2283624612 +2283624453 +2283624485 +2283624517 +2283624549 +2283624581 +2283624613 +2283624645 +2283624454 +2283624486 +2283624518 +2283624550 +2283624582 +2283624614 +2283624646 +2283624455 +2283624487 +2283624519 +2283624551 +2283624583 +2283624615 +2283624647 +2283624679 +2283624456 +2283624488 +2283624520 +2283624552 +2283624584 +2283624616 +2283624648 +2283624680 +2283624489 +2283624521 +2283624553 +2283624585 +2283624617 +2283624649 +2283624681 +2283624713 +2283624522 +2283624554 +2283624586 +2283624618 +2283624650 +2283624682 +2283624714 +2283624555 +2283624587 +2283624619 +2283624651 +2283624683 +2283624715 +2283624747 +2283624588 +2283624620 +2283624652 +2283624684 +2283624716 +2283624748 +2283624621 +2283624653 +2283624685 +2283624717 +2283624749 +2283624781 +2283624654 +2283624686 +2283624718 +2283624750 +2283624782 +2283624687 +2283624719 +2283624751 +2283624783 +2283624815 +2283084800 +2283084832 +2283084864 +2283084896 +2283084801 +2283084833 +2283084865 +2283084897 +2283084929 +2283084802 +2283084834 +2283084866 +2283084898 +2283084930 +2283084803 +2283084835 +2283084867 +2283084899 +2283084931 +2283084963 +2283084804 +2283084836 +2283084868 +2283084900 +2283084932 +2283084964 +2283084805 +2283084837 +2283084869 +2283084901 +2283084933 +2283084965 +2283084997 +2283084806 +2283084838 +2283084870 +2283084902 +2283084934 +2283084966 +2283084998 +2283084807 +2283084839 +2283084871 +2283084903 +2283084935 +2283084967 +2283084999 +2283085031 +2283084808 +2283084840 +2283084872 +2283084904 +2283084936 +2283084968 +2283085000 +2283085032 +2283084841 +2283084873 +2283084905 +2283084937 +2283084969 +2283085001 +2283085033 +2283085065 +2283084874 +2283084906 +2283084938 +2283084970 +2283085002 +2283085034 +2283085066 +2283084907 +2283084939 +2283084971 +2283085003 +2283085035 +2283085067 +2283085099 +2283084940 +2283084972 +2283085004 +2283085036 +2283085068 +2283085100 +2283084973 +2283085005 +2283085037 +2283085069 +2283085101 +2283085133 +2283085006 +2283085038 +2283085070 +2283085102 +2283085134 +2283085039 +2283085071 +2283085103 +2283085135 +2283085167 +2283561992 +2283562024 +2283562056 +2283562088 +2283562120 +2283562152 +2283562184 +2283562216 +2283562248 +2283562280 +2283562312 +2283562344 +2283562376 +2283562408 +2283562440 +2283562472 +2283562025 +2283562057 +2283562089 +2283562121 +2283562153 +2283562185 +2283562217 +2283562249 +2283562281 +2283562313 +2283562345 +2283562377 +2283562409 +2283562441 +2283562473 +2283562058 +2283562090 +2283562122 +2283562154 +2283562186 +2283562218 +2283562250 +2283562282 +2283562314 +2283562346 +2283562378 +2283562410 +2283562442 +2283562474 +2283562091 +2283562123 +2283562155 +2283562187 +2283562219 +2283562251 +2283562283 +2283562315 +2283562347 +2283562379 +2283562411 +2283562443 +2283562475 +2283562124 +2283562156 +2283562188 +2283562220 +2283562252 +2283562284 +2283562316 +2283562348 +2283562380 +2283562412 +2283562444 +2283562476 +2283562157 +2283562189 +2283562221 +2283562253 +2283562285 +2283562317 +2283562349 +2283562381 +2283562413 +2283562445 +2283562477 +2283562190 +2283562222 +2283562254 +2283562286 +2283562318 +2283562350 +2283562382 +2283562414 +2283562446 +2283562478 +2283562223 +2283562255 +2283562287 +2283562319 +2283562351 +2283562383 +2283562415 +2283562447 +2283562479 +2283083776 +2283083808 +2283083840 +2283083872 +2283083777 +2283083809 +2283083841 +2283083873 +2283083905 +2283083778 +2283083810 +2283083842 +2283083874 +2283083906 +2283083779 +2283083811 +2283083843 +2283083875 +2283083907 +2283083939 +2283083780 +2283083812 +2283083844 +2283083876 +2283083908 +2283083940 +2283083781 +2283083813 +2283083845 +2283083877 +2283083909 +2283083941 +2283083973 +2283083782 +2283083814 +2283083846 +2283083878 +2283083910 +2283083942 +2283083974 +2283083783 +2283083815 +2283083847 +2283083879 +2283083911 +2283083943 +2283083975 +2283084007 +2283083784 +2283083816 +2283083848 +2283083880 +2283083912 +2283083944 +2283083976 +2283084008 +2283083817 +2283083849 +2283083881 +2283083913 +2283083945 +2283083977 +2283084009 +2283084041 +2283083850 +2283083882 +2283083914 +2283083946 +2283083978 +2283084010 +2283084042 +2283083883 +2283083915 +2283083947 +2283083979 +2283084011 +2283084043 +2283084075 +2283083916 +2283083948 +2283083980 +2283084012 +2283084044 +2283084076 +2283083949 +2283083981 +2283084013 +2283084045 +2283084077 +2283084109 +2283083982 +2283084014 +2283084046 +2283084078 +2283084110 +2283084015 +2283084047 +2283084079 +2283084111 +2283084143 +2283082880 +2283082912 +2283082944 +2283082976 +2283082881 +2283082913 +2283082945 +2283082977 +2283083009 +2283082914 +2283082946 +2283082978 +2283083010 +2283083042 +2283082915 +2283082947 +2283082979 +2283083011 +2283083043 +2283083075 +2283082948 +2283082980 +2283083012 +2283083044 +2283083076 +2283083108 +2283082949 +2283082981 +2283083013 +2283083045 +2283083077 +2283083109 +2283083141 +2283082982 +2283083014 +2283083046 +2283083078 +2283083110 +2283083142 +2283083174 +2283082983 +2283083015 +2283083047 +2283083079 +2283083111 +2283083143 +2283083175 +2283083207 +2283083016 +2283083048 +2283083080 +2283083112 +2283083144 +2283083176 +2283083208 +2283083240 +2283083017 +2283083049 +2283083081 +2283083113 +2283083145 +2283083177 +2283083209 +2283083241 +2283083050 +2283083082 +2283083114 +2283083146 +2283083178 +2283083210 +2283083242 +2283083051 +2283083083 +2283083115 +2283083147 +2283083179 +2283083211 +2283083243 +2283083084 +2283083116 +2283083148 +2283083180 +2283083212 +2283083244 +2283083085 +2283083117 +2283083149 +2283083181 +2283083213 +2283083245 +2283083118 +2283083150 +2283083182 +2283083214 +2283083246 +2283083119 +2283083151 +2283083183 +2283083215 +2283083247 +2283081856 +2283081888 +2283081920 +2283081952 +2283081857 +2283081889 +2283081921 +2283081953 +2283081985 +2283081890 +2283081922 +2283081954 +2283081986 +2283082018 +2283081891 +2283081923 +2283081955 +2283081987 +2283082019 +2283082051 +2283081924 +2283081956 +2283081988 +2283082020 +2283082052 +2283082084 +2283081925 +2283081957 +2283081989 +2283082021 +2283082053 +2283082085 +2283082117 +2283081958 +2283081990 +2283082022 +2283082054 +2283082086 +2283082118 +2283082150 +2283081959 +2283081991 +2283082023 +2283082055 +2283082087 +2283082119 +2283082151 +2283082183 +2283081992 +2283082024 +2283082056 +2283082088 +2283082120 +2283082152 +2283082184 +2283082216 +2283081993 +2283082025 +2283082057 +2283082089 +2283082121 +2283082153 +2283082185 +2283082217 +2283082026 +2283082058 +2283082090 +2283082122 +2283082154 +2283082186 +2283082218 +2283082027 +2283082059 +2283082091 +2283082123 +2283082155 +2283082187 +2283082219 +2283082060 +2283082092 +2283082124 +2283082156 +2283082188 +2283082220 +2283082061 +2283082093 +2283082125 +2283082157 +2283082189 +2283082221 +2283082094 +2283082126 +2283082158 +2283082190 +2283082222 +2283082095 +2283082127 +2283082159 +2283082191 +2283082223 +2283080832 +2283080864 +2283080896 +2283080928 +2283080833 +2283080865 +2283080897 +2283080929 +2283080961 +2283080866 +2283080898 +2283080930 +2283080962 +2283080994 +2283080867 +2283080899 +2283080931 +2283080963 +2283080995 +2283081027 +2283080900 +2283080932 +2283080964 +2283080996 +2283081028 +2283081060 +2283080901 +2283080933 +2283080965 +2283080997 +2283081029 +2283081061 +2283081093 +2283080934 +2283080966 +2283080998 +2283081030 +2283081062 +2283081094 +2283081126 +2283080935 +2283080967 +2283080999 +2283081031 +2283081063 +2283081095 +2283081127 +2283081159 +2283080968 +2283081000 +2283081032 +2283081064 +2283081096 +2283081128 +2283081160 +2283081192 +2283080969 +2283081001 +2283081033 +2283081065 +2283081097 +2283081129 +2283081161 +2283081193 +2283081002 +2283081034 +2283081066 +2283081098 +2283081130 +2283081162 +2283081194 +2283081003 +2283081035 +2283081067 +2283081099 +2283081131 +2283081163 +2283081195 +2283081036 +2283081068 +2283081100 +2283081132 +2283081164 +2283081196 +2283081037 +2283081069 +2283081101 +2283081133 +2283081165 +2283081197 +2283081070 +2283081102 +2283081134 +2283081166 +2283081198 +2283081071 +2283081103 +2283081135 +2283081167 +2283081199 +2283530368 +2283530400 +2283530432 +2283530464 +2283530369 +2283530401 +2283530433 +2283530465 +2283530497 +2283530402 +2283530434 +2283530466 +2283530498 +2283530530 +2283530403 +2283530435 +2283530467 +2283530499 +2283530531 +2283530563 +2283530436 +2283530468 +2283530500 +2283530532 +2283530564 +2283530596 +2283530437 +2283530469 +2283530501 +2283530533 +2283530565 +2283530597 +2283530629 +2283530470 +2283530502 +2283530534 +2283530566 +2283530598 +2283530630 +2283530662 +2283530471 +2283530503 +2283530535 +2283530567 +2283530599 +2283530631 +2283530663 +2283530695 +2283530504 +2283530536 +2283530568 +2283530600 +2283530632 +2283530664 +2283530696 +2283530728 +2283530505 +2283530537 +2283530569 +2283530601 +2283530633 +2283530665 +2283530697 +2283530729 +2283530538 +2283530570 +2283530602 +2283530634 +2283530666 +2283530698 +2283530730 +2283530539 +2283530571 +2283530603 +2283530635 +2283530667 +2283530699 +2283530731 +2283530572 +2283530604 +2283530636 +2283530668 +2283530700 +2283530732 +2283530573 +2283530605 +2283530637 +2283530669 +2283530701 +2283530733 +2283530606 +2283530638 +2283530670 +2283530702 +2283530734 +2283530607 +2283530639 +2283530671 +2283530703 +2283530735 +2149090304 +2149090336 +2149090368 +2149090305 +2149090337 +2149090369 +2149090306 +2149090338 +2149090370 +2149090402 +2149090307 +2149090339 +2149090371 +2149090403 +2149090308 +2149090340 +2149090372 +2149090404 +2149090436 +2149090309 +2149090341 +2149090373 +2149090405 +2149090437 +2149090310 +2149090342 +2149090374 +2149090406 +2149090438 +2149090470 +2149090311 +2149090343 +2149090375 +2149090407 +2149090439 +2149090471 +2149090312 +2149090344 +2149090376 +2149090408 +2149090440 +2149090472 +2149090504 +2149090313 +2149090345 +2149090377 +2149090409 +2149090441 +2149090473 +2149090505 +2149090314 +2149090346 +2149090378 +2149090410 +2149090442 +2149090474 +2149090506 +2149090538 +2149090315 +2149090347 +2149090379 +2149090411 +2149090443 +2149090475 +2149090507 +2149090539 +2149090316 +2149090348 +2149090380 +2149090412 +2149090444 +2149090476 +2149090508 +2149090540 +2149090572 +2149090349 +2149090381 +2149090413 +2149090445 +2149090477 +2149090509 +2149090541 +2149090573 +2149090382 +2149090414 +2149090446 +2149090478 +2149090510 +2149090542 +2149090574 +2149090606 +2149090415 +2149090447 +2149090479 +2149090511 +2149090543 +2149090575 +2149090607 +2149090448 +2149090480 +2149090512 +2149090544 +2149090576 +2149090608 +2149090640 +2149090481 +2149090513 +2149090545 +2149090577 +2149090609 +2149090641 +2149090514 +2149090546 +2149090578 +2149090610 +2149090642 +2149090674 +2149090547 +2149090579 +2149090611 +2149090643 +2149090675 +2149090580 +2149090612 +2149090644 +2149090676 +2149090708 +2149090613 +2149090645 +2149090677 +2149090709 +2149090646 +2149090678 +2149090710 +2149090742 +2149090679 +2149090711 +2149090743 +2282989696 +2282989728 +2282989760 +2282989792 +2282989697 +2282989729 +2282989761 +2282989793 +2282989825 +2282989730 +2282989762 +2282989794 +2282989826 +2282989858 +2282989731 +2282989763 +2282989795 +2282989827 +2282989859 +2282989891 +2282989764 +2282989796 +2282989828 +2282989860 +2282989892 +2282989924 +2282989765 +2282989797 +2282989829 +2282989861 +2282989893 +2282989925 +2282989957 +2282989798 +2282989830 +2282989862 +2282989894 +2282989926 +2282989958 +2282989990 +2282989799 +2282989831 +2282989863 +2282989895 +2282989927 +2282989959 +2282989991 +2282990023 +2282989832 +2282989864 +2282989896 +2282989928 +2282989960 +2282989992 +2282990024 +2282990056 +2282989833 +2282989865 +2282989897 +2282989929 +2282989961 +2282989993 +2282990025 +2282990057 +2282989866 +2282989898 +2282989930 +2282989962 +2282989994 +2282990026 +2282990058 +2282989867 +2282989899 +2282989931 +2282989963 +2282989995 +2282990027 +2282990059 +2282989900 +2282989932 +2282989964 +2282989996 +2282990028 +2282990060 +2282989901 +2282989933 +2282989965 +2282989997 +2282990029 +2282990061 +2282989934 +2282989966 +2282989998 +2282990030 +2282990062 +2282989935 +2282989967 +2282989999 +2282990031 +2282990063 +2282935459 +2282935587 +2282924160 +2282924192 +2282924224 +2282924256 +2282924161 +2282924193 +2282924225 +2282924257 +2282924289 +2282924194 +2282924226 +2282924258 +2282924290 +2282924322 +2282924195 +2282924227 +2282924259 +2282924291 +2282924323 +2282924355 +2282924228 +2282924260 +2282924292 +2282924324 +2282924356 +2282924388 +2282924229 +2282924261 +2282924293 +2282924325 +2282924357 +2282924389 +2282924421 +2282924262 +2282924294 +2282924326 +2282924358 +2282924390 +2282924422 +2282924454 +2282924263 +2282924295 +2282924327 +2282924359 +2282924391 +2282924423 +2282924455 +2282924487 +2282924296 +2282924328 +2282924360 +2282924392 +2282924424 +2282924456 +2282924488 +2282924520 +2282924297 +2282924329 +2282924361 +2282924393 +2282924425 +2282924457 +2282924489 +2282924521 +2282924330 +2282924362 +2282924394 +2282924426 +2282924458 +2282924490 +2282924522 +2282924331 +2282924363 +2282924395 +2282924427 +2282924459 +2282924491 +2282924523 +2282924364 +2282924396 +2282924428 +2282924460 +2282924492 +2282924524 +2282924365 +2282924397 +2282924429 +2282924461 +2282924493 +2282924525 +2282924398 +2282924430 +2282924462 +2282924494 +2282924526 +2282924399 +2282924431 +2282924463 +2282924495 +2282924527 +2148598508 +2283497600 +2283497632 +2283497664 +2283497696 +2283497601 +2283497633 +2283497665 +2283497697 +2283497729 +2283497634 +2283497666 +2283497698 +2283497730 +2283497762 +2283497635 +2283497667 +2283497699 +2283497731 +2283497763 +2283497795 +2283497668 +2283497700 +2283497732 +2283497764 +2283497796 +2283497828 +2283497669 +2283497701 +2283497733 +2283497765 +2283497797 +2283497829 +2283497861 +2283497702 +2283497734 +2283497766 +2283497798 +2283497830 +2283497862 +2283497894 +2283497703 +2283497735 +2283497767 +2283497799 +2283497831 +2283497863 +2283497895 +2283497927 +2283497736 +2283497768 +2283497800 +2283497832 +2283497864 +2283497896 +2283497928 +2283497960 +2283497737 +2283497769 +2283497801 +2283497833 +2283497865 +2283497897 +2283497929 +2283497961 +2283497770 +2283497802 +2283497834 +2283497866 +2283497898 +2283497930 +2283497962 +2283497771 +2283497803 +2283497835 +2283497867 +2283497899 +2283497931 +2283497963 +2283497804 +2283497836 +2283497868 +2283497900 +2283497932 +2283497964 +2283497805 +2283497837 +2283497869 +2283497901 +2283497933 +2283497965 +2283497838 +2283497870 +2283497902 +2283497934 +2283497966 +2283497839 +2283497871 +2283497903 +2283497935 +2283497967 +2148598784 +2148599159 +2283045896 +2283045928 +2283045960 +2283045992 +2283046024 +2283046056 +2283046088 +2283046120 +2283046152 +2283046184 +2283046216 +2283046248 +2283046280 +2283046312 +2283046344 +2283046376 +2283045929 +2283045961 +2283045993 +2283046025 +2283046057 +2283046089 +2283046121 +2283046153 +2283046185 +2283046217 +2283046249 +2283046281 +2283046313 +2283046345 +2283046377 +2283045962 +2283045994 +2283046026 +2283046058 +2283046090 +2283046122 +2283046154 +2283046186 +2283046218 +2283046250 +2283046282 +2283046314 +2283046346 +2283046378 +2283045995 +2283046027 +2283046059 +2283046091 +2283046123 +2283046155 +2283046187 +2283046219 +2283046251 +2283046283 +2283046315 +2283046347 +2283046379 +2283046028 +2283046060 +2283046092 +2283046124 +2283046156 +2283046188 +2283046220 +2283046252 +2283046284 +2283046316 +2283046348 +2283046380 +2283046061 +2283046093 +2283046125 +2283046157 +2283046189 +2283046221 +2283046253 +2283046285 +2283046317 +2283046349 +2283046381 +2283046094 +2283046126 +2283046158 +2283046190 +2283046222 +2283046254 +2283046286 +2283046318 +2283046350 +2283046382 +2283046127 +2283046159 +2283046191 +2283046223 +2283046255 +2283046287 +2283046319 +2283046351 +2283046383 +2283380200 +2283315208 +2283315690 +2283315695 +2282904040 +2282891264 +2282891296 +2282891328 +2282891360 +2282891265 +2282891297 +2282891329 +2282891361 +2282891393 +2282891266 +2282891298 +2282891330 +2282891362 +2282891394 +2282891267 +2282891299 +2282891331 +2282891363 +2282891395 +2282891427 +2282891268 +2282891300 +2282891332 +2282891364 +2282891396 +2282891428 +2282891269 +2282891301 +2282891333 +2282891365 +2282891397 +2282891429 +2282891461 +2282891270 +2282891302 +2282891334 +2282891366 +2282891398 +2282891430 +2282891462 +2282891271 +2282891303 +2282891335 +2282891367 +2282891399 +2282891431 +2282891463 +2282891495 +2282891272 +2282891304 +2282891336 +2282891368 +2282891400 +2282891432 +2282891464 +2282891496 +2282891305 +2282891337 +2282891369 +2282891401 +2282891433 +2282891465 +2282891497 +2282891529 +2282891338 +2282891370 +2282891402 +2282891434 +2282891466 +2282891498 +2282891530 +2282891371 +2282891403 +2282891435 +2282891467 +2282891499 +2282891531 +2282891563 +2282891404 +2282891436 +2282891468 +2282891500 +2282891532 +2282891564 +2282891437 +2282891469 +2282891501 +2282891533 +2282891565 +2282891597 +2282891470 +2282891502 +2282891534 +2282891566 +2282891598 +2282891503 +2282891535 +2282891567 +2282891599 +2282891631 +2283443688 +2283443695 +2148582400 +2148582432 +2148582464 +2148582401 +2148582433 +2148582465 +2148582402 +2148582434 +2148582466 +2148582498 +2148582403 +2148582435 +2148582467 +2148582499 +2148582404 +2148582436 +2148582468 +2148582500 +2148582532 +2148582405 +2148582437 +2148582469 +2148582501 +2148582533 +2148582406 +2148582438 +2148582470 +2148582502 +2148582534 +2148582566 +2148582407 +2148582439 +2148582471 +2148582503 +2148582535 +2148582567 +2148582408 +2148582440 +2148582472 +2148582504 +2148582536 +2148582568 +2148582600 +2148582409 +2148582441 +2148582473 +2148582505 +2148582537 +2148582569 +2148582601 +2148582410 +2148582442 +2148582474 +2148582506 +2148582538 +2148582570 +2148582602 +2148582634 +2148582411 +2148582443 +2148582475 +2148582507 +2148582539 +2148582571 +2148582603 +2148582635 +2148582412 +2148582444 +2148582476 +2148582508 +2148582540 +2148582572 +2148582604 +2148582636 +2148582668 +2148582445 +2148582477 +2148582509 +2148582541 +2148582573 +2148582605 +2148582637 +2148582669 +2148582478 +2148582510 +2148582542 +2148582574 +2148582606 +2148582638 +2148582670 +2148582702 +2148582511 +2148582543 +2148582575 +2148582607 +2148582639 +2148582671 +2148582703 +2148582544 +2148582576 +2148582608 +2148582640 +2148582672 +2148582704 +2148582736 +2148582577 +2148582609 +2148582641 +2148582673 +2148582705 +2148582737 +2148582610 +2148582642 +2148582674 +2148582706 +2148582738 +2148582770 +2148582643 +2148582675 +2148582707 +2148582739 +2148582771 +2148582676 +2148582708 +2148582740 +2148582772 +2148582804 +2148582709 +2148582741 +2148582773 +2148582805 +2148582742 +2148582774 +2148582806 +2148582838 +2148582775 +2148582807 +2148582839 +2149122060 +2149122423 +2283474952 +2283506696 +2282858496 +2282858528 +2282858560 +2282858592 +2282858497 +2282858529 +2282858561 +2282858593 +2282858625 +2282858498 +2282858530 +2282858562 +2282858594 +2282858626 +2282858499 +2282858531 +2282858563 +2282858595 +2282858627 +2282858659 +2282858500 +2282858532 +2282858564 +2282858596 +2282858628 +2282858660 +2282858501 +2282858533 +2282858565 +2282858597 +2282858629 +2282858661 +2282858693 +2282858502 +2282858534 +2282858566 +2282858598 +2282858630 +2282858662 +2282858694 +2282858503 +2282858535 +2282858567 +2282858599 +2282858631 +2282858663 +2282858695 +2282858727 +2282858504 +2282858536 +2282858568 +2282858600 +2282858632 +2282858664 +2282858696 +2282858728 +2282858537 +2282858569 +2282858601 +2282858633 +2282858665 +2282858697 +2282858729 +2282858761 +2282858570 +2282858602 +2282858634 +2282858666 +2282858698 +2282858730 +2282858762 +2282858603 +2282858635 +2282858667 +2282858699 +2282858731 +2282858763 +2282858795 +2282858636 +2282858668 +2282858700 +2282858732 +2282858764 +2282858796 +2282858669 +2282858701 +2282858733 +2282858765 +2282858797 +2282858829 +2282858702 +2282858734 +2282858766 +2282858798 +2282858830 +2282858735 +2282858767 +2282858799 +2282858831 +2282858863 +2283411944 +2283411951 +2148534647 +2148535031 +2148551031 +2149107724 +2149139456 +2149140855 +2149141239 +2283399168 +2283399200 +2283399232 +2283399264 +2283399169 +2283399201 +2283399233 +2283399265 +2283399297 +2283399170 +2283399202 +2283399234 +2283399266 +2283399298 +2283399171 +2283399203 +2283399235 +2283399267 +2283399299 +2283399331 +2283399172 +2283399204 +2283399236 +2283399268 +2283399300 +2283399332 +2283399173 +2283399205 +2283399237 +2283399269 +2283399301 +2283399333 +2283399365 +2283399174 +2283399206 +2283399238 +2283399270 +2283399302 +2283399334 +2283399366 +2283399175 +2283399207 +2283399239 +2283399271 +2283399303 +2283399335 +2283399367 +2283399399 +2283399176 +2283399208 +2283399240 +2283399272 +2283399304 +2283399336 +2283399368 +2283399400 +2283399209 +2283399241 +2283399273 +2283399305 +2283399337 +2283399369 +2283399401 +2283399433 +2283399242 +2283399274 +2283399306 +2283399338 +2283399370 +2283399402 +2283399434 +2283399275 +2283399307 +2283399339 +2283399371 +2283399403 +2283399435 +2283399467 +2283399308 +2283399340 +2283399372 +2283399404 +2283399436 +2283399468 +2283399341 +2283399373 +2283399405 +2283399437 +2283399469 +2283399501 +2283399374 +2283399406 +2283399438 +2283399470 +2283399502 +2283399407 +2283399439 +2283399471 +2283399503 +2283399535 +2283431936 +2283431968 +2283432000 +2283432032 +2283431937 +2283431969 +2283432001 +2283432033 +2283432065 +2283431938 +2283431970 +2283432002 +2283432034 +2283432066 +2283431939 +2283431971 +2283432003 +2283432035 +2283432067 +2283432099 +2283431940 +2283431972 +2283432004 +2283432036 +2283432068 +2283432100 +2283431941 +2283431973 +2283432005 +2283432037 +2283432069 +2283432101 +2283432133 +2283431942 +2283431974 +2283432006 +2283432038 +2283432070 +2283432102 +2283432134 +2283431943 +2283431975 +2283432007 +2283432039 +2283432071 +2283432103 +2283432135 +2283432167 +2283431944 +2283431976 +2283432008 +2283432040 +2283432072 +2283432104 +2283432136 +2283432168 +2283431977 +2283432009 +2283432041 +2283432073 +2283432105 +2283432137 +2283432169 +2283432201 +2283432010 +2283432042 +2283432074 +2283432106 +2283432138 +2283432170 +2283432202 +2283432043 +2283432075 +2283432107 +2283432139 +2283432171 +2283432203 +2283432235 +2283432076 +2283432108 +2283432140 +2283432172 +2283432204 +2283432236 +2283432109 +2283432141 +2283432173 +2283432205 +2283432237 +2283432269 +2283432142 +2283432174 +2283432206 +2283432238 +2283432270 +2283432175 +2283432207 +2283432239 +2283432271 +2283432303 +2283464832 +2283464864 +2283464896 +2283464928 +2283464833 +2283464865 +2283464897 +2283464929 +2283464961 +2283464866 +2283464898 +2283464930 +2283464962 +2283464994 +2283464867 +2283464899 +2283464931 +2283464963 +2283464995 +2283465027 +2283464900 +2283464932 +2283464964 +2283464996 +2283465028 +2283465060 +2283464901 +2283464933 +2283464965 +2283464997 +2283465029 +2283465061 +2283465093 +2283464934 +2283464966 +2283464998 +2283465030 +2283465062 +2283465094 +2283465126 +2283464935 +2283464967 +2283464999 +2283465031 +2283465063 +2283465095 +2283465127 +2283465159 +2283464968 +2283465000 +2283465032 +2283465064 +2283465096 +2283465128 +2283465160 +2283465192 +2283464969 +2283465001 +2283465033 +2283465065 +2283465097 +2283465129 +2283465161 +2283465193 +2283465002 +2283465034 +2283465066 +2283465098 +2283465130 +2283465162 +2283465194 +2283465003 +2283465035 +2283465067 +2283465099 +2283465131 +2283465163 +2283465195 +2283465036 +2283465068 +2283465100 +2283465132 +2283465164 +2283465196 +2283465037 +2283465069 +2283465101 +2283465133 +2283465165 +2283465197 +2283465070 +2283465102 +2283465134 +2283465166 +2283465198 +2283465071 +2283465103 +2283465135 +2283465167 +2283465199 +2283586568 +2283586600 +2283586632 +2283586664 +2283586696 +2283586728 +2283586760 +2283586792 +2283586824 +2283586856 +2283586888 +2283586920 +2283586952 +2283586984 +2283587016 +2283587048 +2283586601 +2283586633 +2283586665 +2283586697 +2283586729 +2283586761 +2283586793 +2283586825 +2283586857 +2283586889 +2283586921 +2283586953 +2283586985 +2283587017 +2283587049 +2283586634 +2283586666 +2283586698 +2283586730 +2283586762 +2283586794 +2283586826 +2283586858 +2283586890 +2283586922 +2283586954 +2283586986 +2283587018 +2283587050 +2283586667 +2283586699 +2283586731 +2283586763 +2283586795 +2283586827 +2283586859 +2283586891 +2283586923 +2283586955 +2283586987 +2283587019 +2283587051 +2283586700 +2283586732 +2283586764 +2283586796 +2283586828 +2283586860 +2283586892 +2283586924 +2283586956 +2283586988 +2283587020 +2283587052 +2283586733 +2283586765 +2283586797 +2283586829 +2283586861 +2283586893 +2283586925 +2283586957 +2283586989 +2283587021 +2283587053 +2283586766 +2283586798 +2283586830 +2283586862 +2283586894 +2283586926 +2283586958 +2283586990 +2283587022 +2283587054 +2283586799 +2283586831 +2283586863 +2283586895 +2283586927 +2283586959 +2283586991 +2283587023 +2283587055 +2283621504 +2283621536 +2283621568 +2283621600 +2283621505 +2283621537 +2283621569 +2283621601 +2283621633 +2283621538 +2283621570 +2283621602 +2283621634 +2283621666 +2283621539 +2283621571 +2283621603 +2283621635 +2283621667 +2283621699 +2283621572 +2283621604 +2283621636 +2283621668 +2283621700 +2283621732 +2283621573 +2283621605 +2283621637 +2283621669 +2283621701 +2283621733 +2283621765 +2283621606 +2283621638 +2283621670 +2283621702 +2283621734 +2283621766 +2283621798 +2283621607 +2283621639 +2283621671 +2283621703 +2283621735 +2283621767 +2283621799 +2283621831 +2283621640 +2283621672 +2283621704 +2283621736 +2283621768 +2283621800 +2283621832 +2283621864 +2283621641 +2283621673 +2283621705 +2283621737 +2283621769 +2283621801 +2283621833 +2283621865 +2283621674 +2283621706 +2283621738 +2283621770 +2283621802 +2283621834 +2283621866 +2283621675 +2283621707 +2283621739 +2283621771 +2283621803 +2283621835 +2283621867 +2283621708 +2283621740 +2283621772 +2283621804 +2283621836 +2283621868 +2283621709 +2283621741 +2283621773 +2283621805 +2283621837 +2283621869 +2283621742 +2283621774 +2283621806 +2283621838 +2283621870 +2283621743 +2283621775 +2283621807 +2283621839 +2283621871 +2148567052 +2148567415 +2148599820 +2148600567 diff --git a/Geometry/HGCalGeometry/test/HGCalMissingID.cc b/Geometry/HGCalGeometry/test/HGCalMissingID.cc new file mode 100644 index 0000000000000..b02e00c1ad882 --- /dev/null +++ b/Geometry/HGCalGeometry/test/HGCalMissingID.cc @@ -0,0 +1,174 @@ +// -*- C++ -*- +// +// Package: HGCalValidityTester +// Class: HGCalMissingID +// +/**\class HGCalMissingID HGCalMissingID.cc + test/HGCalMissingID.cc + + Description: + + Implementation: + +*/ +// +// Original Author: Sunanda Banerjee +// Created: Mon 2022/10/22 +// +// + +// system include files +#include +#include +#include +#include +#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/one/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/ParameterSet/interface/FileInPath.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/Utilities/interface/transform.h" + +#include "DataFormats/DetId/interface/DetId.h" +#include "DataFormats/ForwardDetId/interface/HGCSiliconDetId.h" +#include "DataFormats/ForwardDetId/interface/HGCScintillatorDetId.h" +#include "Geometry/HGCalCommonData/interface/HGCalDDDConstants.h" +#include "Geometry/HGCalCommonData/interface/HGCalGeomUtils.h" +#include "Geometry/HGCalGeometry/interface/HGCalGeometry.h" +#include "Geometry/Records/interface/IdealGeometryRecord.h" + +class HGCalMissingID : public edm::one::EDAnalyzer { +public: + explicit HGCalMissingID(const edm::ParameterSet &); + ~HGCalMissingID() override = default; + static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); + + void beginJob() override {} + void beginRun(edm::Run const &, edm::EventSetup const &) override; + void analyze(edm::Event const &iEvent, edm::EventSetup const &) override {} + void endRun(edm::Run const &, edm::EventSetup const &) override {} + void endJob() override {} + +private: + const std::vector nameDetectors_; + const std::string fileName_; + const int32_t nFirst_, nTot_; + const std::vector> tok_hgcal_; + std::vector hgcGeom_; + std::vector> detIds_; +}; + +HGCalMissingID::HGCalMissingID(const edm::ParameterSet &iC) + : nameDetectors_(iC.getParameter>("nameDetectors")), + fileName_(iC.getParameter("fileName")), + nFirst_(iC.getParameter("first")), + nTot_(iC.getParameter("total")), + tok_hgcal_{edm::vector_transform(nameDetectors_, [this](const std::string &name) { + return esConsumes(edm::ESInputTag{"", name}); + })} { + std::ostringstream st1; + for (const auto &name : nameDetectors_) + st1 << " : " << name; + edm::LogVerbatim("HGCGeom") << "Test validity of cells for " << nameDetectors_.size() << " detectors" << st1.str() + << " with inputs from " << fileName_; + + const std::vector dets = {DetId::HGCalEE, DetId::HGCalHSi}; + if (!fileName_.empty()) { + edm::FileInPath filetmp("Geometry/HGCalGeometry/data/" + fileName_); + std::string fileName = filetmp.fullPath(); + std::ifstream fInput(fileName.c_str()); + if (!fInput.good()) { + edm::LogVerbatim("HGCGeom") << "Cannot open file " << fileName; + } else { + char buffer[80]; + int kount(0); + while (fInput.getline(buffer, 80)) { + std::vector items = HGCalGeomUtils::splitString(std::string(buffer)); + unsigned int id = static_cast(std::atoi(items[0].c_str())); + DetId::Detector det = DetId(id).det(); + auto itr = std::find(dets.begin(), dets.end(), det); + if (itr != dets.end()) { + uint32_t pos = static_cast(itr - dets.begin()); + ++kount; + if (kount > nFirst_) { + detIds_.emplace_back(std::pair(id, pos)); + if ((detIds_.size() > static_cast(nTot_)) && (nTot_ > 0)) + break; + } + } + } + fInput.close(); + } + } + edm::LogVerbatim("HGCGeom") << "Reads " << detIds_.size() << " ID's from " << fileName_; + for (unsigned int i = 0; i < dets.size(); ++i) { + int32_t nt(0); + for (unsigned int k = 0; k < detIds_.size(); ++k) { + if (detIds_[k].second == i) + ++nt; + } + edm::LogVerbatim("HGCGeom") << "[" << i << "] " << nt << " IDs for " << dets[i]; + } +} + +void HGCalMissingID::fillDescriptions(edm::ConfigurationDescriptions &descriptions) { + std::vector names = {"HGCalEESensitive", "HGCalHESiliconSensitive"}; + edm::ParameterSetDescription desc; + desc.add>("nameDetectors", names); + desc.add("fileName", "missingIDsV19.txt"); + desc.add("first", 0); + desc.add("total", 10); + descriptions.add("hgcalMissingID", desc); +} + +// ------------ method called to produce the data ------------ +void HGCalMissingID::beginRun(edm::Run const &iRun, edm::EventSetup const &iSetup) { + //initiating hgc Geometry + std::vector names = {"HGCalEESensitive", "HGCalHESiliconSensitive"}; + std::vector dets = {DetId::HGCalEE, DetId::HGCalHSi}; + std::map detMap; + for (uint32_t i = 0; i < nameDetectors_.size(); i++) { + edm::LogVerbatim("HGCGeom") << "Tries to initialize HGCalGeometry and HGCalDDDConstants for " << i << ":" + << nameDetectors_[i]; + const edm::ESHandle &hgcGeom = iSetup.getHandle(tok_hgcal_[i]); + if (hgcGeom.isValid()) { + hgcGeom_.push_back(hgcGeom.product()); + } else { + edm::LogWarning("HGCGeom") << "Cannot initiate HGCalGeometry for " << nameDetectors_[i] << std::endl; + } + auto ii = std::find(names.begin(), names.end(), nameDetectors_[i]); + if (ii != names.end()) { + uint32_t k = static_cast(ii - names.begin()); + detMap[dets[k]] = i; + } + } + edm::LogVerbatim("HGCGeom") << "Loaded HGCalDDConstants for " << detMap.size() << " detectors"; + + for (auto itr = detMap.begin(); itr != detMap.end(); ++itr) + edm::LogVerbatim("HGCGeom") << "[" << itr->second << "]: " << nameDetectors_[itr->second] << " for Detector " + << itr->first; + + for (unsigned int k = 0; k < detIds_.size(); ++k) { + std::ostringstream st1; + const HGCalGeometry *geom = hgcGeom_[detMap[(detIds_[k].first).det()]]; + HGCSiliconDetId id(detIds_[k].first); + GlobalPoint xy = geom->getPosition(id, false, false); + bool valid = geom->topology().valid(id); + auto cell = geom->getPosition(DetId(id), false, false); + DetId idx = geom->getClosestCell(cell); + std::string ok = (id.rawId() == idx.rawId()) ? "OK" : "ERROR"; + st1 << "Old: " << id << " Valid " << valid << " New: " << HGCSiliconDetId(idx) << " === " << ok << " at " << xy; + edm::LogVerbatim("HGCGeom") << "Hit[" << k << "] " << st1.str() << " Position (" << cell.x() << ", " << cell.y() + << ", " << cell.z() << ")"; + } +} + +// define this as a plug-in +DEFINE_FWK_MODULE(HGCalMissingID); diff --git a/Geometry/HGCalGeometry/test/python/testHGCalMissingID_cfg.py b/Geometry/HGCalGeometry/test/python/testHGCalMissingID_cfg.py new file mode 100644 index 0000000000000..8ec88dc347630 --- /dev/null +++ b/Geometry/HGCalGeometry/test/python/testHGCalMissingID_cfg.py @@ -0,0 +1,84 @@ +############################################################################### +# Way to use this: +# cmsRun testHGCalMissingID_cfg.py geometry=D120 +# +# Options for geometry D120, D122, D123 +# +############################################################################### +import FWCore.ParameterSet.Config as cms +import os, sys, importlib, re +import FWCore.ParameterSet.VarParsing as VarParsing + +#################################################################### +### SETUP OPTIONS +options = VarParsing.VarParsing('standard') +options.register('geometry', + "D120", + VarParsing.VarParsing.multiplicity.singleton, + VarParsing.VarParsing.varType.string, + "geometry of operations: D120, D122, D123") + +### get and parse the command line arguments +options.parseArguments() + +print(options) + +#################################################################### +# Use the options + +geomName = "Run4" + options.geometry +geomFile = "Configuration.Geometry.GeometryExtended" + geomName + "Reco_cff" +fileName = "HGCMissingID" + options.geometry + ".root" +import Configuration.Geometry.defaultPhase2ConditionsEra_cff as _settings +GLOBAL_TAG, ERA = _settings.get_era_and_conditions(geomName) +print("Geometry file: ", geomFile) +print("Output file: ", fileName) + +process = cms.Process('HGCMissingID',ERA) + +process.load(geomFile) +process.load("SimGeneral.HepPDTESSource.pdt_cfi") +process.load('Configuration.StandardSequences.MagneticField_cff') +process.load('Configuration.StandardSequences.Services_cff') +process.load('Geometry.HGCalGeometry.hgcalMissingID_cfi') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, GLOBAL_TAG, '') + +if hasattr(process,'MessageLogger'): + process.MessageLogger.HGCGeom=dict() + +process.load("IOMC.RandomEngine.IOMC_cff") +process.RandomNumberGeneratorService.generator.initialSeed = 456789 + +process.source = cms.Source("EmptySource") + +process.generator = cms.EDProducer("FlatRandomEGunProducer", + PGunParameters = cms.PSet( + PartID = cms.vint32(14), + MinEta = cms.double(-3.5), + MaxEta = cms.double(3.5), + MinPhi = cms.double(-3.14159265359), + MaxPhi = cms.double(3.14159265359), + MinE = cms.double(9.99), + MaxE = cms.double(10.01) + ), + AddAntiParticle = cms.bool(False), + Verbosity = cms.untracked.int32(0), + firstRun = cms.untracked.uint32(1) +) + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(1) +) + +process.TFileService = cms.Service("TFileService", + fileName = cms.string(fileName), + closeFileFast = cms.untracked.bool(True) + ) + +#process.hgcalGeometryCheck.verbosity = True + +process.p1 = cms.Path(process.generator*process.hgcalMissingID) diff --git a/Geometry/TrackerCommonData/data/CRack_PhaseII/Geometry_plotter.C b/Geometry/TrackerCommonData/data/CRack_PhaseII/Geometry_plotter.C new file mode 100644 index 0000000000000..82243d9a0f473 --- /dev/null +++ b/Geometry/TrackerCommonData/data/CRack_PhaseII/Geometry_plotter.C @@ -0,0 +1,48 @@ + +//SIMPLE SCRIPT for geometry plotting and debugging. +void Geometry_plotter() { + TGeoManager::Import("cmsSimGeom-Run4D500_validation.root"); + + gGeoManager->GetListOfVolumes()->Print(); + TGeoVolume* tb2s = gGeoManager->FindVolumeFast("tracker:Tracker"); + + if (!tb2s) { + std::cerr << "ERROR: Volume 'tracker:OTDisc5R11EModule' not found." << std::endl; + return; + } + + // Assign a unique color to each material used inside tb2s + std::map materialColors; + int colorIndex = 2; + + // Loop over all nodes (components) inside the volume + for (int i = 0; i < tb2s->GetNdaughters(); ++i) { + TGeoNode* node = tb2s->GetNode(i); + if (!node) + continue; + + TGeoVolume* daughterVol = node->GetVolume(); + if (!daughterVol || !daughterVol->GetMaterial()) + continue; + + std::string matName = daughterVol->GetMaterial()->GetName(); + //std::cout << "material is: " << matName << std::endl; + + if (materialColors.find(matName) == materialColors.end()) { + materialColors[matName] = colorIndex++; + //std::cout << "material is: " << matName << " color is " << colorIndex << std::endl; + + if (colorIndex > 50) + colorIndex = 2; + } + /*if(matName == "materials:Air") { + daughterVol->SetTransparency(100); + }*/ + + //daughterVol->SetLineColor(materialColors[matName]); + //daughterVol->SetFillColor(materialColors[matName]); + //daughterVol->SetTransparency(10); // Optional transparency + } + + tb2s->Draw("ogl"); +} diff --git a/Geometry/TrackerCommonData/data/CRack_PhaseII/README.md b/Geometry/TrackerCommonData/data/CRack_PhaseII/README.md new file mode 100644 index 0000000000000..7405ce9e54ece --- /dev/null +++ b/Geometry/TrackerCommonData/data/CRack_PhaseII/README.md @@ -0,0 +1,78 @@ +# CRACK for PhaseII: + +## Geometry generation + +This section provides complete instructions for creating the CRACK geometry. +If you only wish to use the geometry without generating it, please skip to the next section. + +This setup does not use TKLayout. It is a manual setup to create a custom standalone Tracker, in this case, the CRACK geometry. +If you want to run a standard GEN-SIM workflow instead, please refer to the official instructions: +[here](https://github.com/cms-sw/cmssw/tree/master/Configuration/Geometry) and [here](https://github.com/cms-sw/cmssw/tree/master/Configuration/PyReleaseValidation). + +The CRACK geometry is defined through a set of XML files registered under the name TCRACK in dictCRACKIIGeometry.py. + +To create a new detector version with the standalone CRACK geometry, run the following commands: + +``` +git cms-addpkg Geometry/CMSCommonData +git cms-addpkg Configuration/Geometry +scram b -j 8 +cd Configuration/Geometry +python3 ./scripts/generateCRACKIIGeometry.py -D 500 +``` +## Geometry validation: + +To validate the geometry, two options are available: + +1. Fireworks Geometry Display (Linux only) + +2. ROOT Macro Visualization (Linux and macOS) + +### Fireworks (Linux only) + +``` +git cms-addpkg Fireworks +cmsRun Fireworks/Geometry/python/dumpSimGeometry_cfg.py tag=Run4 version=D500 +LD_PRELOAD="/lib64/libLLVM-17.so" +cmsShow --sim-geom-file cmsSimGeom-Run4D500.root -c Fireworks/Core/macros/simGeo.fwc +``` + +### ROOT (both Linux and macOS) +Alternatively, use a ROOT macro to visualize the geometry. This method works on both Linux and macOS. On macOS, run the macro locally (not via ssh to lxplus) to avoid X11 forwarding issues. + +``` + root Geometry_plotter.C +``` + +## Gen-Sim step + +To run the cosmic rays Gen-Sim step for the CRACK, run the following command: + +``` +cmsRun myTrackerOnly_cfg.py +``` + +This will create a step1.root file. To analyse the hits in the root file, you can use the [SimHitAnalyzer](https://github.com/hayfasfar/SimHitAnalyzer/tree/master/SimHitAnalyzer). + + + +## Run the workflow (Not Needed.) +500 is the new detector version for the standelone CRACK. The following step creates available workflows for D500 sush as a simple the GEN-SIM step + +The new Geometry is integrated in the full matrix, and several new workflow made available. a workflow is a set of GEN-SIM-RECO etc steps with different configurations. For further details on this step please refer to this presentation [here](https://indico.cern.ch/event/1296370/contributions/5449497/attachments/2664526/4616810/TkGeom_handover_AdeWit.pdf) + +To check the available workflows for D500 + +``` + runTheMatrix.py --what upgrade --showMatrix | grep D500 > log +``` + +To run a simple GEN-SIM step on the standelone version using cosmics you can use the workflow 32854.0 + +``` +runTheMatrix.py -l 32854.0 -t 4 --what upgrade --command="-n 1" + +``` +This will simply run a cmsDriver command for the GEN-SIM step with cosmic muons. + + diff --git a/Geometry/TrackerCommonData/data/CRack_PhaseII/cms.xml b/Geometry/TrackerCommonData/data/CRack_PhaseII/cms.xml new file mode 100644 index 0000000000000..50ba19cd23e56 --- /dev/null +++ b/Geometry/TrackerCommonData/data/CRack_PhaseII/cms.xml @@ -0,0 +1,62 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Geometry/TrackerCommonData/data/CRack_PhaseII/myTrackerOnly_cfg.py b/Geometry/TrackerCommonData/data/CRack_PhaseII/myTrackerOnly_cfg.py new file mode 100644 index 0000000000000..36937fbb449b4 --- /dev/null +++ b/Geometry/TrackerCommonData/data/CRack_PhaseII/myTrackerOnly_cfg.py @@ -0,0 +1,247 @@ +# Auto generated configuration file +# using: +# Revision: 1.19 +# Source: /local/reps/CMSSW/CMSSW/Configuration/Applications/python/ConfigBuilder.py,v +# with command line options: UndergroundCosmicSPLooseMu_cfi -s GEN,SIM -n 1 --conditions auto:phase2_realistic_0T --beamspot DBrealisticHLLHC --datatier GEN-SIM --eventcontent FEVTDEBUG --geometry ExtendedRun4D500 --era phase2_tracker,trackingPhase2PU140 --fileout file:step1.root --nThreads 4 --python_filename myTrackerOnly_cfg.py +import FWCore.ParameterSet.Config as cms + +from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker +from Configuration.Eras.Modifier_trackingPhase2PU140_cff import trackingPhase2PU140 + +process = cms.Process('SIM',phase2_tracker,trackingPhase2PU140) + +# import of standard configurations +process.load('Configuration.StandardSequences.Services_cff') +process.load('SimGeneral.HepPDTESSource.pythiapdt_cfi') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.EventContent.EventContent_cff') +process.load('SimGeneral.MixingModule.mixNoPU_cfi') +process.load('Configuration.Geometry.GeometryExtendedRun4D500Reco_cff') +process.load('Configuration.Geometry.GeometryExtendedRun4D500_cff') +process.load('Configuration.StandardSequences.MagneticField_cff') +process.load('Configuration.StandardSequences.Generator_cff') +process.load('IOMC.EventVertexGenerators.VtxSmearedRealisticHLLHC_cfi') +process.load('GeneratorInterface.Core.genFilterSummary_cff') +process.load('Configuration.StandardSequences.SimIdeal_cff') +process.load('Configuration.StandardSequences.EndOfProcess_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') +''' +process.MessageLogger = cms.Service("MessageLogger", + destinations = cms.untracked.vstring('cout'), + categories = cms.untracked.vstring('*'), + cout = cms.untracked.PSet( + threshold = cms.untracked.string('DEBUG'), # or 'INFO' + DEBUG = cms.untracked.PSet(limit = cms.untracked.int32(0)), # 0 = unlimited + #INFO = cms.untracked.PSet(limit = cms.untracked.int32(100000)), + #default = cms.untracked.PSet(limit = cms.untracked.int32(100000)) + ), + debugModules = cms.untracked.vstring('*') # Enable debug for all modules +) +''' + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(100000), + output = cms.optional.untracked.allowed(cms.int32,cms.PSet) +) + +# Input source +process.source = cms.Source("EmptySource") + +process.options = cms.untracked.PSet( + IgnoreCompletely = cms.untracked.vstring(), + Rethrow = cms.untracked.vstring(), + TryToContinue = cms.untracked.vstring(), + accelerators = cms.untracked.vstring('*'), + allowUnscheduled = cms.obsolete.untracked.bool, + canDeleteEarly = cms.untracked.vstring(), + deleteNonConsumedUnscheduledModules = cms.untracked.bool(True), + dumpOptions = cms.untracked.bool(False), + emptyRunLumiMode = cms.obsolete.untracked.string, + eventSetup = cms.untracked.PSet( + forceNumberOfConcurrentIOVs = cms.untracked.PSet( + allowAnyLabel_=cms.required.untracked.uint32 + ), + numberOfConcurrentIOVs = cms.untracked.uint32(0) + ), + fileMode = cms.untracked.string('FULLMERGE'), + forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False), + holdsReferencesToDeleteEarly = cms.untracked.VPSet(), + makeTriggerResults = cms.obsolete.untracked.bool, + modulesToCallForTryToContinue = cms.untracked.vstring(), + modulesToIgnoreForDeleteEarly = cms.untracked.vstring(), + numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(0), + numberOfConcurrentRuns = cms.untracked.uint32(1), + numberOfStreams = cms.untracked.uint32(0), + numberOfThreads = cms.untracked.uint32(1), + printDependencies = cms.untracked.bool(False), + sizeOfStackForThreadsInKB = cms.optional.untracked.uint32, + throwIfIllegalParameter = cms.untracked.bool(True), + wantSummary = cms.untracked.bool(False) +) + +# Production Info +process.configurationMetadata = cms.untracked.PSet( + annotation = cms.untracked.string('UndergroundCosmicSPLooseMu_cfi nevts:1'), + name = cms.untracked.string('Applications'), + version = cms.untracked.string('$Revision: 1.19 $') +) + +# Output definition + +process.FEVTDEBUGoutput = cms.OutputModule("PoolOutputModule", + SelectEvents = cms.untracked.PSet( + SelectEvents = cms.vstring('generation_step') + ), + dataset = cms.untracked.PSet( + dataTier = cms.untracked.string('GEN-SIM'), + filterName = cms.untracked.string('') + ), + fileName = cms.untracked.string('file:step1.root'), + outputCommands = process.FEVTDEBUGEventContent.outputCommands, + splitLevel = cms.untracked.int32(0) +) + +# Additional output definition + +# Other statements +process.genstepfilter.triggerConditions=cms.vstring("generation_step") +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:phase2_realistic_0T', '') + +process.generator = cms.EDProducer("CosMuoGenProducer", + MaxP = cms.double(3000.0), # Max momentum [GeV] + MinP = cms.double(5.0), # Min momentum [GeV] + MinEnu = cms.double(5.0), + MaxEnu = cms.double(10000.0), + + MinTheta = cms.double(0.0), # Steep angle (close to horizontal) + MaxTheta = cms.double(85.0), # Allow small variation + + MinPhi = cms.double(0.0), + MaxPhi = cms.double(360.0), # Full azimuthal coverage + + ZCentrOfTarget = cms.double(00.0), # CRACK z-center [mm] + ZDistOfTarget = cms.double(0.0), # Extend z-window [mm] + RadiusOfTarget = cms.double(8000.0), # Enough to cover module spread + + PlugVx = cms.double(0.0), # Target centered at (0,0) + PlugVz = cms.double(-14000.0), # Entry point upstream (long propagation) + + AcptAllMu = cms.bool(False), # Accept all muons (no barrel bias) + #MultiMuon = cms.bool(False), # Disable multi-muon mode + TIFOnly_constant = cms.bool(False), # You can set to True if needed + TIFOnly_linear = cms.bool(False), # <-- MISSING before + TrackerOnly = cms.bool(True), # Avoid tracker-only filtering + + Verbosity = cms.bool(False), # Enable for debugging + + # Optional tweaks + MaxT0 = cms.double(25.0), + MinT0 = cms.double(-25.0), + RhoAir = cms.double(0.001214), + MinP_CMS = cms.double(-1.0), + ElossScaleFactor = cms.double(1.0), + MultiMuon = cms.bool(False), + MultiMuonFileFirstEvent = cms.int32(1), + MultiMuonFileName = cms.string("CORSIKAmultiMuon.root"), + MultiMuonNmin = cms.int32(2), + MTCCHalf = cms.bool(False), + RhoClay = cms.double(0.0), + RhoPlug = cms.double(0.0), + RhoRock = cms.double(0.0), + RhoWall = cms.double(0.0), + ClayWidth = cms.double(0.0), + NuProdAlt = cms.double(5000.0), # production altitude in mm + +) + +''' +process.cosmicInPixelLoose = cms.EDFilter("CosmicGenFilterHelix", + charges = cms.vint32(1, -1), + doMonitor = cms.untracked.bool(False), + maxZ = cms.double(100.0), + minP = cms.double(0.0), + minPt = cms.double(0.0), + minZ = cms.double(-100.0), + pdgIds = cms.vint32(-13, 13), + propagator = cms.string('SteppingHelixPropagatorAlong'), + radius = cms.double(20.0), + src = cms.InputTag("generator","unsmeared") +) + + +process.cosmicInTracker = cms.EDFilter("CosmicGenFilterHelix", + charges = cms.vint32(1, -1), + doMonitor = cms.untracked.bool(False), + maxZ = cms.double(212.0), + minP = cms.double(0.0), + minPt = cms.double(0.0), + minZ = cms.double(-212.0), + pdgIds = cms.vint32(-13, 13), + propagator = cms.string('SteppingHelixPropagatorAlong'), + radius = cms.double(100.0), + src = cms.InputTag("generator","unsmeared") +) + + +process.SteppingHelixPropagatorAlong = cms.ESProducer("SteppingHelixPropagatorESProducer", + ApplyRadX0Correction = cms.bool(True), + AssumeNoMaterial = cms.bool(False), + ComponentName = cms.string('SteppingHelixPropagatorAlong'), + NoErrorPropagation = cms.bool(False), + PropagationDirection = cms.string('alongMomentum'), + SetVBFPointer = cms.bool(False), + VBFName = cms.string('VolumeBasedMagneticField'), + debug = cms.bool(False), + endcapShiftInZNeg = cms.double(0.0), + endcapShiftInZPos = cms.double(0.0), + returnTangentPlane = cms.bool(True), + sendLogWarning = cms.bool(False), + useEndcapShiftsInZ = cms.bool(False), + useInTeslaFromMagField = cms.bool(False), + useIsYokeFlag = cms.bool(True), + useMagVolumes = cms.bool(True), + useMatVolumes = cms.bool(True), + useTuningForL2Speed = cms.bool(False) +) +''' + +#process.ProductionFilterSequence = cms.Sequence(process.generator+process.cosmicInPixelLoose) +process.ProductionFilterSequence = cms.Sequence(process.generator) + +# Path and EndPath definitions +process.generation_step = cms.Path(process.pgen) +process.simulation_step = cms.Path(process.psim) +process.genfiltersummary_step = cms.EndPath(process.genFilterSummary) +process.endjob_step = cms.EndPath(process.endOfProcess) +process.FEVTDEBUGoutput_step = cms.EndPath(process.FEVTDEBUGoutput) + +# Schedule definition +process.schedule = cms.Schedule(process.generation_step,process.genfiltersummary_step,process.simulation_step,process.endjob_step,process.FEVTDEBUGoutput_step) + +from PhysicsTools.PatAlgos.tools.helpers import associatePatAlgosToolsTask +associatePatAlgosToolsTask(process) +#Setup FWK for multithreaded +process.options.numberOfThreads = 4 +process.options.numberOfStreams = 0 +process.options.numberOfConcurrentLuminosityBlocks = 1 +process.options.eventSetup.numberOfConcurrentIOVs = 1 +process.g4SimHits.Verbosity = cms.untracked.int32(5) +# filter all path with the production filter sequence +for path in process.paths: + getattr(process,path).insert(0, process.ProductionFilterSequence) + +process.g4SimHits.TrackingCut = cms.PSet( + EkinMin = cms.double(1.0) # in MeV +) +from SimG4Core.Configuration.customise_trackerOnlySim import customise +process = customise(process) + + +# Customisation from command line + +# Add early deletion of temporary data products to reduce peak memory need +from Configuration.StandardSequences.earlyDeleteSettings_cff import customiseEarlyDelete +process = customiseEarlyDelete(process) +# End adding early deletion + diff --git a/Geometry/TrackerCommonData/data/CRack_PhaseII/tob.xml b/Geometry/TrackerCommonData/data/CRack_PhaseII/tob.xml new file mode 100644 index 0000000000000..31d7eb32dfa9e --- /dev/null +++ b/Geometry/TrackerCommonData/data/CRack_PhaseII/tob.xml @@ -0,0 +1,956 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Geometry/TrackerCommonData/data/CRack_PhaseII/tracker.xml b/Geometry/TrackerCommonData/data/CRack_PhaseII/tracker.xml new file mode 100644 index 0000000000000..cfc098da66829 --- /dev/null +++ b/Geometry/TrackerCommonData/data/CRack_PhaseII/tracker.xml @@ -0,0 +1,25 @@ + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Geometry/TrackerCommonData/data/CRack_PhaseII/trackerStructureTopology.xml b/Geometry/TrackerCommonData/data/CRack_PhaseII/trackerStructureTopology.xml new file mode 100644 index 0000000000000..04fe31e028d84 --- /dev/null +++ b/Geometry/TrackerCommonData/data/CRack_PhaseII/trackerStructureTopology.xml @@ -0,0 +1,179 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Geometry/TrackerCommonData/data/CRack_PhaseII/trackersens.xml b/Geometry/TrackerCommonData/data/CRack_PhaseII/trackersens.xml new file mode 100644 index 0000000000000..286e76e69025e --- /dev/null +++ b/Geometry/TrackerCommonData/data/CRack_PhaseII/trackersens.xml @@ -0,0 +1,32 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/HLTrigger/Configuration/python/HLT_2025v13_cff.py b/HLTrigger/Configuration/python/HLT_2025v13_cff.py index 61404ccbd1289..16fb62eb6717f 100644 --- a/HLTrigger/Configuration/python/HLT_2025v13_cff.py +++ b/HLTrigger/Configuration/python/HLT_2025v13_cff.py @@ -1,6 +1,6 @@ -# hltGetConfiguration /frozen/2025/2e34/v1.3/HLT --cff --data --type 2025v13 +# hltGetConfiguration /frozen/2025/2e34/v1.3/CMSSW_15_1_X/HLT --cff --data --type 2025v13 -# /frozen/2025/2e34/v1.3/HLT/V1 (CMSSW_15_0_11) +# /frozen/2025/2e34/v1.3/CMSSW_15_1_X/HLT/V4 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms @@ -9,7 +9,7 @@ fragment.load("Configuration.StandardSequences.Accelerators_cff") fragment.HLTConfigVersion = cms.PSet( - tableName = cms.string("/frozen/2025/2e34/v1.3/HLT/V1") + tableName = cms.string("/frozen/2025/2e34/v1.3/CMSSW_15_1_X/HLT/V4") ) fragment.HLTGroupedCkfTrajectoryBuilderP5 = cms.PSet( @@ -4677,7 +4677,9 @@ fragment.CSCObjectMapESProducer = cms.ESProducer( "CSCObjectMapESProducer", appendToDataLabel = cms.string( "" ) ) -fragment.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder" ) +fragment.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder", + appendToDataLabel = cms.string( "" ) +) fragment.CaloTowerConstituentsMapBuilder = cms.ESProducer( "CaloTowerConstituentsMapBuilder", MapFile = cms.untracked.string( "Geometry/CaloTopology/data/CaloTowerEEGeometric.map.gz" ), MapAuto = cms.untracked.bool( False ), @@ -4734,85 +4736,103 @@ appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterial" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMf" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOppositeForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositePropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStepOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) fragment.PropagatorWithMaterialForLoopers = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 4.0 ), ComponentName = cms.string( "PropagatorWithMaterialForLoopers" ), Mass = cms.double( 0.1396 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 4.0 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.PropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStep" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) fragment.SiPixelTemplateStoreESProducer = cms.ESProducer( "SiPixelTemplateStoreESProducer", appendToDataLabel = cms.string( "" ) @@ -4951,7 +4971,9 @@ ), timeThresh = cms.double( 2.0 ) ) -fragment.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP" ) +fragment.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP", + appendToDataLabel = cms.string( "" ) +) fragment.hcalDDDRecConstants = cms.ESProducer( "HcalDDDRecConstantsESModule", appendToDataLabel = cms.string( "" ) ) @@ -5252,13 +5274,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPBwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPBwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPChi2ChargeLooseMeasurementEstimator16 = cms.ESProducer( "Chi2ChargeMeasurementEstimatorESProducer", MaxChi2 = cms.double( 16.0 ), @@ -5634,13 +5658,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPFwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPFwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPGlobalDetLayerGeometry = cms.ESProducer( "GlobalDetLayerGeometryESProducer", ComponentName = cms.string( "hltESPGlobalDetLayerGeometry" ), @@ -6214,13 +6240,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPRungeKuttaTrackerPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPRungeKuttaTrackerPropagator" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( True ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPSiPixelCablingSoA = cms.ESProducer( "SiPixelCablingSoAESProducer@alpaka", CablingMapLabel = cms.string( "" ), @@ -6319,7 +6347,8 @@ mTIB_P0 = cms.double( -0.742 ), mTID_P1 = cms.double( 0.433 ), mTID_P0 = cms.double( -1.427 ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPTTRHBWithTrackAngle = cms.ESProducer( "TkTransientTrackingRecHitBuilderESProducer", ComponentName = cms.string( "hltESPTTRHBWithTrackAngle" ), @@ -6577,7 +6606,9 @@ UseQualityInfo = cms.bool( False ), appendToDataLabel = cms.string( "" ) ) -fragment.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer" ) +fragment.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer", + appendToDataLabel = cms.string( "" ) +) fragment.siStripBackPlaneCorrectionDepESProducer = cms.ESProducer( "SiStripBackPlaneCorrectionDepESProducer", LatencyRecord = cms.PSet( label = cms.untracked.string( "" ), @@ -6590,7 +6621,8 @@ BackPlaneCorrectionDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripBackPlaneCorrectionRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.siStripLorentzAngleDepESProducer = cms.ESProducer( "SiStripLorentzAngleDepESProducer", LatencyRecord = cms.PSet( @@ -6604,7 +6636,8 @@ LorentzAngleDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripLorentzAngleRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.zdcTopologyEP = cms.ESProducer( "ZdcTopologyEP", appendToDataLabel = cms.string( "" ) @@ -6777,9 +6810,9 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -7380,14 +7413,22 @@ fragment.hltSiPixelClustersSoA = cms.EDProducer( "SiPixelRawToClusterPhase1@alpaka", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) @@ -7413,36 +7454,38 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltSiPixelRecHits = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), src = cms.InputTag( "hltSiPixelClusters" ) ) fragment.hltPixelTracksSoA = cms.EDProducer( "CAHitNtupletAlpakaPhase1@alpaka", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -7454,9 +7497,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltPixelTracks = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", @@ -10301,74 +10351,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -11810,9 +11860,9 @@ shouldRunTimingComputation = cms.bool( True ) ) fragment.hltEcalUncalibRecHitSerialSync = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -11924,74 +11974,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbherecoSerialSync" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHitSerialSync:EcalRecHitsEB','hltEcalRecHitSerialSync:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbherecoSerialSync" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHitSerialSync:EcalRecHitsEB','hltEcalRecHitSerialSync:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -12227,14 +12277,22 @@ fragment.hltSiPixelClustersSoASerialSync = cms.EDProducer( "alpaka_serial_sync::SiPixelRawToClusterPhase1", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ) ) fragment.hltSiPixelClustersSerialSync = cms.EDProducer( "SiPixelDigisClustersFromSoAAlpakaPhase1", @@ -12258,6 +12316,7 @@ CPE = cms.string( "PixelCPEFastParams" ) ) fragment.hltSiPixelRecHitsSerialSync = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), src = cms.InputTag( "hltSiPixelClustersSerialSync" ) ) @@ -12526,31 +12585,32 @@ ) fragment.hltPixelTracksSoASerialSync = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -12562,9 +12622,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ) + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) fragment.hltPixelTracksSerialSync = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -19820,7 +19887,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 4096 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( False ) ) fragment.hltL1sHcalNZS = cms.EDFilter( "HLTL1TSeed", @@ -19865,7 +19932,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 107 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( True ) ) fragment.hltPrePhysics = cms.EDFilter( "HLTPrescaler", @@ -33003,74 +33070,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( True ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "" ), + ecalInputs = cms.VInputTag( ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -39888,74 +39955,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltCaloRecHitsBeamHaloCleaned" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEB','hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltCaloRecHitsBeamHaloCleaned" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEB','hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -40452,22 +40519,23 @@ TriggerTypes = cms.vint32( 86 ) ) fragment.hltDeepBLifetimeTagInfosPF = cms.EDProducer( "CandIPProducer", - primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), - computeProbabilities = cms.bool( True ), - computeGhostTrack = cms.bool( True ), - ghostTrackPriorDeltaR = cms.double( 0.03 ), - minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 3 ), maximumTransverseImpactParameter = cms.double( 0.2 ), + minimumNumberOfHits = cms.int32( 3 ), minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), + primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), maximumLongitudinalImpactParameter = cms.double( 17.0 ), - jetDirectionUsingTracks = cms.bool( False ), + computeGhostTrack = cms.bool( True ), + maxDeltaR = cms.double( 0.4 ), + candidates = cms.InputTag( "hltParticleFlow" ), jetDirectionUsingGhostTrack = cms.bool( False ), + minimumNumberOfPixelHits = cms.int32( 2 ), + jetDirectionUsingTracks = cms.bool( False ), + computeProbabilities = cms.bool( True ), useTrackQuality = cms.bool( False ), jets = cms.InputTag( "hltPFJetForBtag" ), - candidates = cms.InputTag( "hltParticleFlow" ), - maxDeltaR = cms.double( 0.4 ) + ghostTrackPriorDeltaR = cms.double( 0.03 ), + maximumChiSquared = cms.double( 5.0 ), + explicitJTA = cms.bool( False ) ) fragment.hltDeepInclusiveVertexFinderPF = cms.EDProducer( "InclusiveCandidateVertexFinder", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -42663,15 +42731,15 @@ etMin = cms.double( 20.0 ) ) fragment.hltBSoftMuonDiJet20L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet20L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -42712,15 +42780,15 @@ invertRapidityCut = cms.bool( False ) ) fragment.hltBSoftMuonDiJet20L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet20L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -42782,15 +42850,15 @@ etMin = cms.double( 40.0 ) ) fragment.hltBSoftMuonDiJet40L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet40L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -42808,15 +42876,15 @@ TriggerType = cms.int32( 86 ) ) fragment.hltBSoftMuonDiJet40L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet40L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -42878,15 +42946,15 @@ etMin = cms.double( 70.0 ) ) fragment.hltBSoftMuonDiJet70L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet70L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -42904,15 +42972,15 @@ TriggerType = cms.int32( 86 ) ) fragment.hltBSoftMuonDiJet70L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet70L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -42974,15 +43042,15 @@ etMin = cms.double( 110.0 ) ) fragment.hltBSoftMuonDiJet110L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet110L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43000,15 +43068,15 @@ TriggerType = cms.int32( 86 ) ) fragment.hltBSoftMuonDiJet110L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet110L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43070,15 +43138,15 @@ etMin = cms.double( 110.0 ) ) fragment.hltBSoftMuonDiJet200L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet200L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43096,15 +43164,15 @@ TriggerType = cms.int32( 86 ) ) fragment.hltBSoftMuonDiJet200L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet200L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43166,15 +43234,15 @@ etMin = cms.double( 300.0 ) ) fragment.hltBSoftMuonJet300L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonJet300L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43192,15 +43260,15 @@ TriggerType = cms.int32( 86 ) ) fragment.hltBSoftMuonJet300L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonJet300L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43249,15 +43317,15 @@ etMin = cms.double( 110.0 ) ) fragment.hltBSoftMuonAK8DiJet170L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonAK8DiJet170L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43275,15 +43343,15 @@ TriggerType = cms.int32( 85 ) ) fragment.hltBSoftMuonAK8DiJet170L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonAK8DiJet170L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43377,15 +43445,15 @@ etMin = cms.double( 170.0 ) ) fragment.hltBSoftMuonAK8Jet170L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonAK8Jet170L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43453,15 +43521,15 @@ invertRapidityCut = cms.bool( False ) ) fragment.hltBSoftMuonAK8Jet170L1FastJetDoubleMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonDoubleMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonAK8Jet170L1FastJetDoubleMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43510,15 +43578,15 @@ etMin = cms.double( 300.0 ) ) fragment.hltBSoftMuonJet300L1AK8FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonJet300L1AK8FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43536,15 +43604,15 @@ TriggerType = cms.int32( 85 ) ) fragment.hltBSoftMuonJet300L1AK8FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonJet300L1AK8FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -60056,74 +60124,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( True ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "" ), + hbheInput = cms.InputTag( "" ), + hoInput = cms.InputTag( "" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -66391,22 +66459,23 @@ TriggerTypes = cms.vint32( 86 ) ) fragment.hltDeepBLifetimeTagInfosPFMinPt20 = cms.EDProducer( "CandIPProducer", - primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), - computeProbabilities = cms.bool( True ), - computeGhostTrack = cms.bool( True ), - ghostTrackPriorDeltaR = cms.double( 0.03 ), - minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 3 ), maximumTransverseImpactParameter = cms.double( 0.2 ), + minimumNumberOfHits = cms.int32( 3 ), minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), + primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), maximumLongitudinalImpactParameter = cms.double( 17.0 ), - jetDirectionUsingTracks = cms.bool( False ), + computeGhostTrack = cms.bool( True ), + maxDeltaR = cms.double( 0.4 ), + candidates = cms.InputTag( "hltParticleFlow" ), jetDirectionUsingGhostTrack = cms.bool( False ), + minimumNumberOfPixelHits = cms.int32( 2 ), + jetDirectionUsingTracks = cms.bool( False ), + computeProbabilities = cms.bool( True ), useTrackQuality = cms.bool( False ), jets = cms.InputTag( "hltPFJetForBtagMinPt20" ), - candidates = cms.InputTag( "hltParticleFlow" ), - maxDeltaR = cms.double( 0.4 ) + ghostTrackPriorDeltaR = cms.double( 0.03 ), + maximumChiSquared = cms.double( 5.0 ), + explicitJTA = cms.bool( False ) ) fragment.hltPrimaryVertexAssociationMinPt20 = cms.EDProducer( "PFCandidatePrimaryVertexSorter", sorting = cms.PSet( ), @@ -72950,20 +73019,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerLowPtSingle = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPtSingle" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPtSingle" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLowPtSingle = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -73532,20 +73601,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPtSingle = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPtSingle" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPtSingle" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPtSingle = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -73694,20 +73763,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerLowPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLowPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -73736,20 +73805,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -74104,20 +74173,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerLow30Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow30PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74146,20 +74215,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow30Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow30Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74457,20 +74526,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLow30Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) fragment.hltL4DisplacedDijetFullTracksJetTagProducerLooseFromIPLow30Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1stLoose" ), @@ -74515,20 +74584,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerLow35Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow35PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74557,20 +74626,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow35Pt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow35Pt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74614,20 +74683,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow35Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow35Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74656,20 +74725,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLow35Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) fragment.hltL4DisplacedDijetFullTracksJetTagProducerLooseFromIPLow35Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1stLoose" ), @@ -74717,20 +74786,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74774,20 +74843,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74816,20 +74885,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLowPt1PtrkPt0p5ShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) fragment.hltL4DisplacedDijetFullTracksJetTagProducerLooseFromIPLowPt1PtrkPt0p5ShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1stLoose" ), @@ -74874,20 +74943,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerLow45Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow45Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow45Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow45PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74916,20 +74985,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow45Pt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow45Pt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow45Pt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow45Pt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74974,20 +75043,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerLow50Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow50Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow50Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow50PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75016,20 +75085,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow50Pt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow50Pt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow50Pt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow50Pt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75092,20 +75161,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducer45Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertex45Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertex45Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIP45PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75134,20 +75203,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducer45Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertex45Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertex45Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIP45Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75235,20 +75304,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLowPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) fragment.hltL4DisplacedDijetFullTracksJetTagProducerFromIPLowPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1st" ), @@ -75306,20 +75375,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerMidPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPMidPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -75348,20 +75417,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerMidPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexMidPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexMidPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPMidPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -75885,22 +75954,23 @@ TriggerTypes = cms.vint32( 86 ) ) fragment.hltDeepBLifetimeTagInfosPFMinPt10 = cms.EDProducer( "CandIPProducer", - primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), - computeProbabilities = cms.bool( True ), - computeGhostTrack = cms.bool( True ), - ghostTrackPriorDeltaR = cms.double( 0.03 ), - minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 3 ), maximumTransverseImpactParameter = cms.double( 0.2 ), + minimumNumberOfHits = cms.int32( 3 ), minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), + primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), maximumLongitudinalImpactParameter = cms.double( 17.0 ), - jetDirectionUsingTracks = cms.bool( False ), + computeGhostTrack = cms.bool( True ), + maxDeltaR = cms.double( 0.4 ), + candidates = cms.InputTag( "hltParticleFlow" ), jetDirectionUsingGhostTrack = cms.bool( False ), + minimumNumberOfPixelHits = cms.int32( 2 ), + jetDirectionUsingTracks = cms.bool( False ), + computeProbabilities = cms.bool( True ), useTrackQuality = cms.bool( False ), jets = cms.InputTag( "hltPFJetForBtagMinPt10" ), - candidates = cms.InputTag( "hltParticleFlow" ), - maxDeltaR = cms.double( 0.4 ) + ghostTrackPriorDeltaR = cms.double( 0.03 ), + maximumChiSquared = cms.double( 5.0 ), + explicitJTA = cms.bool( False ) ) fragment.hltPrimaryVertexAssociationMinPt10 = cms.EDProducer( "PFCandidatePrimaryVertexSorter", sorting = cms.PSet( ), @@ -76061,20 +76131,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedSingleJet100FullTracksTrackIPProducer30Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex30Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex30Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedSingleJetFullTracksJetTagProducerFromIP30PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76103,20 +76173,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedSingleJetFullTracksTrackIPProducer30Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex30Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex30Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedSingleJetFullTracksJetTagProducerFromIP30Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76185,20 +76255,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedSingleJet100FullTracksTrackIPProducer35Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex35Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex35Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedSingleJetFullTracksJetTagProducerFromIP35PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76227,20 +76297,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedSingleJetFullTracksTrackIPProducer35Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex35Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex35Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedSingleJetFullTracksJetTagProducerFromIP35Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76273,20 +76343,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedSingleJet100FullTracksTrackIPProducer40Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex40Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex40Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedSingleJetFullTracksJetTagProducerFromIP40PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76315,20 +76385,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedSingleJetFullTracksTrackIPProducer40Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex40Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex40Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedSingleJetFullTracksJetTagProducerFromIP40Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76611,20 +76681,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerMidPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) fragment.hltL4DisplacedDijetFullTracksJetTagProducerFromIPMidPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1st" ), diff --git a/HLTrigger/Configuration/python/HLT_FULL_cff.py b/HLTrigger/Configuration/python/HLT_FULL_cff.py index e2fe984db7e5f..172c9dd1e0546 100644 --- a/HLTrigger/Configuration/python/HLT_FULL_cff.py +++ b/HLTrigger/Configuration/python/HLT_FULL_cff.py @@ -1,6 +1,6 @@ -# hltGetConfiguration /dev/CMSSW_15_0_0/HLT --cff --data --type FULL +# hltGetConfiguration /dev/CMSSW_15_1_0/HLT --cff --data --type FULL -# /dev/CMSSW_15_0_0/HLT/V132 (CMSSW_15_0_11) +# /dev/CMSSW_15_1_0/HLT/V21 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms @@ -9,7 +9,7 @@ fragment.load("Configuration.StandardSequences.Accelerators_cff") fragment.HLTConfigVersion = cms.PSet( - tableName = cms.string("/dev/CMSSW_15_0_0/HLT/V132") + tableName = cms.string("/dev/CMSSW_15_1_0/HLT/V21") ) fragment.HLTGroupedCkfTrajectoryBuilderP5 = cms.PSet( @@ -11057,6 +11057,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -11192,8 +11193,8 @@ 'HLT_Ele8_CaloIdM_TrackIdM_PFJet30_v34', 'HLT_HIL1NotBptxORForPPRef_v10', 'HLT_HIL1UnpairedBunchBptxMinusForPPRef_v10', - 'HLT_HIL1UnpairedBunchBptxPlusForPPRef_v10', - 'HLT_HT170_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14')+cms.vstring( 'HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay0p5nsTrackless_v14', + 'HLT_HIL1UnpairedBunchBptxPlusForPPRef_v10')+cms.vstring( 'HLT_HT170_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14', + 'HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay0p5nsTrackless_v14', 'HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay1nsInclusive_v14', 'HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay1nsTrackless_v14', 'HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay2nsInclusive_v14', @@ -11446,8 +11447,8 @@ 'HLT_PFJet400_v36', 'HLT_PFJet40_v37', 'HLT_PFJet450_v37', - 'HLT_PFJet500_v37', - 'HLT_PFJet550_v27')+cms.vstring( 'HLT_PFJet60_v37', + 'HLT_PFJet500_v37')+cms.vstring( 'HLT_PFJet550_v27', + 'HLT_PFJet60_v37', 'HLT_PFJet80_v37', 'HLT_PFJetFwd140_v34', 'HLT_PFJetFwd200_v34', @@ -12348,6 +12349,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -12407,6 +12409,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -12466,6 +12469,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -12525,6 +12529,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -12584,6 +12589,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -12643,6 +12649,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -12702,6 +12709,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -12761,6 +12769,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -14048,7 +14057,9 @@ fragment.CSCObjectMapESProducer = cms.ESProducer( "CSCObjectMapESProducer", appendToDataLabel = cms.string( "" ) ) -fragment.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder" ) +fragment.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder", + appendToDataLabel = cms.string( "" ) +) fragment.CaloTowerConstituentsMapBuilder = cms.ESProducer( "CaloTowerConstituentsMapBuilder", MapFile = cms.untracked.string( "Geometry/CaloTopology/data/CaloTowerEEGeometric.map.gz" ), MapAuto = cms.untracked.bool( False ), @@ -14105,85 +14116,103 @@ appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterial" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMf" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOppositeForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositePropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStepOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) fragment.PropagatorWithMaterialForLoopers = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 4.0 ), ComponentName = cms.string( "PropagatorWithMaterialForLoopers" ), Mass = cms.double( 0.1396 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 4.0 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.PropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStep" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) fragment.SiPixelTemplateStoreESProducer = cms.ESProducer( "SiPixelTemplateStoreESProducer", appendToDataLabel = cms.string( "" ) @@ -14322,7 +14351,9 @@ ), timeThresh = cms.double( 2.0 ) ) -fragment.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP" ) +fragment.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP", + appendToDataLabel = cms.string( "" ) +) fragment.hcalDDDRecConstants = cms.ESProducer( "HcalDDDRecConstantsESModule", appendToDataLabel = cms.string( "" ) ) @@ -14623,13 +14654,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPBwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPBwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPChi2ChargeLooseMeasurementEstimator16 = cms.ESProducer( "Chi2ChargeMeasurementEstimatorESProducer", MaxChi2 = cms.double( 16.0 ), @@ -15005,13 +15038,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPFwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPFwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPGlobalDetLayerGeometry = cms.ESProducer( "GlobalDetLayerGeometryESProducer", ComponentName = cms.string( "hltESPGlobalDetLayerGeometry" ), @@ -15585,13 +15620,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPRungeKuttaTrackerPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPRungeKuttaTrackerPropagator" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( True ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPSiPixelCablingSoA = cms.ESProducer( "SiPixelCablingSoAESProducer@alpaka", CablingMapLabel = cms.string( "" ), @@ -15690,7 +15727,8 @@ mTIB_P0 = cms.double( -0.742 ), mTID_P1 = cms.double( 0.433 ), mTID_P0 = cms.double( -1.427 ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPTTRHBWithTrackAngle = cms.ESProducer( "TkTransientTrackingRecHitBuilderESProducer", ComponentName = cms.string( "hltESPTTRHBWithTrackAngle" ), @@ -15948,7 +15986,9 @@ UseQualityInfo = cms.bool( False ), appendToDataLabel = cms.string( "" ) ) -fragment.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer" ) +fragment.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer", + appendToDataLabel = cms.string( "" ) +) fragment.siStripBackPlaneCorrectionDepESProducer = cms.ESProducer( "SiStripBackPlaneCorrectionDepESProducer", LatencyRecord = cms.PSet( label = cms.untracked.string( "" ), @@ -15961,7 +16001,8 @@ BackPlaneCorrectionDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripBackPlaneCorrectionRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.siStripLorentzAngleDepESProducer = cms.ESProducer( "SiStripLorentzAngleDepESProducer", LatencyRecord = cms.PSet( @@ -15975,7 +16016,8 @@ LorentzAngleDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripLorentzAngleRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.zdcTopologyEP = cms.ESProducer( "ZdcTopologyEP", appendToDataLabel = cms.string( "" ) @@ -16148,9 +16190,9 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -16797,14 +16839,22 @@ fragment.hltSiPixelClustersSoA = cms.EDProducer( "SiPixelRawToClusterPhase1@alpaka", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) @@ -16830,36 +16880,38 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltSiPixelRecHits = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), src = cms.InputTag( "hltSiPixelClusters" ) ) fragment.hltPixelTracksSoA = cms.EDProducer( "CAHitNtupletAlpakaPhase1@alpaka", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -16871,9 +16923,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltPixelTracks = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", @@ -19803,74 +19862,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -21312,9 +21371,9 @@ shouldRunTimingComputation = cms.bool( True ) ) fragment.hltEcalUncalibRecHitSerialSync = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -21426,74 +21485,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbherecoSerialSync" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHitSerialSync:EcalRecHitsEB','hltEcalRecHitSerialSync:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbherecoSerialSync" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHitSerialSync:EcalRecHitsEB','hltEcalRecHitSerialSync:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -21729,14 +21788,22 @@ fragment.hltSiPixelClustersSoASerialSync = cms.EDProducer( "alpaka_serial_sync::SiPixelRawToClusterPhase1", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ) ) fragment.hltSiPixelClustersSerialSync = cms.EDProducer( "SiPixelDigisClustersFromSoAAlpakaPhase1", @@ -21760,6 +21827,7 @@ CPE = cms.string( "PixelCPEFastParams" ) ) fragment.hltSiPixelRecHitsSerialSync = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), src = cms.InputTag( "hltSiPixelClustersSerialSync" ) ) @@ -22028,31 +22096,32 @@ ) fragment.hltPixelTracksSoASerialSync = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -22064,9 +22133,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ) + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) fragment.hltPixelTracksSerialSync = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -25108,14 +25184,22 @@ fragment.hltSiPixelClustersPPOnAASoA = cms.EDProducer( "SiPixelRawToClusterHIonPhase1@alpaka", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 1000 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) @@ -25145,20 +25229,29 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltSiPixelRecHitsPPOnAA = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaHIonPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsPPOnAASoA" ), src = cms.InputTag( "hltSiPixelClustersPPOnAA" ) ) fragment.hltSiPixelClustersPPOnAASoASerialSync = cms.EDProducer( "alpaka_serial_sync::SiPixelRawToClusterHIonPhase1", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 1000 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ) ) fragment.hltSiPixelClustersPPOnAASerialSync = cms.EDProducer( "SiPixelDigisClustersFromSoAAlpakaHIonPhase1", @@ -25186,50 +25279,59 @@ CPE = cms.string( "PixelCPEFastParamsHIonPhase1" ) ) fragment.hltSiPixelRecHitsPPOnAASerialSync = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaHIonPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsPPOnAASoASerialSync" ), src = cms.InputTag( "hltSiPixelClustersPPOnAASerialSync" ) ) fragment.hltPixelTracksPPOnAASoA = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaHIonPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsPPOnAASoA" ), - CPE = cms.string( "PixelCPEFastParamsHIonPhase1" ), - ptmin = cms.double( 0.8999999761581421 ), - CAThetaCutBarrel = cms.double( 0.0010000000949949026 ), - CAThetaCutForward = cms.double( 0.002000000026077032 ), - hardCurvCut = cms.double( 0.03284072249589491 ), - dcaCutInnerTriplet = cms.double( 0.05000000596046448 ), - dcaCutOuterTriplet = cms.double( 0.1 ), + cellZ0Cut = cms.double( 8.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 36 ), + minYsizeB2 = cms.int32( 28 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "3145728" ), + maxNumberOfTuples = cms.string( "262144" ), + avgHitsPerTrack = cms.double( 5.0 ), + avgCellsPerHit = cms.double( 40.0 ), + avgCellsPerCell = cms.double( 0.5 ), + avgTracksPerCell = cms.double( 0.5 ), + ptmin = cms.double( 0.899999976158 ), + hardCurvCut = cms.double( 0.0328407224959 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 4 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 3145728 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 8.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), - chi2Coeff = cms.vdouble( 0.9, 1.8 ), - chi2Scale = cms.double( 1.8 ), - tripletMinPt = cms.double( 0.1 ), tripletMaxTip = cms.double( 0.3 ), - tripletMaxZip = cms.double( 12.0 ), - quadrupletMinPt = cms.double( 0.1 ), + chi2Scale = cms.double( 1.8 ), quadrupletMaxTip = cms.double( 0.5 ), - quadrupletMaxZip = cms.double( 12.0 ) + quadrupletMinPt = cms.double( 0.1 ), + quadrupletMaxZip = cms.double( 12.0 ), + tripletMaxZip = cms.double( 12.0 ), + tripletMinPt = cms.double( 0.1 ), + chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 36 ), - minYsizeB2 = cms.int32( 28 ), - phiCuts = cms.vint32( 522, 730, 730, 522, 626, 626, 522, 522, 626, 626, 626, 522, 522, 522, 522, 522, 522, 522, 522 ) + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.001, 0.001, 0.001, 0.001, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.05, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 522, 730, 730, 522, 626, 626, 522, 522, 626, 626, 626, 522, 522, 522, 522, 522, 522, 522, 522 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) fragment.hltPixelTracksPPOnAA = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaHIonPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -25267,45 +25369,53 @@ ) fragment.hltPixelTracksPPOnAASoASerialSync = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaHIonPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsPPOnAASoASerialSync" ), - CPE = cms.string( "PixelCPEFastParamsHIonPhase1" ), - ptmin = cms.double( 0.8999999761581421 ), - CAThetaCutBarrel = cms.double( 0.0010000000949949026 ), - CAThetaCutForward = cms.double( 0.002000000026077032 ), - hardCurvCut = cms.double( 0.03284072249589491 ), - dcaCutInnerTriplet = cms.double( 0.05000000596046448 ), - dcaCutOuterTriplet = cms.double( 0.1 ), + cellZ0Cut = cms.double( 8.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 36 ), + minYsizeB2 = cms.int32( 28 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "3145728" ), + maxNumberOfTuples = cms.string( "262144" ), + avgHitsPerTrack = cms.double( 5.0 ), + avgCellsPerHit = cms.double( 40.0 ), + avgCellsPerCell = cms.double( 0.5 ), + avgTracksPerCell = cms.double( 0.5 ), + ptmin = cms.double( 0.899999976158 ), + hardCurvCut = cms.double( 0.0328407224959 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 4 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 3145728 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 8.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), - chi2Coeff = cms.vdouble( 0.9, 1.8 ), - chi2Scale = cms.double( 1.8 ), - tripletMinPt = cms.double( 0.1 ), tripletMaxTip = cms.double( 0.3 ), - tripletMaxZip = cms.double( 12.0 ), - quadrupletMinPt = cms.double( 0.1 ), + chi2Scale = cms.double( 1.8 ), quadrupletMaxTip = cms.double( 0.5 ), - quadrupletMaxZip = cms.double( 12.0 ) + quadrupletMinPt = cms.double( 0.1 ), + quadrupletMaxZip = cms.double( 12.0 ), + tripletMaxZip = cms.double( 12.0 ), + tripletMinPt = cms.double( 0.1 ), + chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 36 ), - minYsizeB2 = cms.int32( 28 ), - phiCuts = cms.vint32( 522, 730, 730, 522, 626, 626, 522, 522, 626, 626, 626, 522, 522, 522, 522, 522, 522, 522, 522 ) + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.001, 0.001, 0.001, 0.001, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.05, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 522, 730, 730, 522, 626, 626, 522, 522, 626, 626, 626, 522, 522, 522, 522, 522, 522, 522, 522 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) fragment.hltPixelTracksPPOnAASerialSync = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaHIonPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -29705,7 +29815,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 4096 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( False ) ) fragment.hltL1sHcalNZS = cms.EDFilter( "HLTL1TSeed", @@ -29750,7 +29860,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 107 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( True ) ) fragment.hltPrePhysics = cms.EDFilter( "HLTPrescaler", @@ -42888,74 +42998,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( True ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "" ), + ecalInputs = cms.VInputTag( ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -49773,74 +49883,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltCaloRecHitsBeamHaloCleaned" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEB','hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltCaloRecHitsBeamHaloCleaned" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEB','hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -50337,22 +50447,23 @@ TriggerTypes = cms.vint32( 86 ) ) fragment.hltDeepBLifetimeTagInfosPF = cms.EDProducer( "CandIPProducer", - primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), - computeProbabilities = cms.bool( True ), - computeGhostTrack = cms.bool( True ), - ghostTrackPriorDeltaR = cms.double( 0.03 ), - minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 3 ), maximumTransverseImpactParameter = cms.double( 0.2 ), + minimumNumberOfHits = cms.int32( 3 ), minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), + primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), maximumLongitudinalImpactParameter = cms.double( 17.0 ), - jetDirectionUsingTracks = cms.bool( False ), + computeGhostTrack = cms.bool( True ), + maxDeltaR = cms.double( 0.4 ), + candidates = cms.InputTag( "hltParticleFlow" ), jetDirectionUsingGhostTrack = cms.bool( False ), + minimumNumberOfPixelHits = cms.int32( 2 ), + jetDirectionUsingTracks = cms.bool( False ), + computeProbabilities = cms.bool( True ), useTrackQuality = cms.bool( False ), jets = cms.InputTag( "hltPFJetForBtag" ), - candidates = cms.InputTag( "hltParticleFlow" ), - maxDeltaR = cms.double( 0.4 ) + ghostTrackPriorDeltaR = cms.double( 0.03 ), + maximumChiSquared = cms.double( 5.0 ), + explicitJTA = cms.bool( False ) ) fragment.hltDeepInclusiveVertexFinderPF = cms.EDProducer( "InclusiveCandidateVertexFinder", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -52548,15 +52659,15 @@ etMin = cms.double( 20.0 ) ) fragment.hltBSoftMuonDiJet20L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet20L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -52597,15 +52708,15 @@ invertRapidityCut = cms.bool( False ) ) fragment.hltBSoftMuonDiJet20L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet20L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -52667,15 +52778,15 @@ etMin = cms.double( 40.0 ) ) fragment.hltBSoftMuonDiJet40L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet40L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -52693,15 +52804,15 @@ TriggerType = cms.int32( 86 ) ) fragment.hltBSoftMuonDiJet40L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet40L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -52763,15 +52874,15 @@ etMin = cms.double( 70.0 ) ) fragment.hltBSoftMuonDiJet70L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet70L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -52789,15 +52900,15 @@ TriggerType = cms.int32( 86 ) ) fragment.hltBSoftMuonDiJet70L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet70L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -52859,15 +52970,15 @@ etMin = cms.double( 110.0 ) ) fragment.hltBSoftMuonDiJet110L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet110L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -52885,15 +52996,15 @@ TriggerType = cms.int32( 86 ) ) fragment.hltBSoftMuonDiJet110L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet110L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -52955,15 +53066,15 @@ etMin = cms.double( 110.0 ) ) fragment.hltBSoftMuonDiJet200L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet200L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -52981,15 +53092,15 @@ TriggerType = cms.int32( 86 ) ) fragment.hltBSoftMuonDiJet200L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet200L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53051,15 +53162,15 @@ etMin = cms.double( 300.0 ) ) fragment.hltBSoftMuonJet300L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonJet300L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53077,15 +53188,15 @@ TriggerType = cms.int32( 86 ) ) fragment.hltBSoftMuonJet300L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonJet300L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53134,15 +53245,15 @@ etMin = cms.double( 110.0 ) ) fragment.hltBSoftMuonAK8DiJet170L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonAK8DiJet170L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53160,15 +53271,15 @@ TriggerType = cms.int32( 85 ) ) fragment.hltBSoftMuonAK8DiJet170L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonAK8DiJet170L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53262,15 +53373,15 @@ etMin = cms.double( 170.0 ) ) fragment.hltBSoftMuonAK8Jet170L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonAK8Jet170L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53338,15 +53449,15 @@ invertRapidityCut = cms.bool( False ) ) fragment.hltBSoftMuonAK8Jet170L1FastJetDoubleMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonDoubleMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonAK8Jet170L1FastJetDoubleMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53395,15 +53506,15 @@ etMin = cms.double( 300.0 ) ) fragment.hltBSoftMuonJet300L1AK8FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonJet300L1AK8FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53421,15 +53532,15 @@ TriggerType = cms.int32( 85 ) ) fragment.hltBSoftMuonJet300L1AK8FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonJet300L1AK8FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -59784,6 +59895,98 @@ BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), MuonTag = cms.InputTag( "hltIterL3MuonCandidates" ) ) +fragment.hltPreDimuon0LowMassInclusive = cms.EDFilter( "HLTPrescaler", + offset = cms.uint32( 0 ), + L1GtReadoutRecordTag = cms.InputTag( "hltGtStage2Digis" ) +) +fragment.hltL1fL1DoubleMu0SQInclusiveL1Filtered0 = cms.EDFilter( "HLTMuonL1TFilter", + saveTags = cms.bool( True ), + CandTag = cms.InputTag( 'hltGtStage2Digis','Muon' ), + PreviousCandTag = cms.InputTag( "hltL1sDoubleMu0SQOS" ), + MaxEta = cms.double( 2.5 ), + MinPt = cms.double( 0.0 ), + MaxDeltaR = cms.double( 0.3 ), + MinN = cms.int32( 2 ), + CentralBxOnly = cms.bool( True ), + SelectQualities = cms.vint32( ) +) +fragment.hltL2fL1sL1DoubleMu0SQInclusiveL2PreFiltered0 = cms.EDFilter( "HLTMuonL2FromL1TPreFilter", + saveTags = cms.bool( True ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltL1fL1DoubleMu0SQInclusiveL1Filtered0" ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MinN = cms.int32( 0 ), + MaxEta = cms.double( 2.5 ), + AbsEtaBins = cms.vdouble( 0.0 ), + MinNstations = cms.vint32( 0 ), + MinNhits = cms.vint32( 0 ), + CutOnChambers = cms.bool( False ), + MinNchambers = cms.vint32( 0 ), + MaxDr = cms.double( 9999.0 ), + MinDr = cms.double( -1.0 ), + MaxDz = cms.double( 9999.0 ), + MinDxySig = cms.double( -1.0 ), + MinPt = cms.double( 0.0 ), + NSigmaPt = cms.double( 0.0 ), + MatchToPreviousCand = cms.bool( True ) +) +fragment.hltL1fForIterL3L1fL1DoubleMu0SQInclusiveL1Filtered0 = cms.EDFilter( "HLTMuonL1TFilter", + saveTags = cms.bool( True ), + CandTag = cms.InputTag( "hltL1MuonsPt0" ), + PreviousCandTag = cms.InputTag( "hltL1fL1DoubleMu0SQInclusiveL1Filtered0" ), + MaxEta = cms.double( 2.5 ), + MinPt = cms.double( 0.0 ), + MaxDeltaR = cms.double( 0.3 ), + MinN = cms.int32( 1 ), + CentralBxOnly = cms.bool( True ), + SelectQualities = cms.vint32( ) +) +fragment.hltDimuon0LowMassInclusiveL3Filtered = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + CandTag = cms.InputTag( "hltIterL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltL2fL1sL1DoubleMu0SQInclusiveL2PreFiltered0" ), + L1CandTag = cms.InputTag( "hltL1fForIterL3L1fL1DoubleMu0SQInclusiveL1Filtered0" ), + inputMuonCollection = cms.InputTag( "hltIterL3Muons" ), + PreviousCandIsL2 = cms.bool( True ), + FastAccept = cms.bool( False ), + MinN = cms.int32( 1 ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.int32( 0 ), + MaxDr = cms.double( 2.0 ), + MaxDz = cms.double( 9999.0 ), + ChargeOpt = cms.int32( 0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MinPtMax = cms.vdouble( 0.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + MinInvMass = cms.vdouble( 0.2 ), + MaxInvMass = cms.vdouble( 12.0 ), + MinDiMuonDeltaR = cms.double( -1.0 ), + MinAcop = cms.double( -999.0 ), + MaxAcop = cms.double( 999.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxPtBalance = cms.double( 999999.0 ), + NSigmaPt = cms.double( 0.0 ), + MaxDCAMuMu = cms.double( 0.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + InputLinks = cms.InputTag( "hltL3MuonsIterL3Links" ), + L1MatchingdR = cms.double( 0.3 ), + MatchToPreviousCand = cms.bool( True ), + useSimpleGeometry = cms.bool( True ), + useStation2 = cms.bool( True ), + fallbackToME1 = cms.bool( False ), + cosmicPropagationHypothesis = cms.bool( False ), + useMB2InOverlap = cms.bool( False ), + useTrack = cms.string( "tracker" ), + useState = cms.string( "atVertex" ), + propagatorAlong = cms.ESInputTag( "","hltESPSteppingHelixPropagatorAlong" ), + propagatorAny = cms.ESInputTag( "","SteppingHelixPropagatorAny" ), + propagatorOpposite = cms.ESInputTag( "","hltESPSteppingHelixPropagatorOpposite" ) +) fragment.hltL1sTripleMu530NoMass = cms.EDFilter( "HLTL1TSeed", saveTags = cms.bool( True ), L1SeedsLogicalExpression = cms.string( "L1_TripleMu_5SQ_3SQ_0OQ" ), @@ -69941,74 +70144,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( True ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "" ), + hbheInput = cms.InputTag( "" ), + hoInput = cms.InputTag( "" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -76276,22 +76479,23 @@ TriggerTypes = cms.vint32( 86 ) ) fragment.hltDeepBLifetimeTagInfosPFMinPt20 = cms.EDProducer( "CandIPProducer", - primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), - computeProbabilities = cms.bool( True ), - computeGhostTrack = cms.bool( True ), - ghostTrackPriorDeltaR = cms.double( 0.03 ), - minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 3 ), maximumTransverseImpactParameter = cms.double( 0.2 ), + minimumNumberOfHits = cms.int32( 3 ), minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), + primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), maximumLongitudinalImpactParameter = cms.double( 17.0 ), - jetDirectionUsingTracks = cms.bool( False ), + computeGhostTrack = cms.bool( True ), + maxDeltaR = cms.double( 0.4 ), + candidates = cms.InputTag( "hltParticleFlow" ), jetDirectionUsingGhostTrack = cms.bool( False ), + minimumNumberOfPixelHits = cms.int32( 2 ), + jetDirectionUsingTracks = cms.bool( False ), + computeProbabilities = cms.bool( True ), useTrackQuality = cms.bool( False ), jets = cms.InputTag( "hltPFJetForBtagMinPt20" ), - candidates = cms.InputTag( "hltParticleFlow" ), - maxDeltaR = cms.double( 0.4 ) + ghostTrackPriorDeltaR = cms.double( 0.03 ), + maximumChiSquared = cms.double( 5.0 ), + explicitJTA = cms.bool( False ) ) fragment.hltPrimaryVertexAssociationMinPt20 = cms.EDProducer( "PFCandidatePrimaryVertexSorter", sorting = cms.PSet( ), @@ -82835,20 +83039,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerLowPtSingle = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPtSingle" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPtSingle" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLowPtSingle = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -83417,20 +83621,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPtSingle = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPtSingle" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPtSingle" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPtSingle = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -83579,20 +83783,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerLowPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLowPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -83621,20 +83825,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -83989,20 +84193,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerLow30Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow30PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -84031,20 +84235,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow30Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow30Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -84342,20 +84546,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLow30Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) fragment.hltL4DisplacedDijetFullTracksJetTagProducerLooseFromIPLow30Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1stLoose" ), @@ -84400,20 +84604,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerLow35Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow35PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -84442,20 +84646,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow35Pt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow35Pt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -84499,20 +84703,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow35Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow35Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -84541,20 +84745,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLow35Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) fragment.hltL4DisplacedDijetFullTracksJetTagProducerLooseFromIPLow35Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1stLoose" ), @@ -84602,20 +84806,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -84659,20 +84863,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -84701,20 +84905,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLowPt1PtrkPt0p5ShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) fragment.hltL4DisplacedDijetFullTracksJetTagProducerLooseFromIPLowPt1PtrkPt0p5ShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1stLoose" ), @@ -84759,20 +84963,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerLow45Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow45Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow45Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow45PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -84801,20 +85005,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow45Pt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow45Pt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow45Pt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow45Pt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -84859,20 +85063,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerLow50Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow50Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow50Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow50PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -84901,20 +85105,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow50Pt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow50Pt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow50Pt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow50Pt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -84977,20 +85181,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducer45Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertex45Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertex45Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIP45PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -85019,20 +85223,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducer45Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertex45Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertex45Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIP45Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -85120,20 +85324,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLowPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) fragment.hltL4DisplacedDijetFullTracksJetTagProducerFromIPLowPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1st" ), @@ -85191,20 +85395,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerMidPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPMidPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -85233,20 +85437,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerMidPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexMidPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexMidPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPMidPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -85770,22 +85974,23 @@ TriggerTypes = cms.vint32( 86 ) ) fragment.hltDeepBLifetimeTagInfosPFMinPt10 = cms.EDProducer( "CandIPProducer", - primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), - computeProbabilities = cms.bool( True ), - computeGhostTrack = cms.bool( True ), - ghostTrackPriorDeltaR = cms.double( 0.03 ), - minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 3 ), maximumTransverseImpactParameter = cms.double( 0.2 ), + minimumNumberOfHits = cms.int32( 3 ), minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), + primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), maximumLongitudinalImpactParameter = cms.double( 17.0 ), - jetDirectionUsingTracks = cms.bool( False ), + computeGhostTrack = cms.bool( True ), + maxDeltaR = cms.double( 0.4 ), + candidates = cms.InputTag( "hltParticleFlow" ), jetDirectionUsingGhostTrack = cms.bool( False ), + minimumNumberOfPixelHits = cms.int32( 2 ), + jetDirectionUsingTracks = cms.bool( False ), + computeProbabilities = cms.bool( True ), useTrackQuality = cms.bool( False ), jets = cms.InputTag( "hltPFJetForBtagMinPt10" ), - candidates = cms.InputTag( "hltParticleFlow" ), - maxDeltaR = cms.double( 0.4 ) + ghostTrackPriorDeltaR = cms.double( 0.03 ), + maximumChiSquared = cms.double( 5.0 ), + explicitJTA = cms.bool( False ) ) fragment.hltPrimaryVertexAssociationMinPt10 = cms.EDProducer( "PFCandidatePrimaryVertexSorter", sorting = cms.PSet( ), @@ -85946,20 +86151,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedSingleJet100FullTracksTrackIPProducer30Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex30Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex30Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedSingleJetFullTracksJetTagProducerFromIP30PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -85988,20 +86193,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedSingleJetFullTracksTrackIPProducer30Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex30Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex30Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedSingleJetFullTracksJetTagProducerFromIP30Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -86070,20 +86275,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedSingleJet100FullTracksTrackIPProducer35Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex35Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex35Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedSingleJetFullTracksJetTagProducerFromIP35PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -86112,20 +86317,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedSingleJetFullTracksTrackIPProducer35Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex35Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex35Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedSingleJetFullTracksJetTagProducerFromIP35Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -86158,20 +86363,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedSingleJet100FullTracksTrackIPProducer40Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex40Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex40Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedSingleJetFullTracksJetTagProducerFromIP40PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -86200,20 +86405,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedSingleJetFullTracksTrackIPProducer40Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex40Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex40Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedSingleJetFullTracksJetTagProducerFromIP40Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -86496,20 +86701,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerMidPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) fragment.hltL4DisplacedDijetFullTracksJetTagProducerFromIPMidPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1st" ), @@ -97600,74 +97805,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0E-99 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.1 ), HBThreshold2 = cms.double( 0.2 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0E-99 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 11 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( True ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "" ), + hoInput = cms.InputTag( "" ), + ecalInputs = cms.VInputTag( ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 11 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -99190,7 +99395,7 @@ trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "" ), produceSeedingHitSets = cms.bool( True ), - produceIntermediateHitDoublets = cms.bool( True ), + produceIntermediateHitDoublets = cms.bool( False ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), putEmptyIfMaxElementReached = cms.bool( False ), @@ -99212,7 +99417,7 @@ trackingRegions = cms.InputTag( "hltEleSeedsTrackingRegionsPPOnAA" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -105123,7 +105328,7 @@ trackingRegions = cms.InputTag( "hltFullIter2PixelTrackingRegionsPPOnAAForDmeson" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter2PixelClusterCheckPPOnAAForDmeson" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -105327,7 +105532,7 @@ trackingRegions = cms.InputTag( "hltFullIter3PixelTrackingRegionsPPOnAA" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter3PixelClusterCheckPPOnAA" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -105526,7 +105731,7 @@ trackingRegions = cms.InputTag( "hltFullIter7MixedTrackingRegionsAPPOnAA" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter7MixedClusterCheckPPOnAA" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -105623,7 +105828,7 @@ trackingRegions = cms.InputTag( "hltFullIter7MixedTrackingRegionsBPPOnAA" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter7MixedClusterCheckPPOnAA" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -106221,7 +106426,7 @@ trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter9TobTecClusterCheckPPOnAA" ), produceSeedingHitSets = cms.bool( True ), - produceIntermediateHitDoublets = cms.bool( True ), + produceIntermediateHitDoublets = cms.bool( False ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), putEmptyIfMaxElementReached = cms.bool( False ), @@ -117195,6 +117400,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -117330,8 +117536,8 @@ 'HLT_Ele8_CaloIdM_TrackIdM_PFJet30_v34', 'HLT_HIL1NotBptxORForPPRef_v10', 'HLT_HIL1UnpairedBunchBptxMinusForPPRef_v10', - 'HLT_HIL1UnpairedBunchBptxPlusForPPRef_v10', - 'HLT_HT170_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14')+cms.vstring( 'HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay0p5nsTrackless_v14', + 'HLT_HIL1UnpairedBunchBptxPlusForPPRef_v10')+cms.vstring( 'HLT_HT170_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14', + 'HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay0p5nsTrackless_v14', 'HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay1nsInclusive_v14', 'HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay1nsTrackless_v14', 'HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay2nsInclusive_v14', @@ -117584,8 +117790,8 @@ 'HLT_PFJet400_v36', 'HLT_PFJet40_v37', 'HLT_PFJet450_v37', - 'HLT_PFJet500_v37', - 'HLT_PFJet550_v27')+cms.vstring( 'HLT_PFJet60_v37', + 'HLT_PFJet500_v37')+cms.vstring( 'HLT_PFJet550_v27', + 'HLT_PFJet60_v37', 'HLT_PFJet80_v37', 'HLT_PFJetFwd140_v34', 'HLT_PFJetFwd200_v34', @@ -117871,6 +118077,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -120331,6 +120538,7 @@ fragment.HLT_Dimuon0_LowMass_L1_0er1p5_v24 = cms.Path( fragment.HLTBeginSequence + fragment.hltL1sDoubleMu0er1p5 + fragment.hltPreDimuon0LowMassL10er1p5 + fragment.hltL1sEmuDoubleMu0er1p5 + fragment.hltL1fL1sL1DoubleMu0er1p5L1Filtered0 + fragment.HLTL2muonrecoSequence + cms.ignore(fragment.hltL2fL1sL1DoubleMu0er1p5L1f0L2PreFiltered0) + fragment.HLTL3muonrecoSequence + cms.ignore(fragment.hltL1fForIterL3L1fL1sL1DoubleMu0er1p5L1Filtered0) + fragment.hltDimuon0LowMassL1s0er1p5L3Filtered + fragment.hltDisplacedmumuVtxProducerDimuon0LowMassL1s0er1p5 + fragment.hltDisplacedmumuFilterDimuon0LowMassL1s0er1p5 + fragment.HLTEndSequence ) fragment.HLT_Dimuon0_LowMass_v24 = cms.Path( fragment.HLTBeginSequence + fragment.hltL1sDoubleMu0SQOS + fragment.hltPreDimuon0LowMass + fragment.hltL1sEmuDoubleMu0SQOS + fragment.hltL1fL1DoubleMu0SQOSL1Filtered0 + fragment.HLTL2muonrecoSequence + cms.ignore(fragment.hltL2fL1sL1DoubleMu0SQOSL2PreFiltered0) + fragment.HLTL3muonrecoSequence + cms.ignore(fragment.hltL1fForIterL3L1fL1DoubleMu0SQOSL1Filtered0) + fragment.hltDimuon0LowMassL3Filtered + fragment.hltDisplacedmumuVtxProducerDimuon0LowMass + fragment.hltDisplacedmumuFilterDimuon0LowMass + fragment.HLTEndSequence ) fragment.HLT_Dimuon0_LowMass_L1_4_v24 = cms.Path( fragment.HLTBeginSequence + fragment.hltL1sDoubleMu4SQOS + fragment.hltPreDimuon0LowMassL14 + fragment.hltL1sEmuDoubleMu4SQOS + fragment.hltL1fL1sL1DoubleMu4SQOSL1Filtered0 + fragment.HLTL2muonrecoSequence + cms.ignore(fragment.hltL2fL1sL1DoubleMu4SQOSL1f0L2PreFiltered0) + fragment.HLTL3muonrecoSequence + cms.ignore(fragment.hltL1fForIterL3L1fL1sL1DoubleMu4SQOSL1Filtered0) + fragment.hltDimuon0LowMassL1s4L3Filtered + fragment.hltDisplacedmumuVtxProducerDimuon0LowMassL1s4 + fragment.hltDisplacedmumuFilterDimuon0LowMassL1s4 + fragment.HLTEndSequence ) +fragment.HLT_Dimuon0_LowMass_Inclusive_v1 = cms.Path( fragment.HLTBeginSequence + fragment.hltL1sDoubleMu0SQOS + fragment.hltPreDimuon0LowMassInclusive + fragment.hltL1fL1DoubleMu0SQInclusiveL1Filtered0 + fragment.HLTL2muonrecoSequence + cms.ignore(fragment.hltL2fL1sL1DoubleMu0SQInclusiveL2PreFiltered0) + fragment.HLTL3muonrecoSequence + cms.ignore(fragment.hltL1fForIterL3L1fL1DoubleMu0SQInclusiveL1Filtered0) + fragment.hltDimuon0LowMassInclusiveL3Filtered + fragment.HLTEndSequence ) fragment.HLT_Dimuon0_LowMass_L1_TM530_v22 = cms.Path( fragment.HLTBeginSequence + fragment.hltL1sTripleMu530NoMass + fragment.hltPreDimuon0LowMassL1TM530 + fragment.hltL1fL1sL1TripleMuNoMassL1Filtered0 + fragment.HLTL2muonrecoSequence + cms.ignore(fragment.hltL2fL1sL1TripleMuNoMassL1f0L2PreFiltered0) + fragment.HLTL3muonrecoSequence + cms.ignore(fragment.hltL1fForIterL3L1fL1sL1TripleMuNoMassL1Filtered0) + fragment.hltDimuon0LowMassL1sTM530L3Filtered + fragment.hltDisplacedmumuVtxProducerDimuon0LowMassL1sTM530 + fragment.hltDisplacedmumuFilterDimuon0LowMassL1sTM530 + fragment.HLTEndSequence ) fragment.HLT_Dimuon0_Upsilon_Muon_NoL1Mass_v22 = cms.Path( fragment.HLTBeginSequence + fragment.hltL1sTripleMu53p52p5 + fragment.hltPreDimuon0UpsilonMuonNoL1Mass + fragment.hltTripleMuon53p52p5L1Filtered0 + fragment.HLTL2muonrecoSequence + cms.ignore(fragment.hltTripleMuon53p52p5L2PreFiltered0) + fragment.HLTL3muonrecoSequence + cms.ignore(fragment.hltL1fForIterL3TripleMuon53p52p5L1Filtered0) + fragment.hltTripleMu0NoL1MassL3PreFiltered0 + fragment.hltUpsilon0MuonL3FilteredNoL1Mass + fragment.hltDisplacedmumuVtxProducerUpsilon0MuonNoL1Mass + fragment.hltVertexmumuFilterUpsilon0MuonNoL1Mass + fragment.HLTEndSequence ) fragment.HLT_Dimuon0_Upsilon_v2 = cms.Path( fragment.HLTBeginSequence + fragment.hltL1s12ForUpsilonDimuon0Mass8to12 + fragment.hltPreDimuon0Upsilon + fragment.hltL1fL1sL1s12DoubleMu0er2p0SQOSMass8to12L1v2Filtered0 + fragment.HLTL2muonrecoSequence + cms.ignore(fragment.hltL2fL1sL1s12DoubleMu0er2p0SQOSMass8to12L1f0L2v2PreFiltered0) + fragment.HLTL3muonrecoSequence + cms.ignore(fragment.hltL1fForIterL3L1fL1sL1s12DoubleMu0er2p0SQOSMass8to12L1v2Filtered0) + fragment.hltDimuon0UpsilonyL3fL3Filtered + fragment.hltDisplacedmumuVtxProducerDimuon0Upsilonsv3 + fragment.hltDisplacedmumuFilterDimuon0Upsilonsv3 + fragment.HLTEndSequence ) @@ -121574,7 +121782,7 @@ fragment.ScoutingPF1Output = cms.Path( ) -fragment.schedule = cms.Schedule( *(fragment.HLTriggerFirstPath, fragment.Status_OnCPU, fragment.Status_OnGPU, fragment.AlCa_EcalPhiSym_v22, fragment.AlCa_EcalPhiSymForHI_v13, fragment.AlCa_EcalEtaEBonly_v27, fragment.AlCa_EcalEtaEEonly_v27, fragment.AlCa_EcalPi0EBonly_v27, fragment.AlCa_EcalPi0EEonly_v27, fragment.AlCa_EcalEtaEBonlyForHI_v14, fragment.AlCa_EcalEtaEEonlyForHI_v14, fragment.AlCa_EcalPi0EBonlyForHI_v14, fragment.AlCa_EcalPi0EEonlyForHI_v14, fragment.AlCa_IsoTrackHBHE_v3, fragment.AlCa_HIEcalEtaEBonly_v13, fragment.AlCa_HIEcalEtaEEonly_v13, fragment.AlCa_HIEcalPi0EBonly_v13, fragment.AlCa_HIEcalPi0EEonly_v13, fragment.AlCa_RPCMuonNormalisation_v25, fragment.AlCa_RPCMuonNormalisationForHI_v13, fragment.AlCa_HIRPCMuonNormalisation_v13, fragment.AlCa_LumiPixelsCounts_Random_v12, fragment.AlCa_LumiPixelsCounts_ZeroBias_v15, fragment.AlCa_PFJet40_v36, fragment.AlCa_PFJet40_CPUOnly_v15, fragment.AlCa_AK8PFJet40_v31, fragment.DQM_PixelReconstruction_v14, fragment.DQM_EcalReconstruction_v13, fragment.DQM_HcalReconstruction_v11, fragment.DQM_HIPixelReconstruction_v14, fragment.DQM_HIEcalReconstruction_v11, fragment.DQM_HIHcalReconstruction_v9, fragment.DQM_Random_v1, fragment.DQM_ZeroBias_v4, fragment.DST_ZeroBias_v12, fragment.DST_Physics_v17, fragment.DST_PFScouting_DoubleMuonNoVtx_v4, fragment.DST_PFScouting_DoubleMuonVtx_v4, fragment.DST_PFScouting_DoubleMuonVtxMonitorJPsi_v4, fragment.DST_PFScouting_DoubleMuonVtxMonitorZ_v4, fragment.DST_PFScouting_DoubleEG_v10, fragment.DST_PFScouting_DoubleEGMonitorJPsi_v1, fragment.DST_PFScouting_DoubleEGMonitorZ_v1, fragment.DST_PFScouting_SinglePhotonEBMonitorJPsi_v1, fragment.DST_PFScouting_SinglePhotonEBMonitorZ_v1, fragment.DST_PFScouting_JetHT_v10, fragment.DST_PFScouting_AXOVLoose_v8, fragment.DST_PFScouting_AXOLoose_v8, fragment.DST_PFScouting_AXOMedium_v4, fragment.DST_PFScouting_AXOTight_v10, fragment.DST_PFScouting_AXOVTight_v8, fragment.HLT_MonitorL1TPureRate_AXO_v1, fragment.DST_PFScouting_CICADAVLoose_v6, fragment.DST_PFScouting_CICADALoose_v6, fragment.DST_PFScouting_CICADAMedium_v6, fragment.DST_PFScouting_CICADATight_v6, fragment.DST_PFScouting_CICADAVTight_v6, fragment.HLT_MonitorL1TPureRate_CICADA_v1, fragment.DST_PFScouting_SingleMuon_v10, fragment.DST_PFScouting_SinglePhotonEB_v7, fragment.DST_PFScouting_ZeroBias_v8, fragment.DST_PFScouting_ZeroBiasVdM_v2, fragment.HLT_TriggersForScoutingPFMonitor_PS125_v1, fragment.HLT_TriggersForScoutingPFMonitor_PS250_v1, fragment.HLT_TriggersForScoutingPFMonitor_PS500_v1, fragment.HLT_TriggersForScoutingPFMonitor_PS1000_v1, fragment.HLT_TriggersForScoutingPFMonitor_SingleMuon_v1, fragment.HLT_EphemeralPhysics_v10, fragment.HLT_EphemeralZeroBias_v10, fragment.HLT_HIEphemeralPhysics_v6, fragment.HLT_HIEphemeralZeroBias_v6, fragment.HLT_EcalCalibration_v4, fragment.HLT_HcalCalibration_v6, fragment.HLT_HcalNZS_v22, fragment.HLT_HcalPhiSym_v24, fragment.HLT_Random_v3, fragment.HLT_Physics_v15, fragment.HLT_ZeroBias_v14, fragment.HLT_ZeroBias_Alignment_v9, fragment.HLT_ZeroBias_Beamspot_v20, fragment.HLT_ZeroBias_IsolatedBunches_v13, fragment.HLT_ZeroBias_FirstBXAfterTrain_v11, fragment.HLT_ZeroBias_FirstCollisionAfterAbortGap_v13, fragment.HLT_ZeroBias_FirstCollisionInTrain_v12, fragment.HLT_ZeroBias_LastCollisionInTrain_v11, fragment.HLT_HT300_Beamspot_v27, fragment.HLT_PFJet40_GPUvsCPU_v8, fragment.HLT_AK8PFJet380_SoftDropMass30_v10, fragment.HLT_AK8PFJet400_SoftDropMass30_v10, fragment.HLT_AK8PFJet425_SoftDropMass30_v10, fragment.HLT_AK8PFJet450_SoftDropMass30_v10, fragment.HLT_AK8DiPFJet250_250_SoftDropMass40_v10, fragment.HLT_AK8DiPFJet250_250_SoftDropMass50_v10, fragment.HLT_AK8DiPFJet260_260_SoftDropMass30_v10, fragment.HLT_AK8DiPFJet260_260_SoftDropMass40_v10, fragment.HLT_AK8DiPFJet270_270_SoftDropMass30_v10, fragment.HLT_AK8DiPFJet280_280_SoftDropMass30_v16, fragment.HLT_AK8DiPFJet290_290_SoftDropMass30_v10, fragment.HLT_CaloJet500_NoJetID_v24, fragment.HLT_CaloJet550_NoJetID_v19, fragment.HLT_DoubleMu5_Upsilon_DoubleEle3_CaloIdL_TrackIdL_v20, fragment.HLT_DoubleMu3_DoubleEle7p5_CaloIdL_TrackIdL_Upsilon_v20, fragment.HLT_Trimuon5_3p5_2_Upsilon_Muon_v21, fragment.HLT_TrimuonOpen_5_3p5_2_Upsilon_Muon_v18, fragment.HLT_DoubleEle25_CaloIdL_MW_v18, fragment.HLT_DoubleEle27_CaloIdL_MW_v18, fragment.HLT_DoubleEle33_CaloIdL_MW_v31, fragment.HLT_DoubleEle24_eta2p1_WPTight_Gsf_v22, fragment.HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_DZ_PFHT350_v36, fragment.HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_PFHT350_v36, fragment.HLT_Mu27_Ele37_CaloIdL_MW_v21, fragment.HLT_Mu37_Ele27_CaloIdL_MW_v21, fragment.HLT_Mu37_TkMu27_v21, fragment.HLT_DoubleMu4_3_Bs_v31, fragment.HLT_DoubleMu4_3_Jpsi_v31, fragment.HLT_DoubleMu4_3_LowMass_v17, fragment.HLT_DoubleMu4_LowMass_Displaced_v17, fragment.HLT_Mu0_L1DoubleMu_v17, fragment.HLT_Mu4_L1DoubleMu_v17, fragment.HLT_DoubleMu2_Jpsi_LowPt_v10, fragment.HLT_DoubleMu4_3_Photon4_BsToMMG_v16, fragment.HLT_DoubleMu4_3_Displaced_Photon4_BsToMMG_v16, fragment.HLT_DoubleMu3_Trk_Tau3mu_v28, fragment.HLT_DoubleMu3_TkMu_DsTau3Mu_v20, fragment.HLT_DoubleMu4_Mass3p8_DZ_PFHT350_v24, fragment.HLT_DoubleMu4_MuMuTrk_Displaced_v31, fragment.HLT_Mu3_PFJet40_v32, fragment.HLT_Mu7p5_L2Mu2_Jpsi_v26, fragment.HLT_Mu7p5_L2Mu2_Upsilon_v26, fragment.HLT_Mu3_L1SingleMu5orSingleMu7_v17, fragment.HLT_Mu0_Barrel_v10, fragment.HLT_Mu0_Barrel_L1HP6_v7, fragment.HLT_Mu0_Barrel_L1HP7_v7, fragment.HLT_Mu0_Barrel_L1HP8_v8, fragment.HLT_Mu0_Barrel_L1HP9_v8, fragment.HLT_Mu0_Barrel_L1HP10_v10, fragment.HLT_Mu0_Barrel_L1HP11_v10, fragment.HLT_Mu0_Barrel_L1HP13_v4, fragment.HLT_Mu0_Barrel_L1HP6_IP6_v7, fragment.HLT_Mu4_Barrel_IP4_v4, fragment.HLT_Mu4_Barrel_IP6_v4, fragment.HLT_Mu6_Barrel_L1HP7_IP6_v7, fragment.HLT_Mu7_Barrel_L1HP8_IP6_v8, fragment.HLT_Mu8_Barrel_L1HP9_IP6_v8, fragment.HLT_Mu9_Barrel_L1HP10_IP6_v10, fragment.HLT_Mu10_Barrel_L1HP11_IP4_v4, fragment.HLT_Mu10_Barrel_L1HP11_IP6_v10, fragment.HLT_Mu12_Barrel_L1HP13_IP4_v4, fragment.HLT_Mu12_Barrel_L1HP13_IP6_v4, fragment.HLT_DoublePhoton33_CaloIdL_v18, fragment.HLT_DoublePhoton70_v18, fragment.HLT_DoublePhoton85_v26, fragment.HLT_DiEle27_WPTightCaloOnly_L1DoubleEG_v16, fragment.HLT_Ele30_WPTight_Gsf_v16, fragment.HLT_Ele32_WPTight_Gsf_v30, fragment.HLT_Ele35_WPTight_Gsf_v24, fragment.HLT_Ele38_WPTight_Gsf_v24, fragment.HLT_Ele40_WPTight_Gsf_v24, fragment.HLT_Ele32_WPTight_Gsf_L1DoubleEG_v24, fragment.HLT_IsoMu20_v31, fragment.HLT_IsoMu24_v29, fragment.HLT_IsoMu24_HLTTracking_v4, fragment.HLT_IsoMu24_eta2p1_v31, fragment.HLT_IsoMu27_v32, fragment.HLT_UncorrectedJetE30_NoBPTX_v16, fragment.HLT_UncorrectedJetE30_NoBPTX3BX_v16, fragment.HLT_UncorrectedJetE60_NoBPTX3BX_v16, fragment.HLT_UncorrectedJetE70_NoBPTX3BX_v16, fragment.HLT_L1SingleMuCosmics_v9, fragment.HLT_L2Mu10_NoVertex_NoBPTX3BX_v15, fragment.HLT_L2Mu10_NoVertex_NoBPTX_v16, fragment.HLT_L2Mu45_NoVertex_3Sta_NoBPTX3BX_v14, fragment.HLT_L2Mu40_NoVertex_3Sta_NoBPTX3BX_v15, fragment.HLT_L2Mu23NoVtx_2Cha_v11, fragment.HLT_L2Mu23NoVtx_2Cha_CosmicSeed_v11, fragment.HLT_DoubleL2Mu30NoVtx_2Cha_CosmicSeed_Eta2p4_v12, fragment.HLT_DoubleL2Mu30NoVtx_2Cha_Eta2p4_v12, fragment.HLT_DoubleL2Mu50_v12, fragment.HLT_DoubleL2Mu23NoVtx_2Cha_CosmicSeed_v12, fragment.HLT_DoubleL2Mu25NoVtx_2Cha_CosmicSeed_v12, fragment.HLT_DoubleL2Mu25NoVtx_2Cha_CosmicSeed_Eta2p4_v12, fragment.HLT_DoubleL2Mu23NoVtx_2Cha_v12, fragment.HLT_DoubleL2Mu25NoVtx_2Cha_v12, fragment.HLT_DoubleL2Mu25NoVtx_2Cha_Eta2p4_v12, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v30, fragment.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_v19, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v31, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_HLTTracking_v4, fragment.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_v19, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_v21, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_PFJet30_v10, fragment.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_Mass8_v19, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass3p8_v21, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass3p8_HLTTracking_v4, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_CaloJet30_v9, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_AK8PFJet30_v9, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_AK8CaloJet30_v9, fragment.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_Mass3p8_v19, fragment.HLT_Mu30_TkMu0_Psi_v17, fragment.HLT_Mu30_TkMu0_Upsilon_v17, fragment.HLT_Mu25_TkMu0_Phi_v24, fragment.HLT_Mu15_v19, fragment.HLT_Mu20_v28, fragment.HLT_Mu27_v29, fragment.HLT_Mu50_v29, fragment.HLT_Mu55_v19, fragment.HLT_CascadeMu100_v16, fragment.HLT_HighPtTkMu100_v16, fragment.HLT_DiPFJetAve40_v30, fragment.HLT_DiPFJetAve60_v30, fragment.HLT_DiPFJetAve80_v30, fragment.HLT_DiPFJetAve140_v29, fragment.HLT_DiPFJetAve200_v29, fragment.HLT_DiPFJetAve260_v30, fragment.HLT_DiPFJetAve320_v30, fragment.HLT_DiPFJetAve400_v30, fragment.HLT_DiPFJetAve500_v30, fragment.HLT_DiPFJetAve60_HFJEC_v31, fragment.HLT_DiPFJetAve80_HFJEC_v33, fragment.HLT_DiPFJetAve100_HFJEC_v33, fragment.HLT_DiPFJetAve160_HFJEC_v32, fragment.HLT_DiPFJetAve220_HFJEC_v32, fragment.HLT_DiPFJetAve260_HFJEC_v15, fragment.HLT_DiPFJetAve300_HFJEC_v32, fragment.HLT_DiPFJetAve180_PPSMatch_Xi0p3_QuadJet_Max2ProtPerRP_v10, fragment.HLT_AK8PFJet40_v32, fragment.HLT_AK8PFJet60_v31, fragment.HLT_AK8PFJet80_v32, fragment.HLT_AK8PFJet140_v31, fragment.HLT_AK8PFJet200_v31, fragment.HLT_AK8PFJet260_v32, fragment.HLT_AK8PFJet320_v32, fragment.HLT_AK8PFJet400_v32, fragment.HLT_AK8PFJet450_v32, fragment.HLT_AK8PFJet500_v32, fragment.HLT_AK8PFJet550_v27, fragment.HLT_PFJet40_v37, fragment.HLT_PFJet60_v37, fragment.HLT_PFJet80_v37, fragment.HLT_PFJet110_v16, fragment.HLT_PFJet140_v35, fragment.HLT_PFJet200_v35, fragment.HLT_PFJet260_v36, fragment.HLT_PFJet320_v36, fragment.HLT_PFJet400_v36, fragment.HLT_PFJet450_v37, fragment.HLT_PFJet500_v37, fragment.HLT_PFJet550_v27, fragment.HLT_PFJetFwd40_v35, fragment.HLT_PFJetFwd60_v35, fragment.HLT_PFJetFwd80_v34, fragment.HLT_PFJetFwd140_v34, fragment.HLT_PFJetFwd200_v34, fragment.HLT_PFJetFwd260_v35, fragment.HLT_PFJetFwd320_v35, fragment.HLT_PFJetFwd400_v35, fragment.HLT_PFJetFwd450_v35, fragment.HLT_PFJetFwd500_v35, fragment.HLT_AK8PFJetFwd40_v31, fragment.HLT_AK8PFJetFwd60_v30, fragment.HLT_AK8PFJetFwd80_v30, fragment.HLT_AK8PFJetFwd140_v30, fragment.HLT_AK8PFJetFwd200_v30, fragment.HLT_AK8PFJetFwd260_v31, fragment.HLT_AK8PFJetFwd320_v31, fragment.HLT_AK8PFJetFwd400_v31, fragment.HLT_AK8PFJetFwd450_v31, fragment.HLT_AK8PFJetFwd500_v31, fragment.HLT_PFHT180_v33, fragment.HLT_PFHT250_v33, fragment.HLT_PFHT370_v33, fragment.HLT_PFHT430_v33, fragment.HLT_PFHT510_v33, fragment.HLT_PFHT590_v33, fragment.HLT_PFHT680_v33, fragment.HLT_PFHT780_v33, fragment.HLT_PFHT890_v33, fragment.HLT_PFHT1050_v34, fragment.HLT_PFHT500_PFMET100_PFMHT100_IDTight_v28, fragment.HLT_PFHT500_PFMET110_PFMHT110_IDTight_v28, fragment.HLT_PFHT700_PFMET85_PFMHT85_IDTight_v28, fragment.HLT_PFHT800_PFMET75_PFMHT75_IDTight_v28, fragment.HLT_PFMET120_PFMHT120_IDTight_v36, fragment.HLT_PFMET130_PFMHT130_IDTight_v36, fragment.HLT_PFMET140_PFMHT140_IDTight_v36, fragment.HLT_PFMET120_PFMHT120_IDTight_PFHT60_v25, fragment.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_PFHT60_v25, fragment.HLT_PFMETTypeOne140_PFMHT140_IDTight_v27, fragment.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_v36, fragment.HLT_PFMETNoMu130_PFMHTNoMu130_IDTight_v35, fragment.HLT_PFMETNoMu140_PFMHTNoMu140_IDTight_v35, fragment.HLT_PFMETNoMu110_PFMHTNoMu110_IDTight_FilterHF_v16, fragment.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_FilterHF_v16, fragment.HLT_PFMETNoMu130_PFMHTNoMu130_IDTight_FilterHF_v16, fragment.HLT_PFMETNoMu140_PFMHTNoMu140_IDTight_FilterHF_v16, fragment.HLT_L1ETMHadSeeds_v11, fragment.HLT_CaloMHT90_v16, fragment.HLT_CaloMET90_NotCleaned_v16, fragment.HLT_CaloMET350_NotCleaned_v16, fragment.HLT_PFMET200_NotCleaned_v25, fragment.HLT_PFMET250_NotCleaned_v25, fragment.HLT_PFMET300_NotCleaned_v25, fragment.HLT_PFMET200_BeamHaloCleaned_v25, fragment.HLT_PFMETTypeOne200_BeamHaloCleaned_v25, fragment.HLT_MET105_IsoTrk50_v23, fragment.HLT_MET120_IsoTrk50_v23, fragment.HLT_Mu12eta2p3_v17, fragment.HLT_Mu12eta2p3_PFJet40_v17, fragment.HLT_Mu12_DoublePFJets40_PNetBTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets100_PNetBTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets200_PNetBTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets350_PNetBTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets40MaxDeta1p6_PNet2BTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets54MaxDeta1p6_PNet2BTag_0p11_v10, fragment.HLT_DoublePFJets40_PNetBTag_0p11_v10, fragment.HLT_DoublePFJets100_PNetBTag_0p11_v10, fragment.HLT_DoublePFJets200_PNetBTag_0p11_v10, fragment.HLT_DoublePFJets350_PNetBTag_0p11_v10, fragment.HLT_DoublePFJets116MaxDeta1p6_PNet2BTag_0p11_v10, fragment.HLT_DoublePFJets128MaxDeta1p6_PNet2BTag_0p11_v10, fragment.HLT_Photon300_NoHE_v24, fragment.HLT_Mu8_TrkIsoVVL_v28, fragment.HLT_Mu8_DiEle12_CaloIdL_TrackIdL_DZ_v34, fragment.HLT_Mu8_DiEle12_CaloIdL_TrackIdL_v34, fragment.HLT_Mu8_Ele8_CaloIdM_TrackIdM_Mass8_PFHT350_DZ_v35, fragment.HLT_Mu8_Ele8_CaloIdM_TrackIdM_Mass8_PFHT350_v35, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_v29, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_v17, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v27, fragment.HLT_Mu17_TrkIsoVVL_v29, fragment.HLT_Mu19_TrkIsoVVL_v20, fragment.HLT_BTagMu_AK4DiJet20_Mu5_v29, fragment.HLT_BTagMu_AK4DiJet40_Mu5_v29, fragment.HLT_BTagMu_AK4DiJet70_Mu5_v29, fragment.HLT_BTagMu_AK4DiJet110_Mu5_v29, fragment.HLT_BTagMu_AK4DiJet170_Mu5_v28, fragment.HLT_BTagMu_AK4Jet300_Mu5_v28, fragment.HLT_BTagMu_AK8DiJet170_Mu5_v25, fragment.HLT_BTagMu_AK8Jet170_DoubleMu5_v18, fragment.HLT_BTagMu_AK8Jet300_Mu5_v28, fragment.HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v33, fragment.HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_v33, fragment.HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v31, fragment.HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v23, fragment.HLT_Mu12_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v23, fragment.HLT_Mu12_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_v31, fragment.HLT_Mu12_IsoVVL_PFHT150_PNetBTag0p53_v9, fragment.HLT_Photon33_v16, fragment.HLT_Photon50_v24, fragment.HLT_Photon75_v24, fragment.HLT_Photon90_v24, fragment.HLT_Photon120_v24, fragment.HLT_Photon150_v18, fragment.HLT_Photon175_v26, fragment.HLT_Photon200_v25, fragment.HLT_Photon45EB_v4, fragment.HLT_Photon40EB_v4, fragment.HLT_Photon50EB_v5, fragment.HLT_Photon30EB_TightID_TightIso_v15, fragment.HLT_Photon40EB_TightID_TightIso_v6, fragment.HLT_Photon45EB_TightID_TightIso_v6, fragment.HLT_Photon50EB_TightID_TightIso_PFJet30_v10, fragment.HLT_Photon50EB_TightID_TightIso_CaloJet30_v6, fragment.HLT_Photon50EB_TightID_TightIso_AK8PFJet30_v9, fragment.HLT_Photon50EB_TightID_TightIso_AK8CaloJet30_v6, fragment.HLT_Photon50EB_TightID_TightIso_v11, fragment.HLT_Photon55EB_TightID_TightIso_v7, fragment.HLT_Photon75EB_TightID_TightIso_v11, fragment.HLT_Photon90EB_TightID_TightIso_v11, fragment.HLT_Photon110EB_TightID_TightIso_v15, fragment.HLT_Photon110EB_TightID_TightIso_PFJet30_v10, fragment.HLT_Photon110EB_TightID_TightIso_CaloJet30_v6, fragment.HLT_Photon110EB_TightID_TightIso_AK8PFJet30_v9, fragment.HLT_Photon110EB_TightID_TightIso_AK8CaloJet30_v6, fragment.HLT_Photon100EBHE10_v13, fragment.HLT_Photon50_R9Id90_HE10_IsoM_v27, fragment.HLT_Photon75_R9Id90_HE10_IsoM_v27, fragment.HLT_Photon90_R9Id90_HE10_IsoM_v27, fragment.HLT_Photon120_R9Id90_HE10_IsoM_v27, fragment.HLT_Photon165_R9Id90_HE10_IsoM_v28, fragment.HLT_Diphoton30_22_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass90_v26, fragment.HLT_Diphoton30_22_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass95_v26, fragment.HLT_Photon35_TwoProngs35_v17, fragment.HLT_IsoMu24_TwoProngs35_v17, fragment.HLT_Dimuon0_Jpsi_L1_NoOS_v23, fragment.HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23, fragment.HLT_Dimuon0_Jpsi_v24, fragment.HLT_Dimuon0_Jpsi_NoVertexing_v24, fragment.HLT_Dimuon0_Jpsi_L1_4R_0er1p5R_v23, fragment.HLT_Dimuon0_Jpsi_NoVertexing_L1_4R_0er1p5R_v23, fragment.HLT_Dimuon0_Jpsi3p5_Muon2_v21, fragment.HLT_Dimuon0_Upsilon_L1_4p5_v25, fragment.HLT_Dimuon0_Upsilon_L1_4p5er2p0_v25, fragment.HLT_Dimuon0_Upsilon_L1_4p5er2p0M_v23, fragment.HLT_Dimuon0_Upsilon_NoVertexing_v23, fragment.HLT_Dimuon0_LowMass_L1_0er1p5_v24, fragment.HLT_Dimuon0_LowMass_v24, fragment.HLT_Dimuon0_LowMass_L1_4_v24, fragment.HLT_Dimuon0_LowMass_L1_TM530_v22, fragment.HLT_Dimuon0_Upsilon_Muon_NoL1Mass_v22, fragment.HLT_Dimuon0_Upsilon_v2, fragment.HLT_TripleMu_5_3_3_Mass3p8_DZ_v24, fragment.HLT_TripleMu_10_5_5_DZ_v26, fragment.HLT_TripleMu_12_10_5_v26, fragment.HLT_Tau3Mu_Mu7_Mu1_TkMu1_Tau15_v20, fragment.HLT_Tau3Mu_Mu7_Mu1_TkMu1_Tau15_Charge1_v20, fragment.HLT_Tau3Mu_Mu7_Mu1_TkMu1_IsoTau15_v20, fragment.HLT_Tau3Mu_Mu7_Mu1_TkMu1_IsoTau15_Charge1_v20, fragment.HLT_DoubleMu3_DZ_PFMET50_PFMHT60_v26, fragment.HLT_DoubleMu3_DZ_PFMET70_PFMHT70_v26, fragment.HLT_DoubleMu3_DZ_PFMET90_PFMHT90_v26, fragment.HLT_DoubleMu3_Trk_Tau3mu_NoL1Mass_v22, fragment.HLT_DoubleMu4_3_LowMass_SS_v10, fragment.HLT_DoubleMu4_Jpsi_Displaced_v23, fragment.HLT_DoubleMu4_Jpsi_NoVertexing_v23, fragment.HLT_DoubleMu4_JpsiTrkTrk_Displaced_v23, fragment.HLT_DoubleMu4_JpsiTrk_Bc_v16, fragment.HLT_DoubleMu43NoFiltersNoVtx_v17, fragment.HLT_DoubleMu48NoFiltersNoVtx_v17, fragment.HLT_Mu43NoFiltersNoVtx_Photon43_CaloIdL_v18, fragment.HLT_Mu48NoFiltersNoVtx_Photon48_CaloIdL_v18, fragment.HLT_Mu38NoFiltersNoVtxDisplaced_Photon38_CaloIdL_v14, fragment.HLT_Mu43NoFiltersNoVtxDisplaced_Photon43_CaloIdL_v14, fragment.HLT_Ele28_HighEta_SC20_Mass55_v27, fragment.HLT_Ele15_IsoVVVL_PFHT450_PFMET50_v32, fragment.HLT_Ele15_IsoVVVL_PFHT450_v32, fragment.HLT_Ele50_IsoVVVL_PFHT450_v32, fragment.HLT_Ele15_IsoVVVL_PFHT600_v36, fragment.HLT_Mu15_IsoVVVL_PFHT450_PFMET50_v31, fragment.HLT_Mu15_IsoVVVL_PFHT450_v31, fragment.HLT_Mu50_IsoVVVL_PFHT450_v31, fragment.HLT_Mu15_IsoVVVL_PFHT600_v35, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMET80_PFMHT80_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMET90_PFMHT90_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMET100_PFMHT100_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu80_PFMHTNoMu80_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu90_PFMHTNoMu90_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu100_PFMHTNoMu100_IDTight_v18, fragment.HLT_Dimuon10_Upsilon_y1p4_v17, fragment.HLT_Dimuon12_Upsilon_y1p4_v18, fragment.HLT_Dimuon14_Phi_Barrel_Seagulls_v23, fragment.HLT_Dimuon25_Jpsi_v30, fragment.HLT_Dimuon14_PsiPrime_v29, fragment.HLT_Dimuon14_PsiPrime_noCorrL1_v21, fragment.HLT_Dimuon18_PsiPrime_v30, fragment.HLT_Dimuon18_PsiPrime_noCorrL1_v22, fragment.HLT_Dimuon24_Upsilon_noCorrL1_v22, fragment.HLT_Dimuon24_Phi_noCorrL1_v22, fragment.HLT_Dimuon25_Jpsi_noCorrL1_v22, fragment.HLT_DiMu4_Ele9_CaloIdL_TrackIdL_DZ_Mass3p8_v33, fragment.HLT_DiMu9_Ele9_CaloIdL_TrackIdL_DZ_v33, fragment.HLT_DiMu9_Ele9_CaloIdL_TrackIdL_v33, fragment.HLT_DoubleIsoMu20_eta2p1_v23, fragment.HLT_TrkMu12_DoubleTrkMu5NoFiltersNoVtx_v21, fragment.HLT_Mu8_v28, fragment.HLT_Mu17_v29, fragment.HLT_Mu19_v20, fragment.HLT_Mu17_Photon30_IsoCaloId_v22, fragment.HLT_Ele8_CaloIdL_TrackIdL_IsoVL_PFJet30_v32, fragment.HLT_Ele12_CaloIdL_TrackIdL_IsoVL_PFJet30_v34, fragment.HLT_Ele14_eta2p5_IsoVVVL_Gsf_PFHT200_PNetBTag0p53_v9, fragment.HLT_Ele23_CaloIdL_TrackIdL_IsoVL_PFJet30_v34, fragment.HLT_Ele8_CaloIdM_TrackIdM_PFJet30_v34, fragment.HLT_Ele17_CaloIdM_TrackIdM_PFJet30_v32, fragment.HLT_Ele23_CaloIdM_TrackIdM_PFJet30_v34, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_PFJet165_v34, fragment.HLT_Ele115_CaloIdVT_GsfTrkIdT_v28, fragment.HLT_Ele135_CaloIdVT_GsfTrkIdT_v21, fragment.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_v25, fragment.HLT_PFHT400_SixPFJet32_v25, fragment.HLT_PFHT400_SixPFJet32_PNet2BTagMean0p50_v13, fragment.HLT_PFHT450_SixPFJet36_v24, fragment.HLT_PFHT450_SixPFJet36_PNetBTag0p35_v13, fragment.HLT_PFHT400_FivePFJet_120_120_60_30_30_v10, fragment.HLT_PFHT350_v35, fragment.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT350_v14, fragment.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT380_v14, fragment.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT400_v14, fragment.HLT_ECALHT800_v22, fragment.HLT_DiSC30_18_EIso_AND_HE_Mass70_v25, fragment.HLT_Photon20_HoverELoose_v21, fragment.HLT_Photon30_HoverELoose_v21, fragment.HLT_L1_CDC_SingleMu_3_er1p2_TOP120_DPHI2p618_3p142_v10, fragment.HLT_CDC_L2cosmic_10_er1p0_v11, fragment.HLT_CDC_L2cosmic_5p5_er1p0_v11, fragment.HLT_Photon60_R9Id90_HE10_IsoM_EBOnly_PFJetsMJJ300DEta3_v13, fragment.HLT_Photon75_R9Id90_HE10_IsoM_EBOnly_PFJetsMJJ300DEta3_v21, fragment.HLT_Mu18_Mu9_SameSign_v20, fragment.HLT_DoubleMu2_Jpsi_DoubleTrk1_Phi1p05_v22, fragment.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_v26, fragment.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_Mass2p0_v10, fragment.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_Mass2p0_noDCA_v10, fragment.HLT_TripleMu_5_3_3_Mass3p8_DCA_v19, fragment.HLT_QuadPFJet103_88_75_15_v21, fragment.HLT_QuadPFJet105_88_76_15_v21, fragment.HLT_QuadPFJet111_90_80_15_v21, fragment.HLT_Diphoton30_18_R9IdL_AND_HE_AND_IsoCaloId_v14, fragment.HLT_Diphoton30_18_R9IdL_AND_HE_AND_IsoCaloId_Mass55_v14, fragment.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Tight_eta2p3_CrossL1_v11, fragment.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Medium_eta2p3_CrossL1_v11, fragment.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Loose_eta2p3_CrossL1_v11, fragment.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_PNet3BTag_4p3_v9, fragment.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_PNet3BTag_2p0_v9, fragment.HLT_PFHT400_FivePFJet_120_120_60_30_30_PNet2BTag_5p6_v10, fragment.HLT_PFHT400_FivePFJet_120_120_60_30_30_PNet2BTag_4p3_v10, fragment.HLT_QuadPFJet103_88_75_15_PNetBTag_0p4_VBF2_v10, fragment.HLT_QuadPFJet103_88_75_15_PNet2BTag_0p4_0p12_VBF1_v10, fragment.HLT_QuadPFJet105_88_76_15_PNetBTag_0p4_VBF2_v10, fragment.HLT_QuadPFJet105_88_76_15_PNet2BTag_0p4_0p12_VBF1_v10, fragment.HLT_QuadPFJet111_90_80_15_PNetBTag_0p4_VBF2_v10, fragment.HLT_QuadPFJet111_90_80_15_PNet2BTag_0p4_0p12_VBF1_v10, fragment.HLT_PFHT250_QuadPFJet25_v10, fragment.HLT_PFHT250_QuadPFJet25_PNet2BTagMean0p55_v10, fragment.HLT_PFHT250_QuadPFJet25_PNet1BTag0p20_PNet1Tauh0p50_v10, fragment.HLT_PFHT250_QuadPFJet30_PNet2BTagMean0p55_v10, fragment.HLT_PFHT250_QuadPFJet30_PNet1BTag0p20_PNet1Tauh0p50_v10, fragment.HLT_PFHT280_QuadPFJet30_PNet1BTag0p20_PNet1Tauh0p50_v10, fragment.HLT_PFHT280_QuadPFJet30_v13, fragment.HLT_PFHT280_QuadPFJet30_PNet2BTagMean0p55_v13, fragment.HLT_PFHT280_QuadPFJet30_PNet2BTagMean0p60_v13, fragment.HLT_PFHT280_QuadPFJet35_PNet2BTagMean0p60_v13, fragment.HLT_PFHT340_QuadPFJet70_50_40_40_PNet2BTagMean0p70_v14, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_v13, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_QuadPFJet30_v13, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_QuadPFJet30_PNet2BTagMean0p55_v13, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PNet2BTagMean0p50_v13, fragment.HLT_QuadPFJet100_88_70_30_v14, fragment.HLT_QuadPFJet105_88_75_30_v13, fragment.HLT_QuadPFJet111_90_80_30_v13, fragment.HLT_QuadPFJet100_88_70_30_PNet1CvsAll0p5_VBF3Tight_v14, fragment.HLT_QuadPFJet105_88_75_30_PNet1CvsAll0p5_VBF3Tight_v14, fragment.HLT_QuadPFJet111_90_80_30_PNet1CvsAll0p6_VBF3Tight_v14, fragment.HLT_AK8PFJet220_SoftDropMass40_v17, fragment.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p50_v13, fragment.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p53_v13, fragment.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p55_v13, fragment.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p60_v13, fragment.HLT_AK8PFJet230_SoftDropMass40_v17, fragment.HLT_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_AK8PFJet230_SoftDropMass40_PNetTauTau0p03_v13, fragment.HLT_AK8PFJet230_SoftDropMass40_PNetTauTau0p05_v13, fragment.HLT_AK8PFJet250_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_AK8PFJet250_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_AK8PFJet250_SoftDropMass40_PNetTauTau0p03_v13, fragment.HLT_AK8PFJet250_SoftDropMass40_PNetTauTau0p05_v13, fragment.HLT_AK8PFJet275_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_AK8PFJet275_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_AK8PFJet275_SoftDropMass40_PNetTauTau0p03_v13, fragment.HLT_AK8PFJet275_SoftDropMass40_PNetTauTau0p05_v13, fragment.HLT_AK8PFJet275_Nch45_v10, fragment.HLT_AK8PFJet275_Nch40_v10, fragment.HLT_IsoMu50_AK8PFJet220_SoftDropMass40_v16, fragment.HLT_IsoMu50_AK8PFJet220_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_v16, fragment.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet220_SoftDropMass40_v16, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet220_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_v16, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_DoubleAK4PFJet60_30_v14, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_DoubleAK4PFJet60_30_PNet2BTagMean0p50_v14, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_v10, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_v10, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_PNet2BTagMean0p55_v10, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_PNet1BTag0p20_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Medium_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Tight_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_PFJet60_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_PFJet75_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Tight_eta2p3_CrossL1_ETau_Monitoring_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Medium_eta2p3_CrossL1_ETau_Monitoring_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Loose_eta2p3_CrossL1_ETau_Monitoring_v10, fragment.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Tight_eta2p3_CrossL1_v10, fragment.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Medium_eta2p3_CrossL1_v10, fragment.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Loose_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet20_eta2p2_SingleL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet45_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PFHT250_v10, fragment.HLT_IsoMu24_eta2p1_PFHT250_QuadPFJet25_v10, fragment.HLT_IsoMu24_eta2p1_PFHT250_QuadPFJet25_PNet1Tauh0p50_v10, fragment.HLT_IsoMu24_eta2p1_SinglePFJet25_PNet1Tauh0p50_v10, fragment.HLT_DoublePNetTauhPFJet30_Medium_L2NN_eta2p3_v10, fragment.HLT_DoublePNetTauhPFJet30_Tight_L2NN_eta2p3_v10, fragment.HLT_DoublePNetTauhPFJet26_L2NN_eta2p3_PFJet60_v10, fragment.HLT_DoublePNetTauhPFJet26_L2NN_eta2p3_PFJet75_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Loose_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Medium_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Tight_L2NN_eta2p3_CrossL1_v10, fragment.HLT_SinglePNetTauhPFJet130_Loose_L2NN_eta2p3_v10, fragment.HLT_SinglePNetTauhPFJet130_Medium_L2NN_eta2p3_v10, fragment.HLT_SinglePNetTauhPFJet130_Tight_L2NN_eta2p3_v10, fragment.HLT_DoubleL2Mu10NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v16, fragment.HLT_DoubleL2Mu12NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_DoubleL2Mu14NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_DoubleL3Mu16_10NoVtx_DxyMin0p01cm_v14, fragment.HLT_DoubleL3Mu18_10NoVtx_DxyMin0p01cm_v13, fragment.HLT_DoubleL3Mu20_10NoVtx_DxyMin0p01cm_v13, fragment.HLT_L2Mu10NoVtx_2Cha_v10, fragment.HLT_L2Mu10NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_L3Mu10NoVtx_v13, fragment.HLT_L3Mu10NoVtx_DxyMin0p01cm_v13, fragment.HLT_DoubleL2Mu_L3Mu16NoVtx_VetoL3Mu0DxyMax0p1cm_v13, fragment.HLT_DoubleL2Mu_L3Mu18NoVtx_VetoL3Mu0DxyMax0p1cm_v13, fragment.HLT_DoubleL2Mu10NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_DoubleL2Mu12NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_L2Mu10NoVtx_2Cha_CosmicSeed_v10, fragment.HLT_L2Mu10NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_DoubleL3dTksMu16_10NoVtx_DxyMin0p01cm_v14, fragment.HLT_L2Mu50NoVtx_3Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v8, fragment.HLT_L2Mu50NoVtx_3Cha_VetoL3Mu0DxyMax1cm_v8, fragment.HLT_L3Mu30NoVtx_DxyMin0p01cm_v6, fragment.HLT_L3Mu50NoVtx_DxyMin0p01cm_v6, fragment.HLT_L3dTksMu10_NoVtx_DxyMin0p01cm_v14, fragment.HLT_Mu20NoFiltersNoVtxDisplaced_Photon20_CaloCustomId_v14, fragment.HLT_DisplacedMu24_MediumChargedIsoDisplacedPFTauHPS24_v12, fragment.HLT_Photon34_R9Id90_CaloIdL_IsoL_DisplacedIdL_MediumChargedIsoDisplacedPFTauHPS34_v12, fragment.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS32_Trk1_eta2p1_v17, fragment.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS36_Trk1_eta2p1_v12, fragment.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS32_Trk1_eta2p1_noDxy_v12, fragment.HLT_IsoMu27_MediumChargedIsoDisplacedPFTauHPS24_eta2p1_SingleL1_v12, fragment.HLT_HT350_DelayedJet40_SingleDelay1p5To3p5nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay1p6To3p5nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay1p75To3p5nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay3nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay3p25nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay3p5nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay0p5nsInclusive_v11, fragment.HLT_HT430_DelayedJet40_SingleDelay1nsInclusive_v11, fragment.HLT_HT430_DelayedJet40_SingleDelay1To1p5nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay1p1To1p6nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay1p25To1p75nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay1p5nsInclusive_v11, fragment.HLT_HT430_DelayedJet40_SingleDelay2nsInclusive_v13, fragment.HLT_HT430_DelayedJet40_SingleDelay2p25nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay2p5nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay0p5nsTrackless_v12, fragment.HLT_HT430_DelayedJet40_SingleDelay1nsTrackless_v14, fragment.HLT_HT430_DelayedJet40_SingleDelay1p25nsTrackless_v10, fragment.HLT_HT430_DelayedJet40_SingleDelay1p5nsTrackless_v10, fragment.HLT_HT430_DelayedJet40_DoubleDelay0p5nsInclusive_v12, fragment.HLT_HT430_DelayedJet40_DoubleDelay1nsInclusive_v13, fragment.HLT_HT430_DelayedJet40_DoubleDelay1p25nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_DoubleDelay1p5nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_DoubleDelay0p5nsTrackless_v14, fragment.HLT_HT430_DelayedJet40_DoubleDelay0p75nsTrackless_v10, fragment.HLT_HT430_DelayedJet40_DoubleDelay1nsTrackless_v10, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p5To4nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p6To4nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p75To4nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay3p5nsInclusive_v11, fragment.HLT_L1Tau_DelayedJet40_SingleDelay3p75nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay4nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p5nsTrackless_v12, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p75nsTrackless_v10, fragment.HLT_L1Tau_DelayedJet40_SingleDelay3nsTrackless_v10, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay0p75nsInclusive_v11, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p25nsInclusive_v11, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p5nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p75nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay0p5nsTrackless_v12, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1nsTrackless_v12, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p25nsTrackless_v10, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p5nsTrackless_v10, fragment.HLT_L1Mu6HT240_v10, fragment.HLT_Mu6HT240_DisplacedDijet30_Inclusive1PtrkShortSig5_DisplacedLoose_v14, fragment.HLT_Mu6HT240_DisplacedDijet35_Inclusive0PtrkShortSig5_v14, fragment.HLT_Mu6HT240_DisplacedDijet35_Inclusive1PtrkShortSig5_DisplacedLoose_v14, fragment.HLT_Mu6HT240_DisplacedDijet40_Inclusive0PtrkShortSig5_v14, fragment.HLT_Mu6HT240_DisplacedDijet40_Inclusive1PtrkShortSig5_DisplacedLoose_v14, fragment.HLT_Mu6HT240_DisplacedDijet45_Inclusive0PtrkShortSig5_v14, fragment.HLT_Mu6HT240_DisplacedDijet50_Inclusive0PtrkShortSig5_v14, fragment.HLT_HT350_v9, fragment.HLT_HT425_v21, fragment.HLT_HT360_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT360_DisplacedDijet45_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT390_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT390_DisplacedDijet45_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT390eta2p0_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT430_DisplacedDijet40_Inclusive1PtrkShortSig5_v14, fragment.HLT_HT400_DisplacedDijet40_DisplacedTrack_v26, fragment.HLT_HT430_DisplacedDijet40_DisplacedTrack_v26, fragment.HLT_HT550_DisplacedDijet60_Inclusive_v26, fragment.HLT_HT650_DisplacedDijet60_Inclusive_v26, fragment.HLT_CaloMET60_DTCluster50_v13, fragment.HLT_CaloMET60_DTClusterNoMB1S50_v13, fragment.HLT_L1MET_DTCluster50_v13, fragment.HLT_L1MET_DTClusterNoMB1S50_v13, fragment.HLT_CscCluster_Loose_v11, fragment.HLT_CscCluster_Medium_v11, fragment.HLT_CscCluster_Tight_v11, fragment.HLT_CscCluster50_Photon20Unseeded_v5, fragment.HLT_CscCluster50_Photon30Unseeded_v5, fragment.HLT_CscCluster100_Ele5_v7, fragment.HLT_CscCluster100_Mu5_v10, fragment.HLT_CscCluster100_PNetTauhPFJet10_Loose_v10, fragment.HLT_CscCluster150_DisplacedSingleJet30_Inclusive1PtrkShortSig5_v3, fragment.HLT_CscCluster150_DisplacedSingleJet35_Inclusive1PtrkShortSig5_v3, fragment.HLT_CscCluster150_DisplacedSingleJet40_Inclusive1PtrkShortSig5_v3, fragment.HLT_DoubleCscCluster75_v8, fragment.HLT_IsoTrk200_L1SingleMuShower_v8, fragment.HLT_IsoTrk400_L1SingleMuShower_v8, fragment.HLT_DoubleCscCluster100_v8, fragment.HLT_L1CSCShower_DTCluster50_v11, fragment.HLT_L1CSCShower_DTCluster75_v11, fragment.HLT_PFMET105_IsoTrk50_v17, fragment.HLT_L1SingleLLPJet_v8, fragment.HLT_L1SingleMuShower_v1, fragment.HLT_HT170_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, fragment.HLT_HT200_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, fragment.HLT_HT200_L1SingleLLPJet_DisplacedDijet60_DisplacedTrack_v14, fragment.HLT_HT270_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, fragment.HLT_HT200_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v14, fragment.HLT_HT240_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11, fragment.HLT_HT280_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11, fragment.HLT_HT320_L1SingleLLPJet_DisplacedDijet60_Inclusive_v14, fragment.HLT_HT420_L1SingleLLPJet_DisplacedDijet60_Inclusive_v14, fragment.HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay1nsTrackless_v14, fragment.HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay2nsInclusive_v14, fragment.HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay0p5nsTrackless_v14, fragment.HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay1nsInclusive_v14, fragment.HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p7_v10, fragment.HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p8_v10, fragment.HLT_DiPhoton10Time1ns_v11, fragment.HLT_DiPhoton10Time1p2ns_v11, fragment.HLT_DiPhoton10Time1p4ns_v11, fragment.HLT_DiPhoton10Time1p6ns_v11, fragment.HLT_DiPhoton10Time1p8ns_v11, fragment.HLT_DiPhoton10Time2ns_v11, fragment.HLT_DiPhoton10_CaloIdL_v11, fragment.HLT_DiphotonMVA14p25_Low_Mass60_v1, fragment.HLT_DiphotonMVA14p25_Medium_Mass60_v1, fragment.HLT_DiphotonMVA14p25_High_Mass60_v1, fragment.HLT_DiphotonMVA14p25_TightLow_Mass60_v1, fragment.HLT_DiphotonMVA14p25_TightMedium_Mass60_v1, fragment.HLT_DiphotonMVA14p25_TightHigh_Mass60_v1, fragment.HLT_Diphoton15_10_EBEB_TightID_ECALTrackIsoDr0p2_v3, fragment.HLT_Diphoton15_12_EBEB_TightID_ECALTrackIsoDr0p2_v3, fragment.HLT_Diphoton15_10_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v3, fragment.HLT_Diphoton15_12_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v3, fragment.HLT_Dielectron12_5_EBEB_TightID_ECALTrackIsoDr0p2_v4, fragment.HLT_Dielectron12_5_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v4, fragment.HLT_DoubleEle6p5_eta1p22_mMax6_v13, fragment.HLT_DoubleEle8_eta1p22_mMax6_v13, fragment.HLT_DoubleEle10_eta1p22_mMax6_v13, fragment.HLT_SingleEle8_v12, fragment.HLT_SingleEle8_SingleEGL1_v12, fragment.HLT_Diphoton20_14_eta1p5_R9IdL_AND_HE_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton20_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton22_14_eta1p5_R9IdL_AND_HE_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton22_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton24_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton24_16_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, fragment.HLT_Mu50_L1SingleMuShower_v15, fragment.HLT_IsoMu24_OneProng32_v13, fragment.HLT_Photon32_OneProng32_M50To105_v14, fragment.HLT_VBF_DiPFJet125_45_Mjj1050_v12, fragment.HLT_VBF_DiPFJet125_45_Mjj1150_v4, fragment.HLT_VBF_DiPFJet125_45_Mjj1250_v4, fragment.HLT_VBF_DiPFJet75_45_Mjj800_DiPFJet60_v10, fragment.HLT_VBF_DiPFJet75_45_Mjj900_DiPFJet60_v4, fragment.HLT_VBF_DiPFJet75_45_Mjj1000_DiPFJet60_v4, fragment.HLT_VBF_DiPFJet80_45_Mjj650_PFMETNoMu85_v10, fragment.HLT_VBF_DiPFJet80_45_Mjj750_PFMETNoMu85_v10, fragment.HLT_VBF_DiPFJet80_45_Mjj850_PFMETNoMu85_v4, fragment.HLT_VBF_DiPFJet95_45_Mjj750_Mu3_TrkIsoVVL_v10, fragment.HLT_VBF_DiPFJet95_45_Mjj850_Mu3_TrkIsoVVL_v10, fragment.HLT_VBF_DiPFJet95_45_Mjj950_Mu3_TrkIsoVVL_v4, fragment.HLT_VBF_DiPFJet50_Mjj650_Photon22_v10, fragment.HLT_VBF_DiPFJet50_Mjj750_Photon22_v10, fragment.HLT_VBF_DiPFJet50_Mjj850_Photon22_v4, fragment.HLT_VBF_DiPFJet50_Mjj600_Ele22_eta2p1_WPTight_Gsf_v11, fragment.HLT_VBF_DiPFJet50_Mjj700_Ele22_eta2p1_WPTight_Gsf_v5, fragment.HLT_VBF_DiPFJet50_Mjj800_Ele22_eta2p1_WPTight_Gsf_v5, fragment.HLT_VBF_DiPFJet115_40_Mjj850_DoublePNetTauhPFJet20_eta2p3_v4, fragment.HLT_VBF_DiPFJet115_40_Mjj1000_DoublePNetTauhPFJet20_eta2p3_v4, fragment.HLT_VBF_DiPFJet115_40_Mjj1100_DoublePNetTauhPFJet20_eta2p3_v4, fragment.HLT_VBF_DiPFJet115_40_Mjj1200_DoublePNetTauhPFJet20_eta2p3_v4, fragment.HLT_VBF_DiPFJet45_Mjj650_PNetTauhPFJet45_L2NN_eta2p3_v10, fragment.HLT_VBF_DiPFJet45_Mjj750_PNetTauhPFJet45_L2NN_eta2p3_v10, fragment.HLT_VBF_DiPFJet45_Mjj850_PNetTauhPFJet45_L2NN_eta2p3_v4, fragment.HLT_L1HT200_QuadPFJet20_PNet1BTag0p50_PNet1Tauh0p50_v4, fragment.HLT_L1HT200_QuadPFJet25_PNet1BTag0p50_PNet1Tauh0p50_v4, fragment.HLT_IsoMu24_eta2p1_L1HT200_v4, fragment.HLT_IsoMu24_eta2p1_L1HT200_QuadPFJet25_v4, fragment.HLT_IsoMu24_eta2p1_L1HT200_QuadPFJet25_PNet1Tauh0p50_v4, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_v4, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet20_v4, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet25_v4, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet25_PNet1BTag0p50_v4, fragment.HLT_PFJet200_TimeLtNeg2p5ns_v14, fragment.HLT_PFJet200_TimeGt2p5ns_v14, fragment.HLT_Photon50_TimeLtNeg2p5ns_v8, fragment.HLT_Photon50_TimeGt2p5ns_v8, fragment.HLT_PPSMaxTracksPerArm1_v10, fragment.HLT_PPSMaxTracksPerRP4_v10, fragment.HLT_PPSRandom_v1, fragment.HLT_HIL1NotBptxOR_v15, fragment.HLT_HIL1UnpairedBunchBptxPlus_v15, fragment.HLT_HIL1UnpairedBunchBptxMinus_v15, fragment.HLT_HIPhysics_v15, fragment.HLT_HIPhysicsForZS_v15, fragment.HLT_HIRandom_v8, fragment.HLT_HIRandom_HighRate_v4, fragment.HLT_HIHcalNZS_v15, fragment.HLT_HIHcalPhiSym_v15, fragment.HLT_HIZeroBias_v15, fragment.HLT_HIZeroBias_HighRate_v8, fragment.HLT_HIZeroBias_FirstCollisionAfterAbortGap_v15, fragment.HLT_HIZeroBias_HighRateRAW_v5, fragment.HLT_HIMinimumBiasHF1AND_v8, fragment.HLT_HIMinimumBiasHF1AND_copy_v7, fragment.HLT_HIMinimumBiasHF1ANDZDC1nOR_v5, fragment.HLT_HIMinimumBiasHF1ANDZDC2nOR_v8, fragment.HLT_HIMinimumBiasHF1ANDZDC1nOR_copy_v5, fragment.HLT_HIMinimumBiasHF1ANDZDC2nOR_copy_v7, fragment.HLT_HICentrality30100_FirstCollisionAfterAbortGap_v15, fragment.HLT_HICentrality50100MinimumBiasHF1AND_Beamspot_v2, fragment.HLT_HIL1Centrality30_50_v8, fragment.HLT_HIL1_UCC_0_0p5_v9, fragment.HLT_HIL1_UCC_0_1_v9, fragment.HLT_HIPuAK4CaloJet40Eta5p1_MinBiasHF1AND_v8, fragment.HLT_HIPuAK4CaloJet40Eta5p1_MinBiasHF1AND_ZDC1nOR_v6, fragment.HLT_HIPuAK4CaloJet40Eta5p1_MinBiasHF1AND_ZDC2nOR_v8, fragment.HLT_HIPuAK4CaloJet60Eta5p1_MinBiasHF1AND_v8, fragment.HLT_HIPuAK4CaloJet60Eta5p1_MinBiasHF1AND_ZDC1nOR_v6, fragment.HLT_HIPuAK4CaloJet60Eta5p1_MinBiasHF1AND_ZDC2nOR_v8, fragment.HLT_HIPuAK4CaloJet80Eta5p1_v16, fragment.HLT_HIPuAK4CaloJet100Eta5p1_v16, fragment.HLT_HIPuAK4CaloJet120Eta2p1_v9, fragment.HLT_HIPuAK4CaloJet120Eta5p1_v16, fragment.HLT_HIPuAK4CaloJet40Fwd_v9, fragment.HLT_HIPuAK4CaloJet60Fwd_v9, fragment.HLT_HIPuAK4CaloJet80Fwd_v9, fragment.HLT_HIPuAK4CaloJet100Fwd_v9, fragment.HLT_HIPuAK4CaloJet120Fwd_v9, fragment.HLT_HIGEDPhoton10_v16, fragment.HLT_HIGEDPhoton10_EB_v16, fragment.HLT_HIGEDPhoton20_v16, fragment.HLT_HIGEDPhoton20_EB_v16, fragment.HLT_HIGEDPhoton30_v16, fragment.HLT_HIGEDPhoton30_EB_v16, fragment.HLT_HIGEDPhoton40_v16, fragment.HLT_HIGEDPhoton40_EB_v16, fragment.HLT_HIGEDPhoton50_v16, fragment.HLT_HIGEDPhoton50_EB_v16, fragment.HLT_HIGEDPhoton60_v16, fragment.HLT_HIGEDPhoton60_EB_v16, fragment.HLT_HIDoubleGEDPhoton20_v9, fragment.HLT_HIEle10Gsf_v16, fragment.HLT_HIEle15Gsf_v16, fragment.HLT_HIEle20Gsf_v16, fragment.HLT_HIEle30Gsf_v16, fragment.HLT_HIEle40Gsf_v16, fragment.HLT_HIEle50Gsf_v16, fragment.HLT_HIEle15Ele10Gsf_v16, fragment.HLT_HIEle15Ele10GsfMass50_v16, fragment.HLT_HIDoubleEle10Gsf_v16, fragment.HLT_HIDoubleEle10GsfMass50_v16, fragment.HLT_HIDoubleEle15Gsf_v16, fragment.HLT_HIDoubleEle15GsfMass50_v16, fragment.HLT_HIUPC_ZeroBias_MinPixelCluster400_MaxPixelCluster10000_v15, fragment.HLT_HIUPC_ZeroBias_SinglePixelTrackLowPt_MaxPixelCluster400_v14, fragment.HLT_HIUPC_ZeroBias_SinglePixelTrack_MaxPixelTrack_v15, fragment.HLT_HIUPC_NotMBHF2_v6, fragment.HLT_HIUPC_ZDC1nOR_MinPixelCluster400_MaxPixelCluster10000_v15, fragment.HLT_HIUPC_ZDC1nOR_SinglePixelTrackLowPt_MaxPixelCluster400_v14, fragment.HLT_HIUPC_ZDC1nOR_SinglePixelTrack_MaxPixelTrack_v15, fragment.HLT_HIUPC_ZDC1nXOR_MBHF1AND_PixelTrackMultiplicity20_v15, fragment.HLT_HIUPC_ZDC1nXOR_MBHF1AND_PixelTrackMultiplicity30_v15, fragment.HLT_HIUPC_ZDC1nXOR_MBHF1AND_PixelTrackMultiplicity40_v15, fragment.HLT_HIUPC_ZDC1nXOR_MBHF2AND_PixelTrackMultiplicity20_v15, fragment.HLT_HIUPC_ZDC1nXOR_MBHF2AND_PixelTrackMultiplicity30_v15, fragment.HLT_HIUPC_ZDC1nXOR_MBHF2AND_PixelTrackMultiplicity40_v15, fragment.HLT_HIUPC_ZDC1nAsymXOR_MBHF1AND_PixelTrackMultiplicity20_v7, fragment.HLT_HIUPC_ZDC1nAsymXOR_MBHF1AND_PixelTrackMultiplicity30_v7, fragment.HLT_HIUPC_ZDC1nAsymXOR_MBHF1AND_PixelTrackMultiplicity40_v7, fragment.HLT_HIUPC_ZDC1nAsymXOR_MBHF2AND_PixelTrackMultiplicity20_v7, fragment.HLT_HIUPC_ZDC1nAsymXOR_MBHF2AND_PixelTrackMultiplicity30_v7, fragment.HLT_HIUPC_ZDC1nAsymXOR_MBHF2AND_PixelTrackMultiplicity40_v7, fragment.HLT_HIUPC_SingleMuCosmic_BptxAND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_SingleMuCosmic_NotMBHF2AND_v11, fragment.HLT_HIUPC_SingleMuCosmic_NotMBHF2AND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_SingleMuCosmic_NotMBHF2OR_v11, fragment.HLT_HIUPC_SingleMuCosmic_NotMBHF2OR_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_SingleMuOpen_BptxAND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_SingleMuOpen_NotMBHF2AND_v13, fragment.HLT_HIUPC_SingleMuOpen_NotMBHF2AND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_SingleMuOpen_NotMBHF2OR_v13, fragment.HLT_HIUPC_SingleMuOpen_NotMBHF2OR_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_BptxAND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2AND_v11, fragment.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2AND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2OR_v11, fragment.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2OR_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_DoubleMuCosmic_BptxAND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_DoubleMuCosmic_NotMBHF2AND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_DoubleMuCosmic_NotMBHF2AND_v11, fragment.HLT_HIUPC_DoubleMuOpen_BptxAND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_DoubleMuOpen_NotMBHF2AND_v11, fragment.HLT_HIUPC_DoubleMuOpen_NotMBHF2AND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_SingleEG2_NotMBHF2AND_ZDC1nOR_SinglePixelTrack_MaxPixelTrack_v14, fragment.HLT_HIUPC_SingleEG3_BptxAND_SinglePixelTrack_MaxPixelTrack_v17, fragment.HLT_HIUPC_SingleEG3_NotMBHF2AND_v13, fragment.HLT_HIUPC_SingleEG3_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v16, fragment.HLT_HIUPC_SingleEG3_NotMBHF2OR_v13, fragment.HLT_HIUPC_SingleEG3_NotMBHF2OR_SinglePixelTrack_MaxPixelTrack_v16, fragment.HLT_HIUPC_SingleEG5_BptxAND_SinglePixelTrack_MaxPixelTrack_v17, fragment.HLT_HIUPC_SingleEG4_NotMBHF2AND_v2, fragment.HLT_HIUPC_SingleEG5_NotMBHF2AND_v13, fragment.HLT_HIUPC_SingleEG5_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v16, fragment.HLT_HIUPC_DoubleEG2_BptxAND_SinglePixelTrack_MaxPixelTrack_v17, fragment.HLT_HIUPC_DoubleEG2_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v16, fragment.HLT_HIUPC_DoubleEG2_NotMBHF2AND_v13, fragment.HLT_HIUPC_DoubleEG3_NotMBHF2AND_v1, fragment.HLT_HIUPC_DoubleEG3_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v2, fragment.HLT_HIUPC_DoubleEG5_BptxAND_SinglePixelTrack_MaxPixelTrack_v17, fragment.HLT_HIUPC_DoubleEG5_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v16, fragment.HLT_HIUPC_DoubleEG5_NotMBHF2AND_v13, fragment.HLT_HIUPC_SingleJet8_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet12_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet16_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet20_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet24_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet28_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet8_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet12_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet16_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet20_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet24_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet28_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet8_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet12_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet16_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet20_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet24_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet28_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_ZeroBias_MaxPixelCluster10000_v4, fragment.HLT_HIUPC_ZDC1nOR_MaxPixelCluster10000_v4, fragment.HLT_HIUPC_ZDC1nOR_MBHF1AND_PixelTrackMultiplicity20400_v4, fragment.HLT_HIUPC_ZDC1nOR_MBHF1AND_PixelTrackMultiplicity30400_v4, fragment.HLT_HIUPC_ZDC1nOR_MBHF1AND_PixelTrackMultiplicity40400_v4, fragment.HLT_HIUPC_ZDC1nAND_NotMBHF2_MaxPixelCluster10000_v4, fragment.HLT_HIUPC_MinPixelThrust0p8_MaxPixelCluster10000_v4, fragment.HLT_HIUPC_SingleUncorrJet8_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet12_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet16_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet20_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet24_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet28_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet8_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet12_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet16_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet20_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet24_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet28_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet8_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet12_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet16_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet20_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet24_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet28_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleUncorrJet8_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleUncorrJet12_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleUncorrJet16_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleUncorrJet8_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleUncorrJet12_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleUncorrJet16_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleUncorrJet8_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleUncorrJet12_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleUncorrJet16_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_ZDC1nOR_RapGap_MaxPixelCluster10000_v4, fragment.HLT_HIUPC_SingleJet8_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet12_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet16_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet20_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet24_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet28_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet8_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet12_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet16_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet20_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet24_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet28_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet8_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet12_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet16_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet20_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet24_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet28_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleJet8_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleJet12_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleJet16_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleJet8_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleJet12_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleJet16_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleJet8_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleJet12_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleJet16_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_Random_HighRate_v2, fragment.HLT_HIUPC_HFafterglowCombined_v2, fragment.HLT_HIL1SingleMuOpen_Centrality30to100_v2, fragment.HLT_HIL1SingleMu0_Centrality30to100_v2, fragment.HLT_HIL1SingleMu0_Centrality40to100_v2, fragment.HLT_HIL1SingleMu0_v8, fragment.HLT_HIL1SingleMu0_Open_v8, fragment.HLT_HIL1SingleMu0_Cosmic_v8, fragment.HLT_HIL1SingleMu5_SingleEG20Gsf_v9, fragment.HLT_HIL1SingleMu5_SingleGEDPhoton20_v9, fragment.HLT_HIL1SingleMu7_SingleEG20Gsf_v9, fragment.HLT_HIL1SingleMu7_SingleGEDPhoton20_v3, fragment.HLT_HIL2DoubleMuOpen_Centrality40to100_v2, fragment.HLT_HIL2DoubleMuOpen_SS_v2, fragment.HLT_HIL2DoubleMuOpen_OS_v2, fragment.HLT_HIL1DoubleMu0_v8, fragment.HLT_HIL2DoubleMu0_SQ_v2, fragment.HLT_HIL1DoubleMu0_MaxDr3p5_Open_v8, fragment.HLT_HIL1DoubleMu0_SQ_v8, fragment.HLT_HIL2SingleMuOpen_Centrality30to100_v2, fragment.HLT_HIL2SingleMu0_Centrality30to100_v2, fragment.HLT_HIL2SingleMu0_Centrality40to100_v2, fragment.HLT_HIL2SingleMu3_Open_v8, fragment.HLT_HIL2SingleMu5_v8, fragment.HLT_HIL2SingleMu7_v8, fragment.HLT_HIL2SingleMu12_v2, fragment.HLT_HIL2DoubleMu0_Open_v8, fragment.HLT_HIL2DoubleMu0_M1p5to6_Open_v8, fragment.HLT_HIL2DoubleMu0_M7to15_Open_v8, fragment.HLT_HIL2DoubleMu2p8_M1p5to6_Open_v8, fragment.HLT_HIL2DoubleMu3_M7to15_Open_v8, fragment.HLT_HIDmesonPPOnAATrackingGlobal_Dpt30_v10, fragment.HLT_HIDmesonPPOnAATrackingGlobal_Dpt45_v10, fragment.HLT_HIDmesonPPOnAATrackingGlobal_Dpt60_v10, fragment.HLT_HICscCluster_Loose_v8, fragment.HLT_HICscCluster_Medium_v8, fragment.HLT_HICscCluster_Tight_v8, fragment.HLT_HIL1UnpairedBunchBptxMinusForPPRef_v10, fragment.HLT_HIL1UnpairedBunchBptxPlusForPPRef_v10, fragment.HLT_HIL1NotBptxORForPPRef_v10, fragment.HLT_HIHT80_Beamspot_ppRef5TeV_v19, fragment.HLT_PPRefZeroBias_v7, fragment.HLT_AK4CaloJet40_v8, fragment.HLT_AK4CaloJet60_v8, fragment.HLT_AK4CaloJet70_v8, fragment.HLT_AK4CaloJet80_v8, fragment.HLT_AK4CaloJet100_v8, fragment.HLT_AK4CaloJet120_v8, fragment.HLT_AK4CaloJetFwd40_v8, fragment.HLT_AK4CaloJetFwd60_v8, fragment.HLT_AK4CaloJetFwd70_v8, fragment.HLT_AK4CaloJetFwd80_v8, fragment.HLT_AK4CaloJetFwd100_v8, fragment.HLT_AK4CaloJetFwd120_v8, fragment.HLT_AK4PFJet40_v12, fragment.HLT_AK4PFJet60_v12, fragment.HLT_AK4PFJet80_v12, fragment.HLT_AK4PFJet100_v12, fragment.HLT_AK4PFJet120_v12, fragment.HLT_AK4PFJetFwd40_v12, fragment.HLT_AK4PFJetFwd60_v12, fragment.HLT_AK4PFJetFwd80_v12, fragment.HLT_AK4PFJetFwd100_v12, fragment.HLT_AK4PFJetFwd120_v12, fragment.HLT_PPRefDoubleEle10Gsf_v10, fragment.HLT_PPRefDoubleEle10GsfMass50_v10, fragment.HLT_PPRefDoubleEle15Gsf_v10, fragment.HLT_PPRefDoubleEle15GsfMass50_v10, fragment.HLT_PPRefEle15Ele10Gsf_v10, fragment.HLT_PPRefEle15Ele10GsfMass50_v10, fragment.HLT_PPRefEle10Gsf_v10, fragment.HLT_PPRefEle15Gsf_v10, fragment.HLT_PPRefEle20Gsf_v11, fragment.HLT_PPRefEle30Gsf_v11, fragment.HLT_PPRefEle40Gsf_v10, fragment.HLT_PPRefEle50Gsf_v10, fragment.HLT_PPRefGEDPhoton10_v8, fragment.HLT_PPRefGEDPhoton10_EB_v8, fragment.HLT_PPRefGEDPhoton20_v8, fragment.HLT_PPRefGEDPhoton20_EB_v8, fragment.HLT_PPRefGEDPhoton30_v8, fragment.HLT_PPRefGEDPhoton30_EB_v8, fragment.HLT_PPRefGEDPhoton40_v8, fragment.HLT_PPRefGEDPhoton40_EB_v8, fragment.HLT_PPRefGEDPhoton50_v8, fragment.HLT_PPRefGEDPhoton50_EB_v8, fragment.HLT_PPRefGEDPhoton60_v8, fragment.HLT_PPRefGEDPhoton60_EB_v8, fragment.HLT_PPRefDoubleGEDPhoton20_v3, fragment.HLT_PPRefL1DoubleMu0_v7, fragment.HLT_PPRefL1DoubleMu0_SQ_v2, fragment.HLT_PPRefL1DoubleMu0_Open_v7, fragment.HLT_PPRefL1DoubleMu2_v2, fragment.HLT_PPRefL1DoubleMu2_SQ_v2, fragment.HLT_PPRefL1SingleMu0_Cosmics_v7, fragment.HLT_PPRefL1SingleMu7_v7, fragment.HLT_PPRefL1SingleMu12_v7, fragment.HLT_PPRefL1SingleMu5_Ele20Gsf_v5, fragment.HLT_PPRefL1SingleMu5_GEDPhoton20_v3, fragment.HLT_PPRefL1SingleMu7_Ele20Gsf_v5, fragment.HLT_PPRefL1SingleMu7_GEDPhoton10_v3, fragment.HLT_PPRefL2DoubleMu0_v7, fragment.HLT_PPRefL2DoubleMu0_Open_v7, fragment.HLT_PPRefL2SingleMu7_v7, fragment.HLT_PPRefL2SingleMu12_v7, fragment.HLT_PPRefL2SingleMu15_v7, fragment.HLT_PPRefL2SingleMu20_v7, fragment.HLT_PPRefL3DoubleMu0_v12, fragment.HLT_PPRefL3DoubleMu0_Open_v12, fragment.HLT_PPRefL3SingleMu3_v12, fragment.HLT_PPRefL3SingleMu5_v12, fragment.HLT_PPRefL3SingleMu7_v12, fragment.HLT_PPRefL3SingleMu12_v12, fragment.HLT_PPRefL3SingleMu15_v12, fragment.HLT_PPRefL3SingleMu20_v12, fragment.HLT_PPRefL3SingleMu3_SingleAK4CaloJet40_v5, fragment.HLT_PPRefL3SingleMu3_SingleAK4CaloJet60_v5, fragment.HLT_PPRefL3SingleMu3_SingleAK4CaloJet80_v5, fragment.HLT_PPRefL3SingleMu5_SingleAK4CaloJet40_v5, fragment.HLT_PPRefL3SingleMu5_SingleAK4CaloJet60_v5, fragment.HLT_PPRefL3SingleMu5_SingleAK4CaloJet80_v5, fragment.HLT_PPRefCscCluster_Loose_v7, fragment.HLT_PPRefCscCluster_Medium_v7, fragment.HLT_PPRefCscCluster_Tight_v7, fragment.HLT_PPRefUPC_SingleJet8_ZDC1nAsymXOR_v2, fragment.HLT_PPRefUPC_SingleJet12_ZDC1nAsymXOR_v2, fragment.HLT_PPRefUPC_SingleJet16_ZDC1nAsymXOR_v2, fragment.HLT_PPRefUPC_SingleJet20_ZDC1nAsymXOR_v2, fragment.HLT_PPRefUPC_SingleJet24_ZDC1nAsymXOR_v2, fragment.HLT_PPRefUPC_SingleJet28_ZDC1nAsymXOR_v2, fragment.HLT_PPRefUPC_SingleJet8_ZDC1nOR_v2, fragment.HLT_PPRefUPC_SingleJet12_ZDC1nOR_v2, fragment.HLT_PPRefUPC_SingleJet16_ZDC1nOR_v2, fragment.HLT_PPRefUPC_SingleJet20_ZDC1nOR_v2, fragment.HLT_PPRefUPC_SingleJet24_ZDC1nOR_v2, fragment.HLT_PPRefUPC_SingleJet28_ZDC1nOR_v2, fragment.HLT_PPRefUPC_ZDC1nAsymXOR_v2, fragment.HLT_PPRefUPC_ZDC1nOR_v2, fragment.HLT_PPRefZeroBias_FirstCollisionInTrain_v1, fragment.HLT_TestData_v1, fragment.MC_ReducedIterativeTracking_v26, fragment.MC_AK4CaloJets_v21, fragment.MC_AK4CaloJetsFromPV_v21, fragment.MC_CaloHT_v20, fragment.MC_AK8CaloHT_v20, fragment.MC_CaloMHT_v20, fragment.MC_AK4PFJets_v33, fragment.MC_PFHT_v32, fragment.MC_AK8PFJets_v33, fragment.MC_AK8PFHT_v32, fragment.MC_CaloMET_v20, fragment.MC_CaloMET_JetIdCleaned_v21, fragment.MC_PFMET_v33, fragment.MC_PFMHT_v32, fragment.MC_AK4PFJetPNet_v9, fragment.MC_AK8PFJetPNet_v9, fragment.MC_Egamma_Open_v12, fragment.MC_Egamma_Open_Unseeded_v12, fragment.MC_Ele5_WPTight_Gsf_v23, fragment.MC_Ele15_Ele10_CaloIdL_TrackIdL_IsoVL_DZ_v29, fragment.MC_Diphoton10_10_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass10_v26, fragment.MC_DoubleEle5_CaloIdL_MW_v29, fragment.MC_IsoMu_v31, fragment.MC_DoubleMu_TrkIsoVVL_DZ_v27, fragment.MC_DoubleMuNoFiltersNoVtx_v20, fragment.MC_PFScouting_v10, fragment.HLT_SpecialHLTPhysics_v8, fragment.AlCa_LumiPixelsCounts_RandomHighRate_v6, fragment.AlCa_LumiPixelsCounts_ZeroBiasVdM_v6, fragment.AlCa_LumiPixelsCounts_ZeroBiasGated_v7, fragment.HLT_L1AlwaysTrue_v1, fragment.HLT_L1SingleMuOpen_v7, fragment.HLT_L1SingleMuOpen_DT_v7, fragment.HLT_L1SingleMu3_v6, fragment.HLT_L1SingleMu5_v6, fragment.HLT_L1SingleMu7_v6, fragment.HLT_L1DoubleMu0_v6, fragment.HLT_L1SingleJet8erHE_v6, fragment.HLT_L1SingleJet10erHE_v6, fragment.HLT_L1SingleJet12erHE_v6, fragment.HLT_L1SingleJet35_v6, fragment.HLT_L1SingleJet200_v6, fragment.HLT_L1SingleEG8er2p5_v5, fragment.HLT_L1SingleEG10er2p5_v5, fragment.HLT_L1SingleEG15er2p5_v5, fragment.HLT_L1SingleEG26er2p5_v5, fragment.HLT_L1SingleEG28er2p5_v5, fragment.HLT_L1SingleEG28er2p1_v5, fragment.HLT_L1SingleEG28er1p5_v5, fragment.HLT_L1SingleEG34er2p5_v5, fragment.HLT_L1SingleEG36er2p5_v5, fragment.HLT_L1SingleEG38er2p5_v5, fragment.HLT_L1SingleEG40er2p5_v5, fragment.HLT_L1SingleEG42er2p5_v5, fragment.HLT_L1SingleEG45er2p5_v5, fragment.HLT_L1SingleEG50_v5, fragment.HLT_L1SingleJet60_v5, fragment.HLT_L1SingleJet90_v5, fragment.HLT_L1SingleJet120_v5, fragment.HLT_L1SingleJet180_v5, fragment.HLT_L1HTT120er_v5, fragment.HLT_L1HTT160er_v5, fragment.HLT_L1HTT200er_v5, fragment.HLT_L1HTT255er_v5, fragment.HLT_L1HTT280er_v5, fragment.HLT_L1HTT320er_v5, fragment.HLT_L1HTT360er_v5, fragment.HLT_L1HTT400er_v5, fragment.HLT_L1HTT450er_v5, fragment.HLT_L1ETM120_v5, fragment.HLT_L1ETM150_v5, fragment.HLT_L1EXT_HCAL_LaserMon1_v6, fragment.HLT_L1EXT_HCAL_LaserMon4_v6, fragment.HLT_L1MinimumBiasHF0ANDBptxAND_v1, fragment.HLT_L1AXOVVTight_v1, fragment.HLT_L1AXOVVVTight_v1, fragment.HLT_L1CICADA_VVTight_v1, fragment.HLT_L1CICADA_VVVTight_v1, fragment.HLT_L1CICADA_VVVVTight_v1, fragment.HLT_CscCluster_Cosmic_v5, fragment.HLT_HT60_Beamspot_v26, fragment.HLT_Beamspot_PixelClusters_WP2_v10, fragment.HLT_PixelClusters_WP2_v5, fragment.HLT_PixelClusters_WP2_HighRate_v1, fragment.HLT_PixelClusters_WP1_v5, fragment.HLT_BptxOR_v7, fragment.HLT_L1SingleMuCosmics_EMTF_v5, fragment.HLT_L1SingleMuCosmics_CosmicTracking_v2, fragment.HLT_L1SingleMuCosmics_PointingCosmicTracking_v2, fragment.HLT_L1FatEvents_v6, fragment.HLT_Random_HighRate_v1, fragment.HLT_ZeroBias_HighRate_v5, fragment.HLT_ZeroBias_Gated_v6, fragment.HLT_SpecialZeroBias_v7, fragment.HLT_HIHT80_Beamspot_Oxy5TeV_v3, fragment.HLT_MinimumBiasHF_AND_BptxAND_v1, fragment.HLT_MinimumBiasHF_OR_BptxAND_v1, fragment.HLT_MinimumBiasZDC1n_OR_BptxAND_v1, fragment.HLT_MinimumBiasZDC1n_OR_MinimumBiasHF_AND_BptxAND_v1, fragment.HLT_MinimumBiasZDC1n_OR_MinimumBiasHF_OR_BptxAND_v1, fragment.HLT_MinimumBiasZDC1n_OR_OR_MinimumBiasHF_OR_BptxAND_v1, fragment.HLT_MinimumBiasZDC_Asym_MinimumBiasHF_OR_BptxAND_v1, fragment.HLT_OxyDoubleEG2_NotMBHF2AND_v1, fragment.HLT_OxyDoubleEG5_NotMBHF2AND_v1, fragment.HLT_OxyL1CentralityGate_v1, fragment.HLT_OxyL1DoubleMu0_v1, fragment.HLT_OxyL1DoubleMuOpen_v1, fragment.HLT_OxyL1SingleEG10_v1, fragment.HLT_OxyL1SingleEG15_v1, fragment.HLT_OxyL1SingleEG15er2p1_v1, fragment.HLT_OxyL1SingleEG15er2p5_v1, fragment.HLT_OxyL1SingleEG21_v1, fragment.HLT_OxyL1SingleJet20_v1, fragment.HLT_OxyL1SingleJet28_v1, fragment.HLT_OxyL1SingleJet35_v1, fragment.HLT_OxyL1SingleJet44_v1, fragment.HLT_OxyL1SingleJet60_v1, fragment.HLT_OxyL1SingleMu0_v1, fragment.HLT_OxyL1SingleMu3_v1, fragment.HLT_OxyL1SingleMu5_v1, fragment.HLT_OxyL1SingleMu7_v1, fragment.HLT_OxyL1SingleMuOpen_v1, fragment.HLT_OxyNotMBHF2_v1, fragment.HLT_OxySingleEG2_NotMBHF2AND_ZDC1nOR_v1, fragment.HLT_OxySingleEG3_NotMBHF2AND_v1, fragment.HLT_OxySingleEG3_NotMBHF2OR_v1, fragment.HLT_OxySingleEG5_NotMBHF2AND_v1, fragment.HLT_OxySingleJet16_ZDC1nAsymXOR_NotPreBptx_v1, fragment.HLT_OxySingleJet16_ZDC1nAsymXOR_v1, fragment.HLT_OxySingleJet16_ZDC1nXOR_v1, fragment.HLT_OxySingleJet24_ZDC1nAsymXOR_NotPreBptx_v1, fragment.HLT_OxySingleJet24_ZDC1nAsymXOR_v1, fragment.HLT_OxySingleJet24_ZDC1nXOR_v1, fragment.HLT_OxySingleJet8_ZDC1nAsymXOR_NotPreBptx_v1, fragment.HLT_OxySingleJet8_ZDC1nAsymXOR_v1, fragment.HLT_OxySingleJet8_ZDC1nXOR_v1, fragment.HLT_OxySingleMuCosmic_NotMBHF2AND_v1, fragment.HLT_OxySingleMuOpen_NotMBHF2AND_v1, fragment.HLT_OxySingleMuOpen_NotMBHF2OR_v1, fragment.HLT_OxySingleMuOpen_OR_SingleMuCosmic_EMTF_BptxAND_v1, fragment.HLT_OxySingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2AND_v1, fragment.HLT_OxyZDC1nOR_v1, fragment.HLT_OxyZeroBias_v1, fragment.HLT_OxyZeroBias_SinglePixelTrackLowPt_MaxPixelCluster400_v1, fragment.HLT_OxyZeroBias_MinPixelCluster400_v1, fragment.HLTriggerFinalPath, fragment.HLTAnalyzerEndpath, fragment.Dataset_AlCaHcalIsoTrk, fragment.Dataset_AlCaLowPtJet, fragment.Dataset_AlCaLumiPixelsCountsExpress, fragment.Dataset_AlCaLumiPixelsCountsPrompt, fragment.Dataset_AlCaLumiPixelsCountsPromptHighRate0, fragment.Dataset_AlCaLumiPixelsCountsPromptHighRate1, fragment.Dataset_AlCaLumiPixelsCountsPromptHighRate2, fragment.Dataset_AlCaLumiPixelsCountsPromptHighRate3, fragment.Dataset_AlCaLumiPixelsCountsPromptHighRate4, fragment.Dataset_AlCaLumiPixelsCountsPromptHighRate5, fragment.Dataset_AlCaLumiPixelsCountsGated, fragment.Dataset_AlCaP0, fragment.Dataset_AlCaPPSExpress, fragment.Dataset_AlCaPPSPrompt, fragment.Dataset_AlCaPhiSym, fragment.Dataset_BTagMu, fragment.Dataset_Commissioning, fragment.Dataset_Cosmics, fragment.Dataset_DQMGPUvsCPU, fragment.Dataset_DQMOnlineBeamspot, fragment.Dataset_DQMPPSRandom, fragment.Dataset_EGamma0, fragment.Dataset_EGamma1, fragment.Dataset_EGamma2, fragment.Dataset_EGamma3, fragment.Dataset_EcalLaser, fragment.Dataset_EmptyBX, fragment.Dataset_EphemeralHLTPhysics0, fragment.Dataset_EphemeralHLTPhysics1, fragment.Dataset_EphemeralHLTPhysics2, fragment.Dataset_EphemeralHLTPhysics3, fragment.Dataset_EphemeralHLTPhysics4, fragment.Dataset_EphemeralHLTPhysics5, fragment.Dataset_EphemeralHLTPhysics6, fragment.Dataset_EphemeralHLTPhysics7, fragment.Dataset_EphemeralZeroBias0, fragment.Dataset_EphemeralZeroBias1, fragment.Dataset_EphemeralZeroBias2, fragment.Dataset_EphemeralZeroBias3, fragment.Dataset_EphemeralZeroBias4, fragment.Dataset_EphemeralZeroBias5, fragment.Dataset_EphemeralZeroBias6, fragment.Dataset_EphemeralZeroBias7, fragment.Dataset_EventDisplay, fragment.Dataset_ExpressAlignment, fragment.Dataset_ExpressCosmics, fragment.Dataset_ExpressPhysics, fragment.Dataset_HIDQMGPUvsCPU, fragment.Dataset_HIDQMOnlineBeamspot, fragment.Dataset_HIEmptyBX, fragment.Dataset_HIEphemeralHLTPhysics, fragment.Dataset_HIEphemeralZeroBias0, fragment.Dataset_HIEphemeralZeroBias1, fragment.Dataset_HIEventDisplay, fragment.Dataset_HIExpressAlignment, fragment.Dataset_HIExpressPhysics, fragment.Dataset_HIExpressPhysicsRawPrime, fragment.Dataset_HIForward0, fragment.Dataset_HIForward1, fragment.Dataset_HIForward2, fragment.Dataset_HIForward3, fragment.Dataset_HIForward4, fragment.Dataset_HIForward5, fragment.Dataset_HIForward6, fragment.Dataset_HIForward7, fragment.Dataset_HIForward8, fragment.Dataset_HIForward9, fragment.Dataset_HIForward10, fragment.Dataset_HIForward11, fragment.Dataset_HIForward12, fragment.Dataset_HIForward13, fragment.Dataset_HIForward14, fragment.Dataset_HIForward15, fragment.Dataset_HIForward16, fragment.Dataset_HIForward17, fragment.Dataset_HIForward18, fragment.Dataset_HIForward19, fragment.Dataset_HIHLTPhysics, fragment.Dataset_HIHcalNZS, fragment.Dataset_HIOnlineMonitor, fragment.Dataset_HIMinimumBias0, fragment.Dataset_HIMinimumBias1, fragment.Dataset_HIMinimumBias2, fragment.Dataset_HIMinimumBias3, fragment.Dataset_HIPhysicsRawPrime0, fragment.Dataset_HITrackerNZS, fragment.Dataset_HIZeroBias0, fragment.Dataset_HIZeroBias1, fragment.Dataset_HIZeroBias2, fragment.Dataset_HLTMonitor, fragment.Dataset_HLTPhysics, fragment.Dataset_HcalNZS, fragment.Dataset_JetMET0, fragment.Dataset_JetMET1, fragment.Dataset_L1Accept, fragment.Dataset_MinimumBias, fragment.Dataset_MonteCarlo, fragment.Dataset_Muon0, fragment.Dataset_Muon1, fragment.Dataset_MuonEG, fragment.Dataset_MuonShower, fragment.Dataset_NoBPTX, fragment.Dataset_OnlineMonitor, fragment.Dataset_PPRefDoubleMuon0, fragment.Dataset_PPRefDoubleMuon1, fragment.Dataset_PPRefDoubleMuon2, fragment.Dataset_PPRefDoubleMuon3, fragment.Dataset_PPRefHardProbes0, fragment.Dataset_PPRefSingleMuon0, fragment.Dataset_PPRefZeroBiasPlusForward0, fragment.Dataset_ParkingDoubleMuonLowMass0, fragment.Dataset_ParkingDoubleMuonLowMass1, fragment.Dataset_ParkingDoubleMuonLowMass2, fragment.Dataset_ParkingDoubleMuonLowMass3, fragment.Dataset_ParkingDoubleMuonLowMass4, fragment.Dataset_ParkingDoubleMuonLowMass5, fragment.Dataset_ParkingDoubleMuonLowMass6, fragment.Dataset_ParkingDoubleMuonLowMass7, fragment.Dataset_ParkingHH0, fragment.Dataset_ParkingHH1, fragment.Dataset_ParkingLLP0, fragment.Dataset_ParkingLLP1, fragment.Dataset_ParkingSingleMuon0, fragment.Dataset_ParkingSingleMuon1, fragment.Dataset_ParkingSingleMuon2, fragment.Dataset_ParkingSingleMuon3, fragment.Dataset_ParkingSingleMuon4, fragment.Dataset_ParkingSingleMuon5, fragment.Dataset_ParkingSingleMuon6, fragment.Dataset_ParkingSingleMuon7, fragment.Dataset_ParkingSingleMuon8, fragment.Dataset_ParkingSingleMuon9, fragment.Dataset_ParkingSingleMuon10, fragment.Dataset_ParkingSingleMuon11, fragment.Dataset_ParkingSingleMuon12, fragment.Dataset_ParkingSingleMuon13, fragment.Dataset_ParkingSingleMuon14, fragment.Dataset_ParkingSingleMuon15, fragment.Dataset_ParkingVBF0, fragment.Dataset_ParkingVBF1, fragment.Dataset_ParkingVBF2, fragment.Dataset_ParkingVBF3, fragment.Dataset_ParkingVBF4, fragment.Dataset_ParkingVBF5, fragment.Dataset_ParkingVBF6, fragment.Dataset_ParkingVBF7, fragment.Dataset_ParkingAnomalyDetection, fragment.Dataset_RPCMonitor, fragment.Dataset_ScoutingPFMonitor, fragment.Dataset_ScoutingPF0, fragment.Dataset_ScoutingPF1, fragment.Dataset_Tau, fragment.Dataset_TestEnablesEcalHcal, fragment.Dataset_TestEnablesEcalHcalDQM, fragment.Dataset_VRRandom0, fragment.Dataset_VRRandom1, fragment.Dataset_VRRandom2, fragment.Dataset_VRRandom3, fragment.Dataset_VRRandom4, fragment.Dataset_VRRandom5, fragment.Dataset_VRRandom6, fragment.Dataset_VRRandom7, fragment.Dataset_VRRandom8, fragment.Dataset_VRRandom9, fragment.Dataset_VRRandom10, fragment.Dataset_VRRandom11, fragment.Dataset_VRRandom12, fragment.Dataset_VRRandom13, fragment.Dataset_VRRandom14, fragment.Dataset_VRRandom15, fragment.Dataset_ZeroBias, fragment.Dataset_SpecialRandom0, fragment.Dataset_SpecialRandom1, fragment.Dataset_SpecialRandom2, fragment.Dataset_SpecialRandom3, fragment.Dataset_SpecialRandom4, fragment.Dataset_SpecialRandom5, fragment.Dataset_SpecialRandom6, fragment.Dataset_SpecialRandom7, fragment.Dataset_SpecialRandom8, fragment.Dataset_SpecialRandom9, fragment.Dataset_SpecialRandom10, fragment.Dataset_SpecialRandom11, fragment.Dataset_SpecialRandom12, fragment.Dataset_SpecialRandom13, fragment.Dataset_SpecialRandom14, fragment.Dataset_SpecialRandom15, fragment.Dataset_SpecialRandom16, fragment.Dataset_SpecialRandom17, fragment.Dataset_SpecialRandom18, fragment.Dataset_SpecialRandom19, fragment.Dataset_SpecialZeroBias0, fragment.Dataset_SpecialZeroBias1, fragment.Dataset_SpecialZeroBias2, fragment.Dataset_SpecialZeroBias3, fragment.Dataset_SpecialZeroBias4, fragment.Dataset_SpecialZeroBias5, fragment.Dataset_SpecialZeroBias6, fragment.Dataset_SpecialZeroBias7, fragment.Dataset_SpecialZeroBias8, fragment.Dataset_SpecialZeroBias9, fragment.Dataset_SpecialZeroBias10, fragment.Dataset_SpecialZeroBias11, fragment.Dataset_SpecialZeroBias12, fragment.Dataset_SpecialZeroBias13, fragment.Dataset_SpecialZeroBias14, fragment.Dataset_SpecialZeroBias15, fragment.Dataset_SpecialZeroBias16, fragment.Dataset_SpecialZeroBias17, fragment.Dataset_SpecialZeroBias18, fragment.Dataset_SpecialZeroBias19, fragment.Dataset_SpecialZeroBias20, fragment.Dataset_SpecialZeroBias21, fragment.Dataset_SpecialZeroBias22, fragment.Dataset_SpecialZeroBias23, fragment.Dataset_SpecialZeroBias24, fragment.Dataset_SpecialZeroBias25, fragment.Dataset_SpecialZeroBias26, fragment.Dataset_SpecialZeroBias27, fragment.Dataset_SpecialZeroBias28, fragment.Dataset_SpecialZeroBias29, fragment.Dataset_SpecialZeroBias30, fragment.Dataset_SpecialZeroBias31, fragment.Dataset_SpecialHLTPhysics0, fragment.Dataset_SpecialHLTPhysics1, fragment.Dataset_SpecialHLTPhysics2, fragment.Dataset_SpecialHLTPhysics3, fragment.Dataset_SpecialHLTPhysics4, fragment.Dataset_SpecialHLTPhysics5, fragment.Dataset_SpecialHLTPhysics6, fragment.Dataset_SpecialHLTPhysics7, fragment.Dataset_SpecialHLTPhysics8, fragment.Dataset_SpecialHLTPhysics9, fragment.Dataset_SpecialHLTPhysics10, fragment.Dataset_SpecialHLTPhysics11, fragment.Dataset_SpecialHLTPhysics12, fragment.Dataset_SpecialHLTPhysics13, fragment.Dataset_SpecialHLTPhysics14, fragment.Dataset_SpecialHLTPhysics15, fragment.Dataset_SpecialHLTPhysics16, fragment.Dataset_SpecialHLTPhysics17, fragment.Dataset_SpecialHLTPhysics18, fragment.Dataset_SpecialHLTPhysics19, fragment.Dataset_PPRefZeroBiasPlusForward1, fragment.Dataset_PPRefZeroBiasPlusForward2, fragment.Dataset_PPRefZeroBiasPlusForward3, fragment.Dataset_PPRefZeroBiasPlusForward4, fragment.Dataset_PPRefZeroBiasPlusForward5, fragment.Dataset_PPRefZeroBiasPlusForward6, fragment.Dataset_PPRefZeroBiasPlusForward7, fragment.Dataset_PPRefZeroBiasPlusForward8, fragment.Dataset_PPRefZeroBiasPlusForward9, fragment.Dataset_PPRefZeroBiasPlusForward10, fragment.Dataset_PPRefZeroBiasPlusForward11, fragment.Dataset_PPRefZeroBiasPlusForward12, fragment.Dataset_PPRefZeroBiasPlusForward13, fragment.Dataset_PPRefZeroBiasPlusForward14, fragment.Dataset_PPRefZeroBiasPlusForward15, fragment.Dataset_PPRefZeroBiasPlusForward16, fragment.Dataset_PPRefZeroBiasPlusForward17, fragment.Dataset_PPRefZeroBiasPlusForward18, fragment.Dataset_PPRefZeroBiasPlusForward19, fragment.Dataset_PPRefZeroBiasPlusForward20, fragment.Dataset_PPRefZeroBiasPlusForward21, fragment.Dataset_PPRefZeroBiasPlusForward22, fragment.Dataset_PPRefZeroBiasPlusForward23, fragment.Dataset_PPRefZeroBiasPlusForward24, fragment.Dataset_PPRefSingleMuon1, fragment.Dataset_PPRefSingleMuon2, fragment.Dataset_PPRefSingleMuon3, fragment.Dataset_PPRefHardProbes1, fragment.Dataset_PPRefHardProbes2, fragment.Dataset_PPRefHardProbes3, fragment.Dataset_PPRefHardProbes4, fragment.Dataset_SpecialMinimumBias0, fragment.Dataset_SpecialMinimumBias1, fragment.Dataset_SpecialMinimumBias2, fragment.Dataset_SpecialMinimumBias3, fragment.Dataset_HIPhysicsRawPrime1, fragment.Dataset_HIPhysicsRawPrime2, fragment.Dataset_HIPhysicsRawPrime3, fragment.Dataset_HIPhysicsRawPrime4, fragment.Dataset_HIPhysicsRawPrime5, fragment.Dataset_HIPhysicsRawPrime6, fragment.Dataset_HIPhysicsRawPrime7, fragment.Dataset_HIPhysicsRawPrime8, fragment.Dataset_HIPhysicsRawPrime9, fragment.Dataset_HIPhysicsRawPrime10, fragment.Dataset_HIPhysicsRawPrime11, fragment.Dataset_HIPhysicsRawPrime12, fragment.Dataset_HIPhysicsRawPrime13, fragment.Dataset_HIPhysicsRawPrime14, fragment.Dataset_HIPhysicsRawPrime15, fragment.Dataset_HIPhysicsRawPrime16, fragment.Dataset_HIPhysicsRawPrime17, fragment.Dataset_HIPhysicsRawPrime18, fragment.Dataset_HIPhysicsRawPrime19, fragment.Dataset_HIPhysicsRawPrime20, fragment.Dataset_HIPhysicsRawPrime21, fragment.Dataset_HIPhysicsRawPrime22, fragment.Dataset_HIPhysicsRawPrime23, fragment.Dataset_HIPhysicsRawPrime24, fragment.Dataset_HIPhysicsRawPrime25, fragment.Dataset_HIPhysicsRawPrime26, fragment.Dataset_HIPhysicsRawPrime27, fragment.Dataset_HIPhysicsRawPrime28, fragment.Dataset_HIPhysicsRawPrime29, fragment.Dataset_HIPhysicsRawPrime30, fragment.Dataset_HIPhysicsRawPrime31, fragment.Dataset_HIPhysicsRawPrime32, fragment.Dataset_HIPhysicsRawPrime33, fragment.Dataset_HIPhysicsRawPrime34, fragment.Dataset_HIPhysicsRawPrime35, fragment.Dataset_HIPhysicsRawPrime36, fragment.Dataset_HIPhysicsRawPrime37, fragment.Dataset_HIPhysicsRawPrime38, fragment.Dataset_HIPhysicsRawPrime39, fragment.Dataset_HIPhysicsRawPrime40, fragment.Dataset_HIPhysicsRawPrime41, fragment.Dataset_HIPhysicsRawPrime42, fragment.Dataset_HIPhysicsRawPrime43, fragment.Dataset_HIPhysicsRawPrime44, fragment.Dataset_HIPhysicsRawPrime45, fragment.Dataset_HIPhysicsRawPrime46, fragment.Dataset_HIPhysicsRawPrime47, fragment.Dataset_HIPhysicsRawPrime48, fragment.Dataset_HIPhysicsRawPrime49, fragment.Dataset_HIPhysicsRawPrime50, fragment.Dataset_HIPhysicsRawPrime51, fragment.Dataset_HIPhysicsRawPrime52, fragment.Dataset_HIPhysicsRawPrime53, fragment.Dataset_HIPhysicsRawPrime54, fragment.Dataset_HIPhysicsRawPrime55, fragment.Dataset_HIPhysicsRawPrime56, fragment.Dataset_HIPhysicsRawPrime57, fragment.Dataset_HIPhysicsRawPrime58, fragment.Dataset_HIPhysicsRawPrime59, fragment.Dataset_CosmicHLTMonitor, fragment.Dataset_TestDataRaw, fragment.Dataset_TestDataScouting, fragment.Dataset_EmittanceScan0, fragment.Dataset_EmittanceScan1, fragment.Dataset_EmittanceScan2, fragment.Dataset_EmittanceScan3, fragment.Dataset_EmittanceScan4, fragment.Dataset_EmittanceScan5, fragment.Dataset_IonPhysics, fragment.Dataset_DQMOnlineScouting, fragment.ScoutingPF0Output, fragment.ScoutingPF1Output, )) +fragment.schedule = cms.Schedule( *(fragment.HLTriggerFirstPath, fragment.Status_OnCPU, fragment.Status_OnGPU, fragment.AlCa_EcalPhiSym_v22, fragment.AlCa_EcalPhiSymForHI_v13, fragment.AlCa_EcalEtaEBonly_v27, fragment.AlCa_EcalEtaEEonly_v27, fragment.AlCa_EcalPi0EBonly_v27, fragment.AlCa_EcalPi0EEonly_v27, fragment.AlCa_EcalEtaEBonlyForHI_v14, fragment.AlCa_EcalEtaEEonlyForHI_v14, fragment.AlCa_EcalPi0EBonlyForHI_v14, fragment.AlCa_EcalPi0EEonlyForHI_v14, fragment.AlCa_IsoTrackHBHE_v3, fragment.AlCa_HIEcalEtaEBonly_v13, fragment.AlCa_HIEcalEtaEEonly_v13, fragment.AlCa_HIEcalPi0EBonly_v13, fragment.AlCa_HIEcalPi0EEonly_v13, fragment.AlCa_RPCMuonNormalisation_v25, fragment.AlCa_RPCMuonNormalisationForHI_v13, fragment.AlCa_HIRPCMuonNormalisation_v13, fragment.AlCa_LumiPixelsCounts_Random_v12, fragment.AlCa_LumiPixelsCounts_ZeroBias_v15, fragment.AlCa_PFJet40_v36, fragment.AlCa_PFJet40_CPUOnly_v15, fragment.AlCa_AK8PFJet40_v31, fragment.DQM_PixelReconstruction_v14, fragment.DQM_EcalReconstruction_v13, fragment.DQM_HcalReconstruction_v11, fragment.DQM_HIPixelReconstruction_v14, fragment.DQM_HIEcalReconstruction_v11, fragment.DQM_HIHcalReconstruction_v9, fragment.DQM_Random_v1, fragment.DQM_ZeroBias_v4, fragment.DST_ZeroBias_v12, fragment.DST_Physics_v17, fragment.DST_PFScouting_DoubleMuonNoVtx_v4, fragment.DST_PFScouting_DoubleMuonVtx_v4, fragment.DST_PFScouting_DoubleMuonVtxMonitorJPsi_v4, fragment.DST_PFScouting_DoubleMuonVtxMonitorZ_v4, fragment.DST_PFScouting_DoubleEG_v10, fragment.DST_PFScouting_DoubleEGMonitorJPsi_v1, fragment.DST_PFScouting_DoubleEGMonitorZ_v1, fragment.DST_PFScouting_SinglePhotonEBMonitorJPsi_v1, fragment.DST_PFScouting_SinglePhotonEBMonitorZ_v1, fragment.DST_PFScouting_JetHT_v10, fragment.DST_PFScouting_AXOVLoose_v8, fragment.DST_PFScouting_AXOLoose_v8, fragment.DST_PFScouting_AXOMedium_v4, fragment.DST_PFScouting_AXOTight_v10, fragment.DST_PFScouting_AXOVTight_v8, fragment.HLT_MonitorL1TPureRate_AXO_v1, fragment.DST_PFScouting_CICADAVLoose_v6, fragment.DST_PFScouting_CICADALoose_v6, fragment.DST_PFScouting_CICADAMedium_v6, fragment.DST_PFScouting_CICADATight_v6, fragment.DST_PFScouting_CICADAVTight_v6, fragment.HLT_MonitorL1TPureRate_CICADA_v1, fragment.DST_PFScouting_SingleMuon_v10, fragment.DST_PFScouting_SinglePhotonEB_v7, fragment.DST_PFScouting_ZeroBias_v8, fragment.DST_PFScouting_ZeroBiasVdM_v2, fragment.HLT_TriggersForScoutingPFMonitor_PS125_v1, fragment.HLT_TriggersForScoutingPFMonitor_PS250_v1, fragment.HLT_TriggersForScoutingPFMonitor_PS500_v1, fragment.HLT_TriggersForScoutingPFMonitor_PS1000_v1, fragment.HLT_TriggersForScoutingPFMonitor_SingleMuon_v1, fragment.HLT_EphemeralPhysics_v10, fragment.HLT_EphemeralZeroBias_v10, fragment.HLT_HIEphemeralPhysics_v6, fragment.HLT_HIEphemeralZeroBias_v6, fragment.HLT_EcalCalibration_v4, fragment.HLT_HcalCalibration_v6, fragment.HLT_HcalNZS_v22, fragment.HLT_HcalPhiSym_v24, fragment.HLT_Random_v3, fragment.HLT_Physics_v15, fragment.HLT_ZeroBias_v14, fragment.HLT_ZeroBias_Alignment_v9, fragment.HLT_ZeroBias_Beamspot_v20, fragment.HLT_ZeroBias_IsolatedBunches_v13, fragment.HLT_ZeroBias_FirstBXAfterTrain_v11, fragment.HLT_ZeroBias_FirstCollisionAfterAbortGap_v13, fragment.HLT_ZeroBias_FirstCollisionInTrain_v12, fragment.HLT_ZeroBias_LastCollisionInTrain_v11, fragment.HLT_HT300_Beamspot_v27, fragment.HLT_PFJet40_GPUvsCPU_v8, fragment.HLT_AK8PFJet380_SoftDropMass30_v10, fragment.HLT_AK8PFJet400_SoftDropMass30_v10, fragment.HLT_AK8PFJet425_SoftDropMass30_v10, fragment.HLT_AK8PFJet450_SoftDropMass30_v10, fragment.HLT_AK8DiPFJet250_250_SoftDropMass40_v10, fragment.HLT_AK8DiPFJet250_250_SoftDropMass50_v10, fragment.HLT_AK8DiPFJet260_260_SoftDropMass30_v10, fragment.HLT_AK8DiPFJet260_260_SoftDropMass40_v10, fragment.HLT_AK8DiPFJet270_270_SoftDropMass30_v10, fragment.HLT_AK8DiPFJet280_280_SoftDropMass30_v16, fragment.HLT_AK8DiPFJet290_290_SoftDropMass30_v10, fragment.HLT_CaloJet500_NoJetID_v24, fragment.HLT_CaloJet550_NoJetID_v19, fragment.HLT_DoubleMu5_Upsilon_DoubleEle3_CaloIdL_TrackIdL_v20, fragment.HLT_DoubleMu3_DoubleEle7p5_CaloIdL_TrackIdL_Upsilon_v20, fragment.HLT_Trimuon5_3p5_2_Upsilon_Muon_v21, fragment.HLT_TrimuonOpen_5_3p5_2_Upsilon_Muon_v18, fragment.HLT_DoubleEle25_CaloIdL_MW_v18, fragment.HLT_DoubleEle27_CaloIdL_MW_v18, fragment.HLT_DoubleEle33_CaloIdL_MW_v31, fragment.HLT_DoubleEle24_eta2p1_WPTight_Gsf_v22, fragment.HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_DZ_PFHT350_v36, fragment.HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_PFHT350_v36, fragment.HLT_Mu27_Ele37_CaloIdL_MW_v21, fragment.HLT_Mu37_Ele27_CaloIdL_MW_v21, fragment.HLT_Mu37_TkMu27_v21, fragment.HLT_DoubleMu4_3_Bs_v31, fragment.HLT_DoubleMu4_3_Jpsi_v31, fragment.HLT_DoubleMu4_3_LowMass_v17, fragment.HLT_DoubleMu4_LowMass_Displaced_v17, fragment.HLT_Mu0_L1DoubleMu_v17, fragment.HLT_Mu4_L1DoubleMu_v17, fragment.HLT_DoubleMu2_Jpsi_LowPt_v10, fragment.HLT_DoubleMu4_3_Photon4_BsToMMG_v16, fragment.HLT_DoubleMu4_3_Displaced_Photon4_BsToMMG_v16, fragment.HLT_DoubleMu3_Trk_Tau3mu_v28, fragment.HLT_DoubleMu3_TkMu_DsTau3Mu_v20, fragment.HLT_DoubleMu4_Mass3p8_DZ_PFHT350_v24, fragment.HLT_DoubleMu4_MuMuTrk_Displaced_v31, fragment.HLT_Mu3_PFJet40_v32, fragment.HLT_Mu7p5_L2Mu2_Jpsi_v26, fragment.HLT_Mu7p5_L2Mu2_Upsilon_v26, fragment.HLT_Mu3_L1SingleMu5orSingleMu7_v17, fragment.HLT_Mu0_Barrel_v10, fragment.HLT_Mu0_Barrel_L1HP6_v7, fragment.HLT_Mu0_Barrel_L1HP7_v7, fragment.HLT_Mu0_Barrel_L1HP8_v8, fragment.HLT_Mu0_Barrel_L1HP9_v8, fragment.HLT_Mu0_Barrel_L1HP10_v10, fragment.HLT_Mu0_Barrel_L1HP11_v10, fragment.HLT_Mu0_Barrel_L1HP13_v4, fragment.HLT_Mu0_Barrel_L1HP6_IP6_v7, fragment.HLT_Mu4_Barrel_IP4_v4, fragment.HLT_Mu4_Barrel_IP6_v4, fragment.HLT_Mu6_Barrel_L1HP7_IP6_v7, fragment.HLT_Mu7_Barrel_L1HP8_IP6_v8, fragment.HLT_Mu8_Barrel_L1HP9_IP6_v8, fragment.HLT_Mu9_Barrel_L1HP10_IP6_v10, fragment.HLT_Mu10_Barrel_L1HP11_IP4_v4, fragment.HLT_Mu10_Barrel_L1HP11_IP6_v10, fragment.HLT_Mu12_Barrel_L1HP13_IP4_v4, fragment.HLT_Mu12_Barrel_L1HP13_IP6_v4, fragment.HLT_DoublePhoton33_CaloIdL_v18, fragment.HLT_DoublePhoton70_v18, fragment.HLT_DoublePhoton85_v26, fragment.HLT_DiEle27_WPTightCaloOnly_L1DoubleEG_v16, fragment.HLT_Ele30_WPTight_Gsf_v16, fragment.HLT_Ele32_WPTight_Gsf_v30, fragment.HLT_Ele35_WPTight_Gsf_v24, fragment.HLT_Ele38_WPTight_Gsf_v24, fragment.HLT_Ele40_WPTight_Gsf_v24, fragment.HLT_Ele32_WPTight_Gsf_L1DoubleEG_v24, fragment.HLT_IsoMu20_v31, fragment.HLT_IsoMu24_v29, fragment.HLT_IsoMu24_HLTTracking_v4, fragment.HLT_IsoMu24_eta2p1_v31, fragment.HLT_IsoMu27_v32, fragment.HLT_UncorrectedJetE30_NoBPTX_v16, fragment.HLT_UncorrectedJetE30_NoBPTX3BX_v16, fragment.HLT_UncorrectedJetE60_NoBPTX3BX_v16, fragment.HLT_UncorrectedJetE70_NoBPTX3BX_v16, fragment.HLT_L1SingleMuCosmics_v9, fragment.HLT_L2Mu10_NoVertex_NoBPTX3BX_v15, fragment.HLT_L2Mu10_NoVertex_NoBPTX_v16, fragment.HLT_L2Mu45_NoVertex_3Sta_NoBPTX3BX_v14, fragment.HLT_L2Mu40_NoVertex_3Sta_NoBPTX3BX_v15, fragment.HLT_L2Mu23NoVtx_2Cha_v11, fragment.HLT_L2Mu23NoVtx_2Cha_CosmicSeed_v11, fragment.HLT_DoubleL2Mu30NoVtx_2Cha_CosmicSeed_Eta2p4_v12, fragment.HLT_DoubleL2Mu30NoVtx_2Cha_Eta2p4_v12, fragment.HLT_DoubleL2Mu50_v12, fragment.HLT_DoubleL2Mu23NoVtx_2Cha_CosmicSeed_v12, fragment.HLT_DoubleL2Mu25NoVtx_2Cha_CosmicSeed_v12, fragment.HLT_DoubleL2Mu25NoVtx_2Cha_CosmicSeed_Eta2p4_v12, fragment.HLT_DoubleL2Mu23NoVtx_2Cha_v12, fragment.HLT_DoubleL2Mu25NoVtx_2Cha_v12, fragment.HLT_DoubleL2Mu25NoVtx_2Cha_Eta2p4_v12, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v30, fragment.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_v19, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v31, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_HLTTracking_v4, fragment.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_v19, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_v21, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_PFJet30_v10, fragment.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_Mass8_v19, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass3p8_v21, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass3p8_HLTTracking_v4, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_CaloJet30_v9, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_AK8PFJet30_v9, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_AK8CaloJet30_v9, fragment.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_Mass3p8_v19, fragment.HLT_Mu30_TkMu0_Psi_v17, fragment.HLT_Mu30_TkMu0_Upsilon_v17, fragment.HLT_Mu25_TkMu0_Phi_v24, fragment.HLT_Mu15_v19, fragment.HLT_Mu20_v28, fragment.HLT_Mu27_v29, fragment.HLT_Mu50_v29, fragment.HLT_Mu55_v19, fragment.HLT_CascadeMu100_v16, fragment.HLT_HighPtTkMu100_v16, fragment.HLT_DiPFJetAve40_v30, fragment.HLT_DiPFJetAve60_v30, fragment.HLT_DiPFJetAve80_v30, fragment.HLT_DiPFJetAve140_v29, fragment.HLT_DiPFJetAve200_v29, fragment.HLT_DiPFJetAve260_v30, fragment.HLT_DiPFJetAve320_v30, fragment.HLT_DiPFJetAve400_v30, fragment.HLT_DiPFJetAve500_v30, fragment.HLT_DiPFJetAve60_HFJEC_v31, fragment.HLT_DiPFJetAve80_HFJEC_v33, fragment.HLT_DiPFJetAve100_HFJEC_v33, fragment.HLT_DiPFJetAve160_HFJEC_v32, fragment.HLT_DiPFJetAve220_HFJEC_v32, fragment.HLT_DiPFJetAve260_HFJEC_v15, fragment.HLT_DiPFJetAve300_HFJEC_v32, fragment.HLT_DiPFJetAve180_PPSMatch_Xi0p3_QuadJet_Max2ProtPerRP_v10, fragment.HLT_AK8PFJet40_v32, fragment.HLT_AK8PFJet60_v31, fragment.HLT_AK8PFJet80_v32, fragment.HLT_AK8PFJet140_v31, fragment.HLT_AK8PFJet200_v31, fragment.HLT_AK8PFJet260_v32, fragment.HLT_AK8PFJet320_v32, fragment.HLT_AK8PFJet400_v32, fragment.HLT_AK8PFJet450_v32, fragment.HLT_AK8PFJet500_v32, fragment.HLT_AK8PFJet550_v27, fragment.HLT_PFJet40_v37, fragment.HLT_PFJet60_v37, fragment.HLT_PFJet80_v37, fragment.HLT_PFJet110_v16, fragment.HLT_PFJet140_v35, fragment.HLT_PFJet200_v35, fragment.HLT_PFJet260_v36, fragment.HLT_PFJet320_v36, fragment.HLT_PFJet400_v36, fragment.HLT_PFJet450_v37, fragment.HLT_PFJet500_v37, fragment.HLT_PFJet550_v27, fragment.HLT_PFJetFwd40_v35, fragment.HLT_PFJetFwd60_v35, fragment.HLT_PFJetFwd80_v34, fragment.HLT_PFJetFwd140_v34, fragment.HLT_PFJetFwd200_v34, fragment.HLT_PFJetFwd260_v35, fragment.HLT_PFJetFwd320_v35, fragment.HLT_PFJetFwd400_v35, fragment.HLT_PFJetFwd450_v35, fragment.HLT_PFJetFwd500_v35, fragment.HLT_AK8PFJetFwd40_v31, fragment.HLT_AK8PFJetFwd60_v30, fragment.HLT_AK8PFJetFwd80_v30, fragment.HLT_AK8PFJetFwd140_v30, fragment.HLT_AK8PFJetFwd200_v30, fragment.HLT_AK8PFJetFwd260_v31, fragment.HLT_AK8PFJetFwd320_v31, fragment.HLT_AK8PFJetFwd400_v31, fragment.HLT_AK8PFJetFwd450_v31, fragment.HLT_AK8PFJetFwd500_v31, fragment.HLT_PFHT180_v33, fragment.HLT_PFHT250_v33, fragment.HLT_PFHT370_v33, fragment.HLT_PFHT430_v33, fragment.HLT_PFHT510_v33, fragment.HLT_PFHT590_v33, fragment.HLT_PFHT680_v33, fragment.HLT_PFHT780_v33, fragment.HLT_PFHT890_v33, fragment.HLT_PFHT1050_v34, fragment.HLT_PFHT500_PFMET100_PFMHT100_IDTight_v28, fragment.HLT_PFHT500_PFMET110_PFMHT110_IDTight_v28, fragment.HLT_PFHT700_PFMET85_PFMHT85_IDTight_v28, fragment.HLT_PFHT800_PFMET75_PFMHT75_IDTight_v28, fragment.HLT_PFMET120_PFMHT120_IDTight_v36, fragment.HLT_PFMET130_PFMHT130_IDTight_v36, fragment.HLT_PFMET140_PFMHT140_IDTight_v36, fragment.HLT_PFMET120_PFMHT120_IDTight_PFHT60_v25, fragment.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_PFHT60_v25, fragment.HLT_PFMETTypeOne140_PFMHT140_IDTight_v27, fragment.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_v36, fragment.HLT_PFMETNoMu130_PFMHTNoMu130_IDTight_v35, fragment.HLT_PFMETNoMu140_PFMHTNoMu140_IDTight_v35, fragment.HLT_PFMETNoMu110_PFMHTNoMu110_IDTight_FilterHF_v16, fragment.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_FilterHF_v16, fragment.HLT_PFMETNoMu130_PFMHTNoMu130_IDTight_FilterHF_v16, fragment.HLT_PFMETNoMu140_PFMHTNoMu140_IDTight_FilterHF_v16, fragment.HLT_L1ETMHadSeeds_v11, fragment.HLT_CaloMHT90_v16, fragment.HLT_CaloMET90_NotCleaned_v16, fragment.HLT_CaloMET350_NotCleaned_v16, fragment.HLT_PFMET200_NotCleaned_v25, fragment.HLT_PFMET250_NotCleaned_v25, fragment.HLT_PFMET300_NotCleaned_v25, fragment.HLT_PFMET200_BeamHaloCleaned_v25, fragment.HLT_PFMETTypeOne200_BeamHaloCleaned_v25, fragment.HLT_MET105_IsoTrk50_v23, fragment.HLT_MET120_IsoTrk50_v23, fragment.HLT_Mu12eta2p3_v17, fragment.HLT_Mu12eta2p3_PFJet40_v17, fragment.HLT_Mu12_DoublePFJets40_PNetBTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets100_PNetBTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets200_PNetBTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets350_PNetBTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets40MaxDeta1p6_PNet2BTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets54MaxDeta1p6_PNet2BTag_0p11_v10, fragment.HLT_DoublePFJets40_PNetBTag_0p11_v10, fragment.HLT_DoublePFJets100_PNetBTag_0p11_v10, fragment.HLT_DoublePFJets200_PNetBTag_0p11_v10, fragment.HLT_DoublePFJets350_PNetBTag_0p11_v10, fragment.HLT_DoublePFJets116MaxDeta1p6_PNet2BTag_0p11_v10, fragment.HLT_DoublePFJets128MaxDeta1p6_PNet2BTag_0p11_v10, fragment.HLT_Photon300_NoHE_v24, fragment.HLT_Mu8_TrkIsoVVL_v28, fragment.HLT_Mu8_DiEle12_CaloIdL_TrackIdL_DZ_v34, fragment.HLT_Mu8_DiEle12_CaloIdL_TrackIdL_v34, fragment.HLT_Mu8_Ele8_CaloIdM_TrackIdM_Mass8_PFHT350_DZ_v35, fragment.HLT_Mu8_Ele8_CaloIdM_TrackIdM_Mass8_PFHT350_v35, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_v29, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_v17, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v27, fragment.HLT_Mu17_TrkIsoVVL_v29, fragment.HLT_Mu19_TrkIsoVVL_v20, fragment.HLT_BTagMu_AK4DiJet20_Mu5_v29, fragment.HLT_BTagMu_AK4DiJet40_Mu5_v29, fragment.HLT_BTagMu_AK4DiJet70_Mu5_v29, fragment.HLT_BTagMu_AK4DiJet110_Mu5_v29, fragment.HLT_BTagMu_AK4DiJet170_Mu5_v28, fragment.HLT_BTagMu_AK4Jet300_Mu5_v28, fragment.HLT_BTagMu_AK8DiJet170_Mu5_v25, fragment.HLT_BTagMu_AK8Jet170_DoubleMu5_v18, fragment.HLT_BTagMu_AK8Jet300_Mu5_v28, fragment.HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v33, fragment.HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_v33, fragment.HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v31, fragment.HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v23, fragment.HLT_Mu12_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v23, fragment.HLT_Mu12_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_v31, fragment.HLT_Mu12_IsoVVL_PFHT150_PNetBTag0p53_v9, fragment.HLT_Photon33_v16, fragment.HLT_Photon50_v24, fragment.HLT_Photon75_v24, fragment.HLT_Photon90_v24, fragment.HLT_Photon120_v24, fragment.HLT_Photon150_v18, fragment.HLT_Photon175_v26, fragment.HLT_Photon200_v25, fragment.HLT_Photon45EB_v4, fragment.HLT_Photon40EB_v4, fragment.HLT_Photon50EB_v5, fragment.HLT_Photon30EB_TightID_TightIso_v15, fragment.HLT_Photon40EB_TightID_TightIso_v6, fragment.HLT_Photon45EB_TightID_TightIso_v6, fragment.HLT_Photon50EB_TightID_TightIso_PFJet30_v10, fragment.HLT_Photon50EB_TightID_TightIso_CaloJet30_v6, fragment.HLT_Photon50EB_TightID_TightIso_AK8PFJet30_v9, fragment.HLT_Photon50EB_TightID_TightIso_AK8CaloJet30_v6, fragment.HLT_Photon50EB_TightID_TightIso_v11, fragment.HLT_Photon55EB_TightID_TightIso_v7, fragment.HLT_Photon75EB_TightID_TightIso_v11, fragment.HLT_Photon90EB_TightID_TightIso_v11, fragment.HLT_Photon110EB_TightID_TightIso_v15, fragment.HLT_Photon110EB_TightID_TightIso_PFJet30_v10, fragment.HLT_Photon110EB_TightID_TightIso_CaloJet30_v6, fragment.HLT_Photon110EB_TightID_TightIso_AK8PFJet30_v9, fragment.HLT_Photon110EB_TightID_TightIso_AK8CaloJet30_v6, fragment.HLT_Photon100EBHE10_v13, fragment.HLT_Photon50_R9Id90_HE10_IsoM_v27, fragment.HLT_Photon75_R9Id90_HE10_IsoM_v27, fragment.HLT_Photon90_R9Id90_HE10_IsoM_v27, fragment.HLT_Photon120_R9Id90_HE10_IsoM_v27, fragment.HLT_Photon165_R9Id90_HE10_IsoM_v28, fragment.HLT_Diphoton30_22_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass90_v26, fragment.HLT_Diphoton30_22_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass95_v26, fragment.HLT_Photon35_TwoProngs35_v17, fragment.HLT_IsoMu24_TwoProngs35_v17, fragment.HLT_Dimuon0_Jpsi_L1_NoOS_v23, fragment.HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23, fragment.HLT_Dimuon0_Jpsi_v24, fragment.HLT_Dimuon0_Jpsi_NoVertexing_v24, fragment.HLT_Dimuon0_Jpsi_L1_4R_0er1p5R_v23, fragment.HLT_Dimuon0_Jpsi_NoVertexing_L1_4R_0er1p5R_v23, fragment.HLT_Dimuon0_Jpsi3p5_Muon2_v21, fragment.HLT_Dimuon0_Upsilon_L1_4p5_v25, fragment.HLT_Dimuon0_Upsilon_L1_4p5er2p0_v25, fragment.HLT_Dimuon0_Upsilon_L1_4p5er2p0M_v23, fragment.HLT_Dimuon0_Upsilon_NoVertexing_v23, fragment.HLT_Dimuon0_LowMass_L1_0er1p5_v24, fragment.HLT_Dimuon0_LowMass_v24, fragment.HLT_Dimuon0_LowMass_L1_4_v24, fragment.HLT_Dimuon0_LowMass_Inclusive_v1, fragment.HLT_Dimuon0_LowMass_L1_TM530_v22, fragment.HLT_Dimuon0_Upsilon_Muon_NoL1Mass_v22, fragment.HLT_Dimuon0_Upsilon_v2, fragment.HLT_TripleMu_5_3_3_Mass3p8_DZ_v24, fragment.HLT_TripleMu_10_5_5_DZ_v26, fragment.HLT_TripleMu_12_10_5_v26, fragment.HLT_Tau3Mu_Mu7_Mu1_TkMu1_Tau15_v20, fragment.HLT_Tau3Mu_Mu7_Mu1_TkMu1_Tau15_Charge1_v20, fragment.HLT_Tau3Mu_Mu7_Mu1_TkMu1_IsoTau15_v20, fragment.HLT_Tau3Mu_Mu7_Mu1_TkMu1_IsoTau15_Charge1_v20, fragment.HLT_DoubleMu3_DZ_PFMET50_PFMHT60_v26, fragment.HLT_DoubleMu3_DZ_PFMET70_PFMHT70_v26, fragment.HLT_DoubleMu3_DZ_PFMET90_PFMHT90_v26, fragment.HLT_DoubleMu3_Trk_Tau3mu_NoL1Mass_v22, fragment.HLT_DoubleMu4_3_LowMass_SS_v10, fragment.HLT_DoubleMu4_Jpsi_Displaced_v23, fragment.HLT_DoubleMu4_Jpsi_NoVertexing_v23, fragment.HLT_DoubleMu4_JpsiTrkTrk_Displaced_v23, fragment.HLT_DoubleMu4_JpsiTrk_Bc_v16, fragment.HLT_DoubleMu43NoFiltersNoVtx_v17, fragment.HLT_DoubleMu48NoFiltersNoVtx_v17, fragment.HLT_Mu43NoFiltersNoVtx_Photon43_CaloIdL_v18, fragment.HLT_Mu48NoFiltersNoVtx_Photon48_CaloIdL_v18, fragment.HLT_Mu38NoFiltersNoVtxDisplaced_Photon38_CaloIdL_v14, fragment.HLT_Mu43NoFiltersNoVtxDisplaced_Photon43_CaloIdL_v14, fragment.HLT_Ele28_HighEta_SC20_Mass55_v27, fragment.HLT_Ele15_IsoVVVL_PFHT450_PFMET50_v32, fragment.HLT_Ele15_IsoVVVL_PFHT450_v32, fragment.HLT_Ele50_IsoVVVL_PFHT450_v32, fragment.HLT_Ele15_IsoVVVL_PFHT600_v36, fragment.HLT_Mu15_IsoVVVL_PFHT450_PFMET50_v31, fragment.HLT_Mu15_IsoVVVL_PFHT450_v31, fragment.HLT_Mu50_IsoVVVL_PFHT450_v31, fragment.HLT_Mu15_IsoVVVL_PFHT600_v35, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMET80_PFMHT80_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMET90_PFMHT90_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMET100_PFMHT100_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu80_PFMHTNoMu80_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu90_PFMHTNoMu90_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu100_PFMHTNoMu100_IDTight_v18, fragment.HLT_Dimuon10_Upsilon_y1p4_v17, fragment.HLT_Dimuon12_Upsilon_y1p4_v18, fragment.HLT_Dimuon14_Phi_Barrel_Seagulls_v23, fragment.HLT_Dimuon25_Jpsi_v30, fragment.HLT_Dimuon14_PsiPrime_v29, fragment.HLT_Dimuon14_PsiPrime_noCorrL1_v21, fragment.HLT_Dimuon18_PsiPrime_v30, fragment.HLT_Dimuon18_PsiPrime_noCorrL1_v22, fragment.HLT_Dimuon24_Upsilon_noCorrL1_v22, fragment.HLT_Dimuon24_Phi_noCorrL1_v22, fragment.HLT_Dimuon25_Jpsi_noCorrL1_v22, fragment.HLT_DiMu4_Ele9_CaloIdL_TrackIdL_DZ_Mass3p8_v33, fragment.HLT_DiMu9_Ele9_CaloIdL_TrackIdL_DZ_v33, fragment.HLT_DiMu9_Ele9_CaloIdL_TrackIdL_v33, fragment.HLT_DoubleIsoMu20_eta2p1_v23, fragment.HLT_TrkMu12_DoubleTrkMu5NoFiltersNoVtx_v21, fragment.HLT_Mu8_v28, fragment.HLT_Mu17_v29, fragment.HLT_Mu19_v20, fragment.HLT_Mu17_Photon30_IsoCaloId_v22, fragment.HLT_Ele8_CaloIdL_TrackIdL_IsoVL_PFJet30_v32, fragment.HLT_Ele12_CaloIdL_TrackIdL_IsoVL_PFJet30_v34, fragment.HLT_Ele14_eta2p5_IsoVVVL_Gsf_PFHT200_PNetBTag0p53_v9, fragment.HLT_Ele23_CaloIdL_TrackIdL_IsoVL_PFJet30_v34, fragment.HLT_Ele8_CaloIdM_TrackIdM_PFJet30_v34, fragment.HLT_Ele17_CaloIdM_TrackIdM_PFJet30_v32, fragment.HLT_Ele23_CaloIdM_TrackIdM_PFJet30_v34, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_PFJet165_v34, fragment.HLT_Ele115_CaloIdVT_GsfTrkIdT_v28, fragment.HLT_Ele135_CaloIdVT_GsfTrkIdT_v21, fragment.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_v25, fragment.HLT_PFHT400_SixPFJet32_v25, fragment.HLT_PFHT400_SixPFJet32_PNet2BTagMean0p50_v13, fragment.HLT_PFHT450_SixPFJet36_v24, fragment.HLT_PFHT450_SixPFJet36_PNetBTag0p35_v13, fragment.HLT_PFHT400_FivePFJet_120_120_60_30_30_v10, fragment.HLT_PFHT350_v35, fragment.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT350_v14, fragment.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT380_v14, fragment.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT400_v14, fragment.HLT_ECALHT800_v22, fragment.HLT_DiSC30_18_EIso_AND_HE_Mass70_v25, fragment.HLT_Photon20_HoverELoose_v21, fragment.HLT_Photon30_HoverELoose_v21, fragment.HLT_L1_CDC_SingleMu_3_er1p2_TOP120_DPHI2p618_3p142_v10, fragment.HLT_CDC_L2cosmic_10_er1p0_v11, fragment.HLT_CDC_L2cosmic_5p5_er1p0_v11, fragment.HLT_Photon60_R9Id90_HE10_IsoM_EBOnly_PFJetsMJJ300DEta3_v13, fragment.HLT_Photon75_R9Id90_HE10_IsoM_EBOnly_PFJetsMJJ300DEta3_v21, fragment.HLT_Mu18_Mu9_SameSign_v20, fragment.HLT_DoubleMu2_Jpsi_DoubleTrk1_Phi1p05_v22, fragment.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_v26, fragment.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_Mass2p0_v10, fragment.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_Mass2p0_noDCA_v10, fragment.HLT_TripleMu_5_3_3_Mass3p8_DCA_v19, fragment.HLT_QuadPFJet103_88_75_15_v21, fragment.HLT_QuadPFJet105_88_76_15_v21, fragment.HLT_QuadPFJet111_90_80_15_v21, fragment.HLT_Diphoton30_18_R9IdL_AND_HE_AND_IsoCaloId_v14, fragment.HLT_Diphoton30_18_R9IdL_AND_HE_AND_IsoCaloId_Mass55_v14, fragment.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Tight_eta2p3_CrossL1_v11, fragment.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Medium_eta2p3_CrossL1_v11, fragment.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Loose_eta2p3_CrossL1_v11, fragment.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_PNet3BTag_4p3_v9, fragment.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_PNet3BTag_2p0_v9, fragment.HLT_PFHT400_FivePFJet_120_120_60_30_30_PNet2BTag_5p6_v10, fragment.HLT_PFHT400_FivePFJet_120_120_60_30_30_PNet2BTag_4p3_v10, fragment.HLT_QuadPFJet103_88_75_15_PNetBTag_0p4_VBF2_v10, fragment.HLT_QuadPFJet103_88_75_15_PNet2BTag_0p4_0p12_VBF1_v10, fragment.HLT_QuadPFJet105_88_76_15_PNetBTag_0p4_VBF2_v10, fragment.HLT_QuadPFJet105_88_76_15_PNet2BTag_0p4_0p12_VBF1_v10, fragment.HLT_QuadPFJet111_90_80_15_PNetBTag_0p4_VBF2_v10, fragment.HLT_QuadPFJet111_90_80_15_PNet2BTag_0p4_0p12_VBF1_v10, fragment.HLT_PFHT250_QuadPFJet25_v10, fragment.HLT_PFHT250_QuadPFJet25_PNet2BTagMean0p55_v10, fragment.HLT_PFHT250_QuadPFJet25_PNet1BTag0p20_PNet1Tauh0p50_v10, fragment.HLT_PFHT250_QuadPFJet30_PNet2BTagMean0p55_v10, fragment.HLT_PFHT250_QuadPFJet30_PNet1BTag0p20_PNet1Tauh0p50_v10, fragment.HLT_PFHT280_QuadPFJet30_PNet1BTag0p20_PNet1Tauh0p50_v10, fragment.HLT_PFHT280_QuadPFJet30_v13, fragment.HLT_PFHT280_QuadPFJet30_PNet2BTagMean0p55_v13, fragment.HLT_PFHT280_QuadPFJet30_PNet2BTagMean0p60_v13, fragment.HLT_PFHT280_QuadPFJet35_PNet2BTagMean0p60_v13, fragment.HLT_PFHT340_QuadPFJet70_50_40_40_PNet2BTagMean0p70_v14, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_v13, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_QuadPFJet30_v13, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_QuadPFJet30_PNet2BTagMean0p55_v13, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PNet2BTagMean0p50_v13, fragment.HLT_QuadPFJet100_88_70_30_v14, fragment.HLT_QuadPFJet105_88_75_30_v13, fragment.HLT_QuadPFJet111_90_80_30_v13, fragment.HLT_QuadPFJet100_88_70_30_PNet1CvsAll0p5_VBF3Tight_v14, fragment.HLT_QuadPFJet105_88_75_30_PNet1CvsAll0p5_VBF3Tight_v14, fragment.HLT_QuadPFJet111_90_80_30_PNet1CvsAll0p6_VBF3Tight_v14, fragment.HLT_AK8PFJet220_SoftDropMass40_v17, fragment.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p50_v13, fragment.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p53_v13, fragment.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p55_v13, fragment.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p60_v13, fragment.HLT_AK8PFJet230_SoftDropMass40_v17, fragment.HLT_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_AK8PFJet230_SoftDropMass40_PNetTauTau0p03_v13, fragment.HLT_AK8PFJet230_SoftDropMass40_PNetTauTau0p05_v13, fragment.HLT_AK8PFJet250_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_AK8PFJet250_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_AK8PFJet250_SoftDropMass40_PNetTauTau0p03_v13, fragment.HLT_AK8PFJet250_SoftDropMass40_PNetTauTau0p05_v13, fragment.HLT_AK8PFJet275_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_AK8PFJet275_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_AK8PFJet275_SoftDropMass40_PNetTauTau0p03_v13, fragment.HLT_AK8PFJet275_SoftDropMass40_PNetTauTau0p05_v13, fragment.HLT_AK8PFJet275_Nch45_v10, fragment.HLT_AK8PFJet275_Nch40_v10, fragment.HLT_IsoMu50_AK8PFJet220_SoftDropMass40_v16, fragment.HLT_IsoMu50_AK8PFJet220_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_v16, fragment.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet220_SoftDropMass40_v16, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet220_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_v16, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_DoubleAK4PFJet60_30_v14, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_DoubleAK4PFJet60_30_PNet2BTagMean0p50_v14, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_v10, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_v10, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_PNet2BTagMean0p55_v10, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_PNet1BTag0p20_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Medium_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Tight_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_PFJet60_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_PFJet75_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Tight_eta2p3_CrossL1_ETau_Monitoring_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Medium_eta2p3_CrossL1_ETau_Monitoring_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Loose_eta2p3_CrossL1_ETau_Monitoring_v10, fragment.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Tight_eta2p3_CrossL1_v10, fragment.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Medium_eta2p3_CrossL1_v10, fragment.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Loose_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet20_eta2p2_SingleL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet45_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PFHT250_v10, fragment.HLT_IsoMu24_eta2p1_PFHT250_QuadPFJet25_v10, fragment.HLT_IsoMu24_eta2p1_PFHT250_QuadPFJet25_PNet1Tauh0p50_v10, fragment.HLT_IsoMu24_eta2p1_SinglePFJet25_PNet1Tauh0p50_v10, fragment.HLT_DoublePNetTauhPFJet30_Medium_L2NN_eta2p3_v10, fragment.HLT_DoublePNetTauhPFJet30_Tight_L2NN_eta2p3_v10, fragment.HLT_DoublePNetTauhPFJet26_L2NN_eta2p3_PFJet60_v10, fragment.HLT_DoublePNetTauhPFJet26_L2NN_eta2p3_PFJet75_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Loose_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Medium_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Tight_L2NN_eta2p3_CrossL1_v10, fragment.HLT_SinglePNetTauhPFJet130_Loose_L2NN_eta2p3_v10, fragment.HLT_SinglePNetTauhPFJet130_Medium_L2NN_eta2p3_v10, fragment.HLT_SinglePNetTauhPFJet130_Tight_L2NN_eta2p3_v10, fragment.HLT_DoubleL2Mu10NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v16, fragment.HLT_DoubleL2Mu12NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_DoubleL2Mu14NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_DoubleL3Mu16_10NoVtx_DxyMin0p01cm_v14, fragment.HLT_DoubleL3Mu18_10NoVtx_DxyMin0p01cm_v13, fragment.HLT_DoubleL3Mu20_10NoVtx_DxyMin0p01cm_v13, fragment.HLT_L2Mu10NoVtx_2Cha_v10, fragment.HLT_L2Mu10NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_L3Mu10NoVtx_v13, fragment.HLT_L3Mu10NoVtx_DxyMin0p01cm_v13, fragment.HLT_DoubleL2Mu_L3Mu16NoVtx_VetoL3Mu0DxyMax0p1cm_v13, fragment.HLT_DoubleL2Mu_L3Mu18NoVtx_VetoL3Mu0DxyMax0p1cm_v13, fragment.HLT_DoubleL2Mu10NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_DoubleL2Mu12NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_L2Mu10NoVtx_2Cha_CosmicSeed_v10, fragment.HLT_L2Mu10NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_DoubleL3dTksMu16_10NoVtx_DxyMin0p01cm_v14, fragment.HLT_L2Mu50NoVtx_3Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v8, fragment.HLT_L2Mu50NoVtx_3Cha_VetoL3Mu0DxyMax1cm_v8, fragment.HLT_L3Mu30NoVtx_DxyMin0p01cm_v6, fragment.HLT_L3Mu50NoVtx_DxyMin0p01cm_v6, fragment.HLT_L3dTksMu10_NoVtx_DxyMin0p01cm_v14, fragment.HLT_Mu20NoFiltersNoVtxDisplaced_Photon20_CaloCustomId_v14, fragment.HLT_DisplacedMu24_MediumChargedIsoDisplacedPFTauHPS24_v12, fragment.HLT_Photon34_R9Id90_CaloIdL_IsoL_DisplacedIdL_MediumChargedIsoDisplacedPFTauHPS34_v12, fragment.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS32_Trk1_eta2p1_v17, fragment.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS36_Trk1_eta2p1_v12, fragment.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS32_Trk1_eta2p1_noDxy_v12, fragment.HLT_IsoMu27_MediumChargedIsoDisplacedPFTauHPS24_eta2p1_SingleL1_v12, fragment.HLT_HT350_DelayedJet40_SingleDelay1p5To3p5nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay1p6To3p5nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay1p75To3p5nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay3nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay3p25nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay3p5nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay0p5nsInclusive_v11, fragment.HLT_HT430_DelayedJet40_SingleDelay1nsInclusive_v11, fragment.HLT_HT430_DelayedJet40_SingleDelay1To1p5nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay1p1To1p6nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay1p25To1p75nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay1p5nsInclusive_v11, fragment.HLT_HT430_DelayedJet40_SingleDelay2nsInclusive_v13, fragment.HLT_HT430_DelayedJet40_SingleDelay2p25nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay2p5nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay0p5nsTrackless_v12, fragment.HLT_HT430_DelayedJet40_SingleDelay1nsTrackless_v14, fragment.HLT_HT430_DelayedJet40_SingleDelay1p25nsTrackless_v10, fragment.HLT_HT430_DelayedJet40_SingleDelay1p5nsTrackless_v10, fragment.HLT_HT430_DelayedJet40_DoubleDelay0p5nsInclusive_v12, fragment.HLT_HT430_DelayedJet40_DoubleDelay1nsInclusive_v13, fragment.HLT_HT430_DelayedJet40_DoubleDelay1p25nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_DoubleDelay1p5nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_DoubleDelay0p5nsTrackless_v14, fragment.HLT_HT430_DelayedJet40_DoubleDelay0p75nsTrackless_v10, fragment.HLT_HT430_DelayedJet40_DoubleDelay1nsTrackless_v10, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p5To4nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p6To4nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p75To4nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay3p5nsInclusive_v11, fragment.HLT_L1Tau_DelayedJet40_SingleDelay3p75nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay4nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p5nsTrackless_v12, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p75nsTrackless_v10, fragment.HLT_L1Tau_DelayedJet40_SingleDelay3nsTrackless_v10, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay0p75nsInclusive_v11, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p25nsInclusive_v11, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p5nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p75nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay0p5nsTrackless_v12, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1nsTrackless_v12, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p25nsTrackless_v10, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p5nsTrackless_v10, fragment.HLT_L1Mu6HT240_v10, fragment.HLT_Mu6HT240_DisplacedDijet30_Inclusive1PtrkShortSig5_DisplacedLoose_v14, fragment.HLT_Mu6HT240_DisplacedDijet35_Inclusive0PtrkShortSig5_v14, fragment.HLT_Mu6HT240_DisplacedDijet35_Inclusive1PtrkShortSig5_DisplacedLoose_v14, fragment.HLT_Mu6HT240_DisplacedDijet40_Inclusive0PtrkShortSig5_v14, fragment.HLT_Mu6HT240_DisplacedDijet40_Inclusive1PtrkShortSig5_DisplacedLoose_v14, fragment.HLT_Mu6HT240_DisplacedDijet45_Inclusive0PtrkShortSig5_v14, fragment.HLT_Mu6HT240_DisplacedDijet50_Inclusive0PtrkShortSig5_v14, fragment.HLT_HT350_v9, fragment.HLT_HT425_v21, fragment.HLT_HT360_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT360_DisplacedDijet45_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT390_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT390_DisplacedDijet45_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT390eta2p0_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT430_DisplacedDijet40_Inclusive1PtrkShortSig5_v14, fragment.HLT_HT400_DisplacedDijet40_DisplacedTrack_v26, fragment.HLT_HT430_DisplacedDijet40_DisplacedTrack_v26, fragment.HLT_HT550_DisplacedDijet60_Inclusive_v26, fragment.HLT_HT650_DisplacedDijet60_Inclusive_v26, fragment.HLT_CaloMET60_DTCluster50_v13, fragment.HLT_CaloMET60_DTClusterNoMB1S50_v13, fragment.HLT_L1MET_DTCluster50_v13, fragment.HLT_L1MET_DTClusterNoMB1S50_v13, fragment.HLT_CscCluster_Loose_v11, fragment.HLT_CscCluster_Medium_v11, fragment.HLT_CscCluster_Tight_v11, fragment.HLT_CscCluster50_Photon20Unseeded_v5, fragment.HLT_CscCluster50_Photon30Unseeded_v5, fragment.HLT_CscCluster100_Ele5_v7, fragment.HLT_CscCluster100_Mu5_v10, fragment.HLT_CscCluster100_PNetTauhPFJet10_Loose_v10, fragment.HLT_CscCluster150_DisplacedSingleJet30_Inclusive1PtrkShortSig5_v3, fragment.HLT_CscCluster150_DisplacedSingleJet35_Inclusive1PtrkShortSig5_v3, fragment.HLT_CscCluster150_DisplacedSingleJet40_Inclusive1PtrkShortSig5_v3, fragment.HLT_DoubleCscCluster75_v8, fragment.HLT_IsoTrk200_L1SingleMuShower_v8, fragment.HLT_IsoTrk400_L1SingleMuShower_v8, fragment.HLT_DoubleCscCluster100_v8, fragment.HLT_L1CSCShower_DTCluster50_v11, fragment.HLT_L1CSCShower_DTCluster75_v11, fragment.HLT_PFMET105_IsoTrk50_v17, fragment.HLT_L1SingleLLPJet_v8, fragment.HLT_L1SingleMuShower_v1, fragment.HLT_HT170_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, fragment.HLT_HT200_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, fragment.HLT_HT200_L1SingleLLPJet_DisplacedDijet60_DisplacedTrack_v14, fragment.HLT_HT270_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, fragment.HLT_HT200_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v14, fragment.HLT_HT240_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11, fragment.HLT_HT280_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11, fragment.HLT_HT320_L1SingleLLPJet_DisplacedDijet60_Inclusive_v14, fragment.HLT_HT420_L1SingleLLPJet_DisplacedDijet60_Inclusive_v14, fragment.HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay1nsTrackless_v14, fragment.HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay2nsInclusive_v14, fragment.HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay0p5nsTrackless_v14, fragment.HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay1nsInclusive_v14, fragment.HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p7_v10, fragment.HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p8_v10, fragment.HLT_DiPhoton10Time1ns_v11, fragment.HLT_DiPhoton10Time1p2ns_v11, fragment.HLT_DiPhoton10Time1p4ns_v11, fragment.HLT_DiPhoton10Time1p6ns_v11, fragment.HLT_DiPhoton10Time1p8ns_v11, fragment.HLT_DiPhoton10Time2ns_v11, fragment.HLT_DiPhoton10_CaloIdL_v11, fragment.HLT_DiphotonMVA14p25_Low_Mass60_v1, fragment.HLT_DiphotonMVA14p25_Medium_Mass60_v1, fragment.HLT_DiphotonMVA14p25_High_Mass60_v1, fragment.HLT_DiphotonMVA14p25_TightLow_Mass60_v1, fragment.HLT_DiphotonMVA14p25_TightMedium_Mass60_v1, fragment.HLT_DiphotonMVA14p25_TightHigh_Mass60_v1, fragment.HLT_Diphoton15_10_EBEB_TightID_ECALTrackIsoDr0p2_v3, fragment.HLT_Diphoton15_12_EBEB_TightID_ECALTrackIsoDr0p2_v3, fragment.HLT_Diphoton15_10_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v3, fragment.HLT_Diphoton15_12_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v3, fragment.HLT_Dielectron12_5_EBEB_TightID_ECALTrackIsoDr0p2_v4, fragment.HLT_Dielectron12_5_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v4, fragment.HLT_DoubleEle6p5_eta1p22_mMax6_v13, fragment.HLT_DoubleEle8_eta1p22_mMax6_v13, fragment.HLT_DoubleEle10_eta1p22_mMax6_v13, fragment.HLT_SingleEle8_v12, fragment.HLT_SingleEle8_SingleEGL1_v12, fragment.HLT_Diphoton20_14_eta1p5_R9IdL_AND_HE_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton20_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton22_14_eta1p5_R9IdL_AND_HE_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton22_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton24_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton24_16_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, fragment.HLT_Mu50_L1SingleMuShower_v15, fragment.HLT_IsoMu24_OneProng32_v13, fragment.HLT_Photon32_OneProng32_M50To105_v14, fragment.HLT_VBF_DiPFJet125_45_Mjj1050_v12, fragment.HLT_VBF_DiPFJet125_45_Mjj1150_v4, fragment.HLT_VBF_DiPFJet125_45_Mjj1250_v4, fragment.HLT_VBF_DiPFJet75_45_Mjj800_DiPFJet60_v10, fragment.HLT_VBF_DiPFJet75_45_Mjj900_DiPFJet60_v4, fragment.HLT_VBF_DiPFJet75_45_Mjj1000_DiPFJet60_v4, fragment.HLT_VBF_DiPFJet80_45_Mjj650_PFMETNoMu85_v10, fragment.HLT_VBF_DiPFJet80_45_Mjj750_PFMETNoMu85_v10, fragment.HLT_VBF_DiPFJet80_45_Mjj850_PFMETNoMu85_v4, fragment.HLT_VBF_DiPFJet95_45_Mjj750_Mu3_TrkIsoVVL_v10, fragment.HLT_VBF_DiPFJet95_45_Mjj850_Mu3_TrkIsoVVL_v10, fragment.HLT_VBF_DiPFJet95_45_Mjj950_Mu3_TrkIsoVVL_v4, fragment.HLT_VBF_DiPFJet50_Mjj650_Photon22_v10, fragment.HLT_VBF_DiPFJet50_Mjj750_Photon22_v10, fragment.HLT_VBF_DiPFJet50_Mjj850_Photon22_v4, fragment.HLT_VBF_DiPFJet50_Mjj600_Ele22_eta2p1_WPTight_Gsf_v11, fragment.HLT_VBF_DiPFJet50_Mjj700_Ele22_eta2p1_WPTight_Gsf_v5, fragment.HLT_VBF_DiPFJet50_Mjj800_Ele22_eta2p1_WPTight_Gsf_v5, fragment.HLT_VBF_DiPFJet115_40_Mjj850_DoublePNetTauhPFJet20_eta2p3_v4, fragment.HLT_VBF_DiPFJet115_40_Mjj1000_DoublePNetTauhPFJet20_eta2p3_v4, fragment.HLT_VBF_DiPFJet115_40_Mjj1100_DoublePNetTauhPFJet20_eta2p3_v4, fragment.HLT_VBF_DiPFJet115_40_Mjj1200_DoublePNetTauhPFJet20_eta2p3_v4, fragment.HLT_VBF_DiPFJet45_Mjj650_PNetTauhPFJet45_L2NN_eta2p3_v10, fragment.HLT_VBF_DiPFJet45_Mjj750_PNetTauhPFJet45_L2NN_eta2p3_v10, fragment.HLT_VBF_DiPFJet45_Mjj850_PNetTauhPFJet45_L2NN_eta2p3_v4, fragment.HLT_L1HT200_QuadPFJet20_PNet1BTag0p50_PNet1Tauh0p50_v4, fragment.HLT_L1HT200_QuadPFJet25_PNet1BTag0p50_PNet1Tauh0p50_v4, fragment.HLT_IsoMu24_eta2p1_L1HT200_v4, fragment.HLT_IsoMu24_eta2p1_L1HT200_QuadPFJet25_v4, fragment.HLT_IsoMu24_eta2p1_L1HT200_QuadPFJet25_PNet1Tauh0p50_v4, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_v4, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet20_v4, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet25_v4, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet25_PNet1BTag0p50_v4, fragment.HLT_PFJet200_TimeLtNeg2p5ns_v14, fragment.HLT_PFJet200_TimeGt2p5ns_v14, fragment.HLT_Photon50_TimeLtNeg2p5ns_v8, fragment.HLT_Photon50_TimeGt2p5ns_v8, fragment.HLT_PPSMaxTracksPerArm1_v10, fragment.HLT_PPSMaxTracksPerRP4_v10, fragment.HLT_PPSRandom_v1, fragment.HLT_HIL1NotBptxOR_v15, fragment.HLT_HIL1UnpairedBunchBptxPlus_v15, fragment.HLT_HIL1UnpairedBunchBptxMinus_v15, fragment.HLT_HIPhysics_v15, fragment.HLT_HIPhysicsForZS_v15, fragment.HLT_HIRandom_v8, fragment.HLT_HIRandom_HighRate_v4, fragment.HLT_HIHcalNZS_v15, fragment.HLT_HIHcalPhiSym_v15, fragment.HLT_HIZeroBias_v15, fragment.HLT_HIZeroBias_HighRate_v8, fragment.HLT_HIZeroBias_FirstCollisionAfterAbortGap_v15, fragment.HLT_HIZeroBias_HighRateRAW_v5, fragment.HLT_HIMinimumBiasHF1AND_v8, fragment.HLT_HIMinimumBiasHF1AND_copy_v7, fragment.HLT_HIMinimumBiasHF1ANDZDC1nOR_v5, fragment.HLT_HIMinimumBiasHF1ANDZDC2nOR_v8, fragment.HLT_HIMinimumBiasHF1ANDZDC1nOR_copy_v5, fragment.HLT_HIMinimumBiasHF1ANDZDC2nOR_copy_v7, fragment.HLT_HICentrality30100_FirstCollisionAfterAbortGap_v15, fragment.HLT_HICentrality50100MinimumBiasHF1AND_Beamspot_v2, fragment.HLT_HIL1Centrality30_50_v8, fragment.HLT_HIL1_UCC_0_0p5_v9, fragment.HLT_HIL1_UCC_0_1_v9, fragment.HLT_HIPuAK4CaloJet40Eta5p1_MinBiasHF1AND_v8, fragment.HLT_HIPuAK4CaloJet40Eta5p1_MinBiasHF1AND_ZDC1nOR_v6, fragment.HLT_HIPuAK4CaloJet40Eta5p1_MinBiasHF1AND_ZDC2nOR_v8, fragment.HLT_HIPuAK4CaloJet60Eta5p1_MinBiasHF1AND_v8, fragment.HLT_HIPuAK4CaloJet60Eta5p1_MinBiasHF1AND_ZDC1nOR_v6, fragment.HLT_HIPuAK4CaloJet60Eta5p1_MinBiasHF1AND_ZDC2nOR_v8, fragment.HLT_HIPuAK4CaloJet80Eta5p1_v16, fragment.HLT_HIPuAK4CaloJet100Eta5p1_v16, fragment.HLT_HIPuAK4CaloJet120Eta2p1_v9, fragment.HLT_HIPuAK4CaloJet120Eta5p1_v16, fragment.HLT_HIPuAK4CaloJet40Fwd_v9, fragment.HLT_HIPuAK4CaloJet60Fwd_v9, fragment.HLT_HIPuAK4CaloJet80Fwd_v9, fragment.HLT_HIPuAK4CaloJet100Fwd_v9, fragment.HLT_HIPuAK4CaloJet120Fwd_v9, fragment.HLT_HIGEDPhoton10_v16, fragment.HLT_HIGEDPhoton10_EB_v16, fragment.HLT_HIGEDPhoton20_v16, fragment.HLT_HIGEDPhoton20_EB_v16, fragment.HLT_HIGEDPhoton30_v16, fragment.HLT_HIGEDPhoton30_EB_v16, fragment.HLT_HIGEDPhoton40_v16, fragment.HLT_HIGEDPhoton40_EB_v16, fragment.HLT_HIGEDPhoton50_v16, fragment.HLT_HIGEDPhoton50_EB_v16, fragment.HLT_HIGEDPhoton60_v16, fragment.HLT_HIGEDPhoton60_EB_v16, fragment.HLT_HIDoubleGEDPhoton20_v9, fragment.HLT_HIEle10Gsf_v16, fragment.HLT_HIEle15Gsf_v16, fragment.HLT_HIEle20Gsf_v16, fragment.HLT_HIEle30Gsf_v16, fragment.HLT_HIEle40Gsf_v16, fragment.HLT_HIEle50Gsf_v16, fragment.HLT_HIEle15Ele10Gsf_v16, fragment.HLT_HIEle15Ele10GsfMass50_v16, fragment.HLT_HIDoubleEle10Gsf_v16, fragment.HLT_HIDoubleEle10GsfMass50_v16, fragment.HLT_HIDoubleEle15Gsf_v16, fragment.HLT_HIDoubleEle15GsfMass50_v16, fragment.HLT_HIUPC_ZeroBias_MinPixelCluster400_MaxPixelCluster10000_v15, fragment.HLT_HIUPC_ZeroBias_SinglePixelTrackLowPt_MaxPixelCluster400_v14, fragment.HLT_HIUPC_ZeroBias_SinglePixelTrack_MaxPixelTrack_v15, fragment.HLT_HIUPC_NotMBHF2_v6, fragment.HLT_HIUPC_ZDC1nOR_MinPixelCluster400_MaxPixelCluster10000_v15, fragment.HLT_HIUPC_ZDC1nOR_SinglePixelTrackLowPt_MaxPixelCluster400_v14, fragment.HLT_HIUPC_ZDC1nOR_SinglePixelTrack_MaxPixelTrack_v15, fragment.HLT_HIUPC_ZDC1nXOR_MBHF1AND_PixelTrackMultiplicity20_v15, fragment.HLT_HIUPC_ZDC1nXOR_MBHF1AND_PixelTrackMultiplicity30_v15, fragment.HLT_HIUPC_ZDC1nXOR_MBHF1AND_PixelTrackMultiplicity40_v15, fragment.HLT_HIUPC_ZDC1nXOR_MBHF2AND_PixelTrackMultiplicity20_v15, fragment.HLT_HIUPC_ZDC1nXOR_MBHF2AND_PixelTrackMultiplicity30_v15, fragment.HLT_HIUPC_ZDC1nXOR_MBHF2AND_PixelTrackMultiplicity40_v15, fragment.HLT_HIUPC_ZDC1nAsymXOR_MBHF1AND_PixelTrackMultiplicity20_v7, fragment.HLT_HIUPC_ZDC1nAsymXOR_MBHF1AND_PixelTrackMultiplicity30_v7, fragment.HLT_HIUPC_ZDC1nAsymXOR_MBHF1AND_PixelTrackMultiplicity40_v7, fragment.HLT_HIUPC_ZDC1nAsymXOR_MBHF2AND_PixelTrackMultiplicity20_v7, fragment.HLT_HIUPC_ZDC1nAsymXOR_MBHF2AND_PixelTrackMultiplicity30_v7, fragment.HLT_HIUPC_ZDC1nAsymXOR_MBHF2AND_PixelTrackMultiplicity40_v7, fragment.HLT_HIUPC_SingleMuCosmic_BptxAND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_SingleMuCosmic_NotMBHF2AND_v11, fragment.HLT_HIUPC_SingleMuCosmic_NotMBHF2AND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_SingleMuCosmic_NotMBHF2OR_v11, fragment.HLT_HIUPC_SingleMuCosmic_NotMBHF2OR_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_SingleMuOpen_BptxAND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_SingleMuOpen_NotMBHF2AND_v13, fragment.HLT_HIUPC_SingleMuOpen_NotMBHF2AND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_SingleMuOpen_NotMBHF2OR_v13, fragment.HLT_HIUPC_SingleMuOpen_NotMBHF2OR_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_BptxAND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2AND_v11, fragment.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2AND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2OR_v11, fragment.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2OR_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_DoubleMuCosmic_BptxAND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_DoubleMuCosmic_NotMBHF2AND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_DoubleMuCosmic_NotMBHF2AND_v11, fragment.HLT_HIUPC_DoubleMuOpen_BptxAND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_DoubleMuOpen_NotMBHF2AND_v11, fragment.HLT_HIUPC_DoubleMuOpen_NotMBHF2AND_MaxPixelCluster1000_v8, fragment.HLT_HIUPC_SingleEG2_NotMBHF2AND_ZDC1nOR_SinglePixelTrack_MaxPixelTrack_v14, fragment.HLT_HIUPC_SingleEG3_BptxAND_SinglePixelTrack_MaxPixelTrack_v17, fragment.HLT_HIUPC_SingleEG3_NotMBHF2AND_v13, fragment.HLT_HIUPC_SingleEG3_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v16, fragment.HLT_HIUPC_SingleEG3_NotMBHF2OR_v13, fragment.HLT_HIUPC_SingleEG3_NotMBHF2OR_SinglePixelTrack_MaxPixelTrack_v16, fragment.HLT_HIUPC_SingleEG5_BptxAND_SinglePixelTrack_MaxPixelTrack_v17, fragment.HLT_HIUPC_SingleEG4_NotMBHF2AND_v2, fragment.HLT_HIUPC_SingleEG5_NotMBHF2AND_v13, fragment.HLT_HIUPC_SingleEG5_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v16, fragment.HLT_HIUPC_DoubleEG2_BptxAND_SinglePixelTrack_MaxPixelTrack_v17, fragment.HLT_HIUPC_DoubleEG2_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v16, fragment.HLT_HIUPC_DoubleEG2_NotMBHF2AND_v13, fragment.HLT_HIUPC_DoubleEG3_NotMBHF2AND_v1, fragment.HLT_HIUPC_DoubleEG3_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v2, fragment.HLT_HIUPC_DoubleEG5_BptxAND_SinglePixelTrack_MaxPixelTrack_v17, fragment.HLT_HIUPC_DoubleEG5_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v16, fragment.HLT_HIUPC_DoubleEG5_NotMBHF2AND_v13, fragment.HLT_HIUPC_SingleJet8_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet12_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet16_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet20_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet24_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet28_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet8_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet12_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet16_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet20_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet24_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet28_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet8_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet12_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet16_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet20_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet24_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet28_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_ZeroBias_MaxPixelCluster10000_v4, fragment.HLT_HIUPC_ZDC1nOR_MaxPixelCluster10000_v4, fragment.HLT_HIUPC_ZDC1nOR_MBHF1AND_PixelTrackMultiplicity20400_v4, fragment.HLT_HIUPC_ZDC1nOR_MBHF1AND_PixelTrackMultiplicity30400_v4, fragment.HLT_HIUPC_ZDC1nOR_MBHF1AND_PixelTrackMultiplicity40400_v4, fragment.HLT_HIUPC_ZDC1nAND_NotMBHF2_MaxPixelCluster10000_v4, fragment.HLT_HIUPC_MinPixelThrust0p8_MaxPixelCluster10000_v4, fragment.HLT_HIUPC_SingleUncorrJet8_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet12_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet16_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet20_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet24_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet28_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet8_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet12_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet16_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet20_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet24_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet28_ZDC1nXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet8_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet12_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet16_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet20_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet24_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet28_ZDC1nAsymXOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleUncorrJet8_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleUncorrJet12_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleUncorrJet16_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleUncorrJet8_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleUncorrJet12_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleUncorrJet16_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleUncorrJet8_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleUncorrJet12_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleUncorrJet16_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_ZDC1nOR_RapGap_MaxPixelCluster10000_v4, fragment.HLT_HIUPC_SingleJet8_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet12_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet16_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet20_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet24_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet28_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet8_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet12_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet16_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet20_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet24_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleJet28_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet8_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet12_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet16_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet20_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet24_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_SingleUncorrJet28_NotZDC_OR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleJet8_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleJet12_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleJet16_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleJet8_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleJet12_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleJet16_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleJet8_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleJet12_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_DoubleJet16_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, fragment.HLT_HIUPC_Random_HighRate_v2, fragment.HLT_HIUPC_HFafterglowCombined_v2, fragment.HLT_HIL1SingleMuOpen_Centrality30to100_v2, fragment.HLT_HIL1SingleMu0_Centrality30to100_v2, fragment.HLT_HIL1SingleMu0_Centrality40to100_v2, fragment.HLT_HIL1SingleMu0_v8, fragment.HLT_HIL1SingleMu0_Open_v8, fragment.HLT_HIL1SingleMu0_Cosmic_v8, fragment.HLT_HIL1SingleMu5_SingleEG20Gsf_v9, fragment.HLT_HIL1SingleMu5_SingleGEDPhoton20_v9, fragment.HLT_HIL1SingleMu7_SingleEG20Gsf_v9, fragment.HLT_HIL1SingleMu7_SingleGEDPhoton20_v3, fragment.HLT_HIL2DoubleMuOpen_Centrality40to100_v2, fragment.HLT_HIL2DoubleMuOpen_SS_v2, fragment.HLT_HIL2DoubleMuOpen_OS_v2, fragment.HLT_HIL1DoubleMu0_v8, fragment.HLT_HIL2DoubleMu0_SQ_v2, fragment.HLT_HIL1DoubleMu0_MaxDr3p5_Open_v8, fragment.HLT_HIL1DoubleMu0_SQ_v8, fragment.HLT_HIL2SingleMuOpen_Centrality30to100_v2, fragment.HLT_HIL2SingleMu0_Centrality30to100_v2, fragment.HLT_HIL2SingleMu0_Centrality40to100_v2, fragment.HLT_HIL2SingleMu3_Open_v8, fragment.HLT_HIL2SingleMu5_v8, fragment.HLT_HIL2SingleMu7_v8, fragment.HLT_HIL2SingleMu12_v2, fragment.HLT_HIL2DoubleMu0_Open_v8, fragment.HLT_HIL2DoubleMu0_M1p5to6_Open_v8, fragment.HLT_HIL2DoubleMu0_M7to15_Open_v8, fragment.HLT_HIL2DoubleMu2p8_M1p5to6_Open_v8, fragment.HLT_HIL2DoubleMu3_M7to15_Open_v8, fragment.HLT_HIDmesonPPOnAATrackingGlobal_Dpt30_v10, fragment.HLT_HIDmesonPPOnAATrackingGlobal_Dpt45_v10, fragment.HLT_HIDmesonPPOnAATrackingGlobal_Dpt60_v10, fragment.HLT_HICscCluster_Loose_v8, fragment.HLT_HICscCluster_Medium_v8, fragment.HLT_HICscCluster_Tight_v8, fragment.HLT_HIL1UnpairedBunchBptxMinusForPPRef_v10, fragment.HLT_HIL1UnpairedBunchBptxPlusForPPRef_v10, fragment.HLT_HIL1NotBptxORForPPRef_v10, fragment.HLT_HIHT80_Beamspot_ppRef5TeV_v19, fragment.HLT_PPRefZeroBias_v7, fragment.HLT_AK4CaloJet40_v8, fragment.HLT_AK4CaloJet60_v8, fragment.HLT_AK4CaloJet70_v8, fragment.HLT_AK4CaloJet80_v8, fragment.HLT_AK4CaloJet100_v8, fragment.HLT_AK4CaloJet120_v8, fragment.HLT_AK4CaloJetFwd40_v8, fragment.HLT_AK4CaloJetFwd60_v8, fragment.HLT_AK4CaloJetFwd70_v8, fragment.HLT_AK4CaloJetFwd80_v8, fragment.HLT_AK4CaloJetFwd100_v8, fragment.HLT_AK4CaloJetFwd120_v8, fragment.HLT_AK4PFJet40_v12, fragment.HLT_AK4PFJet60_v12, fragment.HLT_AK4PFJet80_v12, fragment.HLT_AK4PFJet100_v12, fragment.HLT_AK4PFJet120_v12, fragment.HLT_AK4PFJetFwd40_v12, fragment.HLT_AK4PFJetFwd60_v12, fragment.HLT_AK4PFJetFwd80_v12, fragment.HLT_AK4PFJetFwd100_v12, fragment.HLT_AK4PFJetFwd120_v12, fragment.HLT_PPRefDoubleEle10Gsf_v10, fragment.HLT_PPRefDoubleEle10GsfMass50_v10, fragment.HLT_PPRefDoubleEle15Gsf_v10, fragment.HLT_PPRefDoubleEle15GsfMass50_v10, fragment.HLT_PPRefEle15Ele10Gsf_v10, fragment.HLT_PPRefEle15Ele10GsfMass50_v10, fragment.HLT_PPRefEle10Gsf_v10, fragment.HLT_PPRefEle15Gsf_v10, fragment.HLT_PPRefEle20Gsf_v11, fragment.HLT_PPRefEle30Gsf_v11, fragment.HLT_PPRefEle40Gsf_v10, fragment.HLT_PPRefEle50Gsf_v10, fragment.HLT_PPRefGEDPhoton10_v8, fragment.HLT_PPRefGEDPhoton10_EB_v8, fragment.HLT_PPRefGEDPhoton20_v8, fragment.HLT_PPRefGEDPhoton20_EB_v8, fragment.HLT_PPRefGEDPhoton30_v8, fragment.HLT_PPRefGEDPhoton30_EB_v8, fragment.HLT_PPRefGEDPhoton40_v8, fragment.HLT_PPRefGEDPhoton40_EB_v8, fragment.HLT_PPRefGEDPhoton50_v8, fragment.HLT_PPRefGEDPhoton50_EB_v8, fragment.HLT_PPRefGEDPhoton60_v8, fragment.HLT_PPRefGEDPhoton60_EB_v8, fragment.HLT_PPRefDoubleGEDPhoton20_v3, fragment.HLT_PPRefL1DoubleMu0_v7, fragment.HLT_PPRefL1DoubleMu0_SQ_v2, fragment.HLT_PPRefL1DoubleMu0_Open_v7, fragment.HLT_PPRefL1DoubleMu2_v2, fragment.HLT_PPRefL1DoubleMu2_SQ_v2, fragment.HLT_PPRefL1SingleMu0_Cosmics_v7, fragment.HLT_PPRefL1SingleMu7_v7, fragment.HLT_PPRefL1SingleMu12_v7, fragment.HLT_PPRefL1SingleMu5_Ele20Gsf_v5, fragment.HLT_PPRefL1SingleMu5_GEDPhoton20_v3, fragment.HLT_PPRefL1SingleMu7_Ele20Gsf_v5, fragment.HLT_PPRefL1SingleMu7_GEDPhoton10_v3, fragment.HLT_PPRefL2DoubleMu0_v7, fragment.HLT_PPRefL2DoubleMu0_Open_v7, fragment.HLT_PPRefL2SingleMu7_v7, fragment.HLT_PPRefL2SingleMu12_v7, fragment.HLT_PPRefL2SingleMu15_v7, fragment.HLT_PPRefL2SingleMu20_v7, fragment.HLT_PPRefL3DoubleMu0_v12, fragment.HLT_PPRefL3DoubleMu0_Open_v12, fragment.HLT_PPRefL3SingleMu3_v12, fragment.HLT_PPRefL3SingleMu5_v12, fragment.HLT_PPRefL3SingleMu7_v12, fragment.HLT_PPRefL3SingleMu12_v12, fragment.HLT_PPRefL3SingleMu15_v12, fragment.HLT_PPRefL3SingleMu20_v12, fragment.HLT_PPRefL3SingleMu3_SingleAK4CaloJet40_v5, fragment.HLT_PPRefL3SingleMu3_SingleAK4CaloJet60_v5, fragment.HLT_PPRefL3SingleMu3_SingleAK4CaloJet80_v5, fragment.HLT_PPRefL3SingleMu5_SingleAK4CaloJet40_v5, fragment.HLT_PPRefL3SingleMu5_SingleAK4CaloJet60_v5, fragment.HLT_PPRefL3SingleMu5_SingleAK4CaloJet80_v5, fragment.HLT_PPRefCscCluster_Loose_v7, fragment.HLT_PPRefCscCluster_Medium_v7, fragment.HLT_PPRefCscCluster_Tight_v7, fragment.HLT_PPRefUPC_SingleJet8_ZDC1nAsymXOR_v2, fragment.HLT_PPRefUPC_SingleJet12_ZDC1nAsymXOR_v2, fragment.HLT_PPRefUPC_SingleJet16_ZDC1nAsymXOR_v2, fragment.HLT_PPRefUPC_SingleJet20_ZDC1nAsymXOR_v2, fragment.HLT_PPRefUPC_SingleJet24_ZDC1nAsymXOR_v2, fragment.HLT_PPRefUPC_SingleJet28_ZDC1nAsymXOR_v2, fragment.HLT_PPRefUPC_SingleJet8_ZDC1nOR_v2, fragment.HLT_PPRefUPC_SingleJet12_ZDC1nOR_v2, fragment.HLT_PPRefUPC_SingleJet16_ZDC1nOR_v2, fragment.HLT_PPRefUPC_SingleJet20_ZDC1nOR_v2, fragment.HLT_PPRefUPC_SingleJet24_ZDC1nOR_v2, fragment.HLT_PPRefUPC_SingleJet28_ZDC1nOR_v2, fragment.HLT_PPRefUPC_ZDC1nAsymXOR_v2, fragment.HLT_PPRefUPC_ZDC1nOR_v2, fragment.HLT_PPRefZeroBias_FirstCollisionInTrain_v1, fragment.HLT_TestData_v1, fragment.MC_ReducedIterativeTracking_v26, fragment.MC_AK4CaloJets_v21, fragment.MC_AK4CaloJetsFromPV_v21, fragment.MC_CaloHT_v20, fragment.MC_AK8CaloHT_v20, fragment.MC_CaloMHT_v20, fragment.MC_AK4PFJets_v33, fragment.MC_PFHT_v32, fragment.MC_AK8PFJets_v33, fragment.MC_AK8PFHT_v32, fragment.MC_CaloMET_v20, fragment.MC_CaloMET_JetIdCleaned_v21, fragment.MC_PFMET_v33, fragment.MC_PFMHT_v32, fragment.MC_AK4PFJetPNet_v9, fragment.MC_AK8PFJetPNet_v9, fragment.MC_Egamma_Open_v12, fragment.MC_Egamma_Open_Unseeded_v12, fragment.MC_Ele5_WPTight_Gsf_v23, fragment.MC_Ele15_Ele10_CaloIdL_TrackIdL_IsoVL_DZ_v29, fragment.MC_Diphoton10_10_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass10_v26, fragment.MC_DoubleEle5_CaloIdL_MW_v29, fragment.MC_IsoMu_v31, fragment.MC_DoubleMu_TrkIsoVVL_DZ_v27, fragment.MC_DoubleMuNoFiltersNoVtx_v20, fragment.MC_PFScouting_v10, fragment.HLT_SpecialHLTPhysics_v8, fragment.AlCa_LumiPixelsCounts_RandomHighRate_v6, fragment.AlCa_LumiPixelsCounts_ZeroBiasVdM_v6, fragment.AlCa_LumiPixelsCounts_ZeroBiasGated_v7, fragment.HLT_L1AlwaysTrue_v1, fragment.HLT_L1SingleMuOpen_v7, fragment.HLT_L1SingleMuOpen_DT_v7, fragment.HLT_L1SingleMu3_v6, fragment.HLT_L1SingleMu5_v6, fragment.HLT_L1SingleMu7_v6, fragment.HLT_L1DoubleMu0_v6, fragment.HLT_L1SingleJet8erHE_v6, fragment.HLT_L1SingleJet10erHE_v6, fragment.HLT_L1SingleJet12erHE_v6, fragment.HLT_L1SingleJet35_v6, fragment.HLT_L1SingleJet200_v6, fragment.HLT_L1SingleEG8er2p5_v5, fragment.HLT_L1SingleEG10er2p5_v5, fragment.HLT_L1SingleEG15er2p5_v5, fragment.HLT_L1SingleEG26er2p5_v5, fragment.HLT_L1SingleEG28er2p5_v5, fragment.HLT_L1SingleEG28er2p1_v5, fragment.HLT_L1SingleEG28er1p5_v5, fragment.HLT_L1SingleEG34er2p5_v5, fragment.HLT_L1SingleEG36er2p5_v5, fragment.HLT_L1SingleEG38er2p5_v5, fragment.HLT_L1SingleEG40er2p5_v5, fragment.HLT_L1SingleEG42er2p5_v5, fragment.HLT_L1SingleEG45er2p5_v5, fragment.HLT_L1SingleEG50_v5, fragment.HLT_L1SingleJet60_v5, fragment.HLT_L1SingleJet90_v5, fragment.HLT_L1SingleJet120_v5, fragment.HLT_L1SingleJet180_v5, fragment.HLT_L1HTT120er_v5, fragment.HLT_L1HTT160er_v5, fragment.HLT_L1HTT200er_v5, fragment.HLT_L1HTT255er_v5, fragment.HLT_L1HTT280er_v5, fragment.HLT_L1HTT320er_v5, fragment.HLT_L1HTT360er_v5, fragment.HLT_L1HTT400er_v5, fragment.HLT_L1HTT450er_v5, fragment.HLT_L1ETM120_v5, fragment.HLT_L1ETM150_v5, fragment.HLT_L1EXT_HCAL_LaserMon1_v6, fragment.HLT_L1EXT_HCAL_LaserMon4_v6, fragment.HLT_L1MinimumBiasHF0ANDBptxAND_v1, fragment.HLT_L1AXOVVTight_v1, fragment.HLT_L1AXOVVVTight_v1, fragment.HLT_L1CICADA_VVTight_v1, fragment.HLT_L1CICADA_VVVTight_v1, fragment.HLT_L1CICADA_VVVVTight_v1, fragment.HLT_CscCluster_Cosmic_v5, fragment.HLT_HT60_Beamspot_v26, fragment.HLT_Beamspot_PixelClusters_WP2_v10, fragment.HLT_PixelClusters_WP2_v5, fragment.HLT_PixelClusters_WP2_HighRate_v1, fragment.HLT_PixelClusters_WP1_v5, fragment.HLT_BptxOR_v7, fragment.HLT_L1SingleMuCosmics_EMTF_v5, fragment.HLT_L1SingleMuCosmics_CosmicTracking_v2, fragment.HLT_L1SingleMuCosmics_PointingCosmicTracking_v2, fragment.HLT_L1FatEvents_v6, fragment.HLT_Random_HighRate_v1, fragment.HLT_ZeroBias_HighRate_v5, fragment.HLT_ZeroBias_Gated_v6, fragment.HLT_SpecialZeroBias_v7, fragment.HLT_HIHT80_Beamspot_Oxy5TeV_v3, fragment.HLT_MinimumBiasHF_AND_BptxAND_v1, fragment.HLT_MinimumBiasHF_OR_BptxAND_v1, fragment.HLT_MinimumBiasZDC1n_OR_BptxAND_v1, fragment.HLT_MinimumBiasZDC1n_OR_MinimumBiasHF_AND_BptxAND_v1, fragment.HLT_MinimumBiasZDC1n_OR_MinimumBiasHF_OR_BptxAND_v1, fragment.HLT_MinimumBiasZDC1n_OR_OR_MinimumBiasHF_OR_BptxAND_v1, fragment.HLT_MinimumBiasZDC_Asym_MinimumBiasHF_OR_BptxAND_v1, fragment.HLT_OxyDoubleEG2_NotMBHF2AND_v1, fragment.HLT_OxyDoubleEG5_NotMBHF2AND_v1, fragment.HLT_OxyL1CentralityGate_v1, fragment.HLT_OxyL1DoubleMu0_v1, fragment.HLT_OxyL1DoubleMuOpen_v1, fragment.HLT_OxyL1SingleEG10_v1, fragment.HLT_OxyL1SingleEG15_v1, fragment.HLT_OxyL1SingleEG15er2p1_v1, fragment.HLT_OxyL1SingleEG15er2p5_v1, fragment.HLT_OxyL1SingleEG21_v1, fragment.HLT_OxyL1SingleJet20_v1, fragment.HLT_OxyL1SingleJet28_v1, fragment.HLT_OxyL1SingleJet35_v1, fragment.HLT_OxyL1SingleJet44_v1, fragment.HLT_OxyL1SingleJet60_v1, fragment.HLT_OxyL1SingleMu0_v1, fragment.HLT_OxyL1SingleMu3_v1, fragment.HLT_OxyL1SingleMu5_v1, fragment.HLT_OxyL1SingleMu7_v1, fragment.HLT_OxyL1SingleMuOpen_v1, fragment.HLT_OxyNotMBHF2_v1, fragment.HLT_OxySingleEG2_NotMBHF2AND_ZDC1nOR_v1, fragment.HLT_OxySingleEG3_NotMBHF2AND_v1, fragment.HLT_OxySingleEG3_NotMBHF2OR_v1, fragment.HLT_OxySingleEG5_NotMBHF2AND_v1, fragment.HLT_OxySingleJet16_ZDC1nAsymXOR_NotPreBptx_v1, fragment.HLT_OxySingleJet16_ZDC1nAsymXOR_v1, fragment.HLT_OxySingleJet16_ZDC1nXOR_v1, fragment.HLT_OxySingleJet24_ZDC1nAsymXOR_NotPreBptx_v1, fragment.HLT_OxySingleJet24_ZDC1nAsymXOR_v1, fragment.HLT_OxySingleJet24_ZDC1nXOR_v1, fragment.HLT_OxySingleJet8_ZDC1nAsymXOR_NotPreBptx_v1, fragment.HLT_OxySingleJet8_ZDC1nAsymXOR_v1, fragment.HLT_OxySingleJet8_ZDC1nXOR_v1, fragment.HLT_OxySingleMuCosmic_NotMBHF2AND_v1, fragment.HLT_OxySingleMuOpen_NotMBHF2AND_v1, fragment.HLT_OxySingleMuOpen_NotMBHF2OR_v1, fragment.HLT_OxySingleMuOpen_OR_SingleMuCosmic_EMTF_BptxAND_v1, fragment.HLT_OxySingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2AND_v1, fragment.HLT_OxyZDC1nOR_v1, fragment.HLT_OxyZeroBias_v1, fragment.HLT_OxyZeroBias_SinglePixelTrackLowPt_MaxPixelCluster400_v1, fragment.HLT_OxyZeroBias_MinPixelCluster400_v1, fragment.HLTriggerFinalPath, fragment.HLTAnalyzerEndpath, fragment.Dataset_AlCaHcalIsoTrk, fragment.Dataset_AlCaLowPtJet, fragment.Dataset_AlCaLumiPixelsCountsExpress, fragment.Dataset_AlCaLumiPixelsCountsPrompt, fragment.Dataset_AlCaLumiPixelsCountsPromptHighRate0, fragment.Dataset_AlCaLumiPixelsCountsPromptHighRate1, fragment.Dataset_AlCaLumiPixelsCountsPromptHighRate2, fragment.Dataset_AlCaLumiPixelsCountsPromptHighRate3, fragment.Dataset_AlCaLumiPixelsCountsPromptHighRate4, fragment.Dataset_AlCaLumiPixelsCountsPromptHighRate5, fragment.Dataset_AlCaLumiPixelsCountsGated, fragment.Dataset_AlCaP0, fragment.Dataset_AlCaPPSExpress, fragment.Dataset_AlCaPPSPrompt, fragment.Dataset_AlCaPhiSym, fragment.Dataset_BTagMu, fragment.Dataset_Commissioning, fragment.Dataset_Cosmics, fragment.Dataset_DQMGPUvsCPU, fragment.Dataset_DQMOnlineBeamspot, fragment.Dataset_DQMPPSRandom, fragment.Dataset_EGamma0, fragment.Dataset_EGamma1, fragment.Dataset_EGamma2, fragment.Dataset_EGamma3, fragment.Dataset_EcalLaser, fragment.Dataset_EmptyBX, fragment.Dataset_EphemeralHLTPhysics0, fragment.Dataset_EphemeralHLTPhysics1, fragment.Dataset_EphemeralHLTPhysics2, fragment.Dataset_EphemeralHLTPhysics3, fragment.Dataset_EphemeralHLTPhysics4, fragment.Dataset_EphemeralHLTPhysics5, fragment.Dataset_EphemeralHLTPhysics6, fragment.Dataset_EphemeralHLTPhysics7, fragment.Dataset_EphemeralZeroBias0, fragment.Dataset_EphemeralZeroBias1, fragment.Dataset_EphemeralZeroBias2, fragment.Dataset_EphemeralZeroBias3, fragment.Dataset_EphemeralZeroBias4, fragment.Dataset_EphemeralZeroBias5, fragment.Dataset_EphemeralZeroBias6, fragment.Dataset_EphemeralZeroBias7, fragment.Dataset_EventDisplay, fragment.Dataset_ExpressAlignment, fragment.Dataset_ExpressCosmics, fragment.Dataset_ExpressPhysics, fragment.Dataset_HIDQMGPUvsCPU, fragment.Dataset_HIDQMOnlineBeamspot, fragment.Dataset_HIEmptyBX, fragment.Dataset_HIEphemeralHLTPhysics, fragment.Dataset_HIEphemeralZeroBias0, fragment.Dataset_HIEphemeralZeroBias1, fragment.Dataset_HIEventDisplay, fragment.Dataset_HIExpressAlignment, fragment.Dataset_HIExpressPhysics, fragment.Dataset_HIExpressPhysicsRawPrime, fragment.Dataset_HIForward0, fragment.Dataset_HIForward1, fragment.Dataset_HIForward2, fragment.Dataset_HIForward3, fragment.Dataset_HIForward4, fragment.Dataset_HIForward5, fragment.Dataset_HIForward6, fragment.Dataset_HIForward7, fragment.Dataset_HIForward8, fragment.Dataset_HIForward9, fragment.Dataset_HIForward10, fragment.Dataset_HIForward11, fragment.Dataset_HIForward12, fragment.Dataset_HIForward13, fragment.Dataset_HIForward14, fragment.Dataset_HIForward15, fragment.Dataset_HIForward16, fragment.Dataset_HIForward17, fragment.Dataset_HIForward18, fragment.Dataset_HIForward19, fragment.Dataset_HIHLTPhysics, fragment.Dataset_HIHcalNZS, fragment.Dataset_HIOnlineMonitor, fragment.Dataset_HIMinimumBias0, fragment.Dataset_HIMinimumBias1, fragment.Dataset_HIMinimumBias2, fragment.Dataset_HIMinimumBias3, fragment.Dataset_HIPhysicsRawPrime0, fragment.Dataset_HITrackerNZS, fragment.Dataset_HIZeroBias0, fragment.Dataset_HIZeroBias1, fragment.Dataset_HIZeroBias2, fragment.Dataset_HLTMonitor, fragment.Dataset_HLTPhysics, fragment.Dataset_HcalNZS, fragment.Dataset_JetMET0, fragment.Dataset_JetMET1, fragment.Dataset_L1Accept, fragment.Dataset_MinimumBias, fragment.Dataset_MonteCarlo, fragment.Dataset_Muon0, fragment.Dataset_Muon1, fragment.Dataset_MuonEG, fragment.Dataset_MuonShower, fragment.Dataset_NoBPTX, fragment.Dataset_OnlineMonitor, fragment.Dataset_PPRefDoubleMuon0, fragment.Dataset_PPRefDoubleMuon1, fragment.Dataset_PPRefDoubleMuon2, fragment.Dataset_PPRefDoubleMuon3, fragment.Dataset_PPRefHardProbes0, fragment.Dataset_PPRefSingleMuon0, fragment.Dataset_PPRefZeroBiasPlusForward0, fragment.Dataset_ParkingDoubleMuonLowMass0, fragment.Dataset_ParkingDoubleMuonLowMass1, fragment.Dataset_ParkingDoubleMuonLowMass2, fragment.Dataset_ParkingDoubleMuonLowMass3, fragment.Dataset_ParkingDoubleMuonLowMass4, fragment.Dataset_ParkingDoubleMuonLowMass5, fragment.Dataset_ParkingDoubleMuonLowMass6, fragment.Dataset_ParkingDoubleMuonLowMass7, fragment.Dataset_ParkingHH0, fragment.Dataset_ParkingHH1, fragment.Dataset_ParkingLLP0, fragment.Dataset_ParkingLLP1, fragment.Dataset_ParkingSingleMuon0, fragment.Dataset_ParkingSingleMuon1, fragment.Dataset_ParkingSingleMuon2, fragment.Dataset_ParkingSingleMuon3, fragment.Dataset_ParkingSingleMuon4, fragment.Dataset_ParkingSingleMuon5, fragment.Dataset_ParkingSingleMuon6, fragment.Dataset_ParkingSingleMuon7, fragment.Dataset_ParkingSingleMuon8, fragment.Dataset_ParkingSingleMuon9, fragment.Dataset_ParkingSingleMuon10, fragment.Dataset_ParkingSingleMuon11, fragment.Dataset_ParkingSingleMuon12, fragment.Dataset_ParkingSingleMuon13, fragment.Dataset_ParkingSingleMuon14, fragment.Dataset_ParkingSingleMuon15, fragment.Dataset_ParkingVBF0, fragment.Dataset_ParkingVBF1, fragment.Dataset_ParkingVBF2, fragment.Dataset_ParkingVBF3, fragment.Dataset_ParkingVBF4, fragment.Dataset_ParkingVBF5, fragment.Dataset_ParkingVBF6, fragment.Dataset_ParkingVBF7, fragment.Dataset_ParkingAnomalyDetection, fragment.Dataset_RPCMonitor, fragment.Dataset_ScoutingPFMonitor, fragment.Dataset_ScoutingPF0, fragment.Dataset_ScoutingPF1, fragment.Dataset_Tau, fragment.Dataset_TestEnablesEcalHcal, fragment.Dataset_TestEnablesEcalHcalDQM, fragment.Dataset_VRRandom0, fragment.Dataset_VRRandom1, fragment.Dataset_VRRandom2, fragment.Dataset_VRRandom3, fragment.Dataset_VRRandom4, fragment.Dataset_VRRandom5, fragment.Dataset_VRRandom6, fragment.Dataset_VRRandom7, fragment.Dataset_VRRandom8, fragment.Dataset_VRRandom9, fragment.Dataset_VRRandom10, fragment.Dataset_VRRandom11, fragment.Dataset_VRRandom12, fragment.Dataset_VRRandom13, fragment.Dataset_VRRandom14, fragment.Dataset_VRRandom15, fragment.Dataset_ZeroBias, fragment.Dataset_SpecialRandom0, fragment.Dataset_SpecialRandom1, fragment.Dataset_SpecialRandom2, fragment.Dataset_SpecialRandom3, fragment.Dataset_SpecialRandom4, fragment.Dataset_SpecialRandom5, fragment.Dataset_SpecialRandom6, fragment.Dataset_SpecialRandom7, fragment.Dataset_SpecialRandom8, fragment.Dataset_SpecialRandom9, fragment.Dataset_SpecialRandom10, fragment.Dataset_SpecialRandom11, fragment.Dataset_SpecialRandom12, fragment.Dataset_SpecialRandom13, fragment.Dataset_SpecialRandom14, fragment.Dataset_SpecialRandom15, fragment.Dataset_SpecialRandom16, fragment.Dataset_SpecialRandom17, fragment.Dataset_SpecialRandom18, fragment.Dataset_SpecialRandom19, fragment.Dataset_SpecialZeroBias0, fragment.Dataset_SpecialZeroBias1, fragment.Dataset_SpecialZeroBias2, fragment.Dataset_SpecialZeroBias3, fragment.Dataset_SpecialZeroBias4, fragment.Dataset_SpecialZeroBias5, fragment.Dataset_SpecialZeroBias6, fragment.Dataset_SpecialZeroBias7, fragment.Dataset_SpecialZeroBias8, fragment.Dataset_SpecialZeroBias9, fragment.Dataset_SpecialZeroBias10, fragment.Dataset_SpecialZeroBias11, fragment.Dataset_SpecialZeroBias12, fragment.Dataset_SpecialZeroBias13, fragment.Dataset_SpecialZeroBias14, fragment.Dataset_SpecialZeroBias15, fragment.Dataset_SpecialZeroBias16, fragment.Dataset_SpecialZeroBias17, fragment.Dataset_SpecialZeroBias18, fragment.Dataset_SpecialZeroBias19, fragment.Dataset_SpecialZeroBias20, fragment.Dataset_SpecialZeroBias21, fragment.Dataset_SpecialZeroBias22, fragment.Dataset_SpecialZeroBias23, fragment.Dataset_SpecialZeroBias24, fragment.Dataset_SpecialZeroBias25, fragment.Dataset_SpecialZeroBias26, fragment.Dataset_SpecialZeroBias27, fragment.Dataset_SpecialZeroBias28, fragment.Dataset_SpecialZeroBias29, fragment.Dataset_SpecialZeroBias30, fragment.Dataset_SpecialZeroBias31, fragment.Dataset_SpecialHLTPhysics0, fragment.Dataset_SpecialHLTPhysics1, fragment.Dataset_SpecialHLTPhysics2, fragment.Dataset_SpecialHLTPhysics3, fragment.Dataset_SpecialHLTPhysics4, fragment.Dataset_SpecialHLTPhysics5, fragment.Dataset_SpecialHLTPhysics6, fragment.Dataset_SpecialHLTPhysics7, fragment.Dataset_SpecialHLTPhysics8, fragment.Dataset_SpecialHLTPhysics9, fragment.Dataset_SpecialHLTPhysics10, fragment.Dataset_SpecialHLTPhysics11, fragment.Dataset_SpecialHLTPhysics12, fragment.Dataset_SpecialHLTPhysics13, fragment.Dataset_SpecialHLTPhysics14, fragment.Dataset_SpecialHLTPhysics15, fragment.Dataset_SpecialHLTPhysics16, fragment.Dataset_SpecialHLTPhysics17, fragment.Dataset_SpecialHLTPhysics18, fragment.Dataset_SpecialHLTPhysics19, fragment.Dataset_PPRefZeroBiasPlusForward1, fragment.Dataset_PPRefZeroBiasPlusForward2, fragment.Dataset_PPRefZeroBiasPlusForward3, fragment.Dataset_PPRefZeroBiasPlusForward4, fragment.Dataset_PPRefZeroBiasPlusForward5, fragment.Dataset_PPRefZeroBiasPlusForward6, fragment.Dataset_PPRefZeroBiasPlusForward7, fragment.Dataset_PPRefZeroBiasPlusForward8, fragment.Dataset_PPRefZeroBiasPlusForward9, fragment.Dataset_PPRefZeroBiasPlusForward10, fragment.Dataset_PPRefZeroBiasPlusForward11, fragment.Dataset_PPRefZeroBiasPlusForward12, fragment.Dataset_PPRefZeroBiasPlusForward13, fragment.Dataset_PPRefZeroBiasPlusForward14, fragment.Dataset_PPRefZeroBiasPlusForward15, fragment.Dataset_PPRefZeroBiasPlusForward16, fragment.Dataset_PPRefZeroBiasPlusForward17, fragment.Dataset_PPRefZeroBiasPlusForward18, fragment.Dataset_PPRefZeroBiasPlusForward19, fragment.Dataset_PPRefZeroBiasPlusForward20, fragment.Dataset_PPRefZeroBiasPlusForward21, fragment.Dataset_PPRefZeroBiasPlusForward22, fragment.Dataset_PPRefZeroBiasPlusForward23, fragment.Dataset_PPRefZeroBiasPlusForward24, fragment.Dataset_PPRefSingleMuon1, fragment.Dataset_PPRefSingleMuon2, fragment.Dataset_PPRefSingleMuon3, fragment.Dataset_PPRefHardProbes1, fragment.Dataset_PPRefHardProbes2, fragment.Dataset_PPRefHardProbes3, fragment.Dataset_PPRefHardProbes4, fragment.Dataset_SpecialMinimumBias0, fragment.Dataset_SpecialMinimumBias1, fragment.Dataset_SpecialMinimumBias2, fragment.Dataset_SpecialMinimumBias3, fragment.Dataset_HIPhysicsRawPrime1, fragment.Dataset_HIPhysicsRawPrime2, fragment.Dataset_HIPhysicsRawPrime3, fragment.Dataset_HIPhysicsRawPrime4, fragment.Dataset_HIPhysicsRawPrime5, fragment.Dataset_HIPhysicsRawPrime6, fragment.Dataset_HIPhysicsRawPrime7, fragment.Dataset_HIPhysicsRawPrime8, fragment.Dataset_HIPhysicsRawPrime9, fragment.Dataset_HIPhysicsRawPrime10, fragment.Dataset_HIPhysicsRawPrime11, fragment.Dataset_HIPhysicsRawPrime12, fragment.Dataset_HIPhysicsRawPrime13, fragment.Dataset_HIPhysicsRawPrime14, fragment.Dataset_HIPhysicsRawPrime15, fragment.Dataset_HIPhysicsRawPrime16, fragment.Dataset_HIPhysicsRawPrime17, fragment.Dataset_HIPhysicsRawPrime18, fragment.Dataset_HIPhysicsRawPrime19, fragment.Dataset_HIPhysicsRawPrime20, fragment.Dataset_HIPhysicsRawPrime21, fragment.Dataset_HIPhysicsRawPrime22, fragment.Dataset_HIPhysicsRawPrime23, fragment.Dataset_HIPhysicsRawPrime24, fragment.Dataset_HIPhysicsRawPrime25, fragment.Dataset_HIPhysicsRawPrime26, fragment.Dataset_HIPhysicsRawPrime27, fragment.Dataset_HIPhysicsRawPrime28, fragment.Dataset_HIPhysicsRawPrime29, fragment.Dataset_HIPhysicsRawPrime30, fragment.Dataset_HIPhysicsRawPrime31, fragment.Dataset_HIPhysicsRawPrime32, fragment.Dataset_HIPhysicsRawPrime33, fragment.Dataset_HIPhysicsRawPrime34, fragment.Dataset_HIPhysicsRawPrime35, fragment.Dataset_HIPhysicsRawPrime36, fragment.Dataset_HIPhysicsRawPrime37, fragment.Dataset_HIPhysicsRawPrime38, fragment.Dataset_HIPhysicsRawPrime39, fragment.Dataset_HIPhysicsRawPrime40, fragment.Dataset_HIPhysicsRawPrime41, fragment.Dataset_HIPhysicsRawPrime42, fragment.Dataset_HIPhysicsRawPrime43, fragment.Dataset_HIPhysicsRawPrime44, fragment.Dataset_HIPhysicsRawPrime45, fragment.Dataset_HIPhysicsRawPrime46, fragment.Dataset_HIPhysicsRawPrime47, fragment.Dataset_HIPhysicsRawPrime48, fragment.Dataset_HIPhysicsRawPrime49, fragment.Dataset_HIPhysicsRawPrime50, fragment.Dataset_HIPhysicsRawPrime51, fragment.Dataset_HIPhysicsRawPrime52, fragment.Dataset_HIPhysicsRawPrime53, fragment.Dataset_HIPhysicsRawPrime54, fragment.Dataset_HIPhysicsRawPrime55, fragment.Dataset_HIPhysicsRawPrime56, fragment.Dataset_HIPhysicsRawPrime57, fragment.Dataset_HIPhysicsRawPrime58, fragment.Dataset_HIPhysicsRawPrime59, fragment.Dataset_CosmicHLTMonitor, fragment.Dataset_TestDataRaw, fragment.Dataset_TestDataScouting, fragment.Dataset_EmittanceScan0, fragment.Dataset_EmittanceScan1, fragment.Dataset_EmittanceScan2, fragment.Dataset_EmittanceScan3, fragment.Dataset_EmittanceScan4, fragment.Dataset_EmittanceScan5, fragment.Dataset_IonPhysics, fragment.Dataset_DQMOnlineScouting, fragment.ScoutingPF0Output, fragment.ScoutingPF1Output, )) # dummify hltGetConditions in cff's diff --git a/HLTrigger/Configuration/python/HLT_Fake1_cff.py b/HLTrigger/Configuration/python/HLT_Fake1_cff.py index 2b557dbc0d214..e3cae6faa68d8 100644 --- a/HLTrigger/Configuration/python/HLT_Fake1_cff.py +++ b/HLTrigger/Configuration/python/HLT_Fake1_cff.py @@ -1,13 +1,13 @@ -# hltGetConfiguration /dev/CMSSW_15_0_0/Fake1 --cff --data --type Fake1 +# hltGetConfiguration /dev/CMSSW_15_1_0/Fake1 --cff --data --type Fake1 -# /dev/CMSSW_15_0_0/Fake1/V11 (CMSSW_15_0_11) +# /dev/CMSSW_15_1_0/Fake1/V9 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms fragment = cms.ProcessFragment( "HLT" ) fragment.HLTConfigVersion = cms.PSet( - tableName = cms.string("/dev/CMSSW_15_0_0/Fake1/V11") + tableName = cms.string("/dev/CMSSW_15_1_0/Fake1/V9") ) fragment.streams = cms.PSet( A = cms.vstring( 'InitialPD' ) ) diff --git a/HLTrigger/Configuration/python/HLT_Fake2_cff.py b/HLTrigger/Configuration/python/HLT_Fake2_cff.py index 9ee7c0ab53998..bba4ee3932909 100644 --- a/HLTrigger/Configuration/python/HLT_Fake2_cff.py +++ b/HLTrigger/Configuration/python/HLT_Fake2_cff.py @@ -1,13 +1,13 @@ -# hltGetConfiguration /dev/CMSSW_15_0_0/Fake2 --cff --data --type Fake2 +# hltGetConfiguration /dev/CMSSW_15_1_0/Fake2 --cff --data --type Fake2 -# /dev/CMSSW_15_0_0/Fake2/V11 (CMSSW_15_0_11) +# /dev/CMSSW_15_1_0/Fake2/V9 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms fragment = cms.ProcessFragment( "HLT" ) fragment.HLTConfigVersion = cms.PSet( - tableName = cms.string("/dev/CMSSW_15_0_0/Fake2/V11") + tableName = cms.string("/dev/CMSSW_15_1_0/Fake2/V9") ) fragment.streams = cms.PSet( A = cms.vstring( 'InitialPD' ) ) diff --git a/HLTrigger/Configuration/python/HLT_Fake_cff.py b/HLTrigger/Configuration/python/HLT_Fake_cff.py index 87f455c0102aa..79b3de9f9eb70 100644 --- a/HLTrigger/Configuration/python/HLT_Fake_cff.py +++ b/HLTrigger/Configuration/python/HLT_Fake_cff.py @@ -1,13 +1,13 @@ -# hltGetConfiguration /dev/CMSSW_15_0_0/Fake --cff --data --type Fake +# hltGetConfiguration /dev/CMSSW_15_1_0/Fake --cff --data --type Fake -# /dev/CMSSW_15_0_0/Fake/V11 (CMSSW_15_0_11) +# /dev/CMSSW_15_1_0/Fake/V9 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms fragment = cms.ProcessFragment( "HLT" ) fragment.HLTConfigVersion = cms.PSet( - tableName = cms.string("/dev/CMSSW_15_0_0/Fake/V11") + tableName = cms.string("/dev/CMSSW_15_1_0/Fake/V9") ) fragment.streams = cms.PSet( A = cms.vstring( 'InitialPD' ) ) diff --git a/HLTrigger/Configuration/python/HLT_GRun_cff.py b/HLTrigger/Configuration/python/HLT_GRun_cff.py index 665a1af14b75c..a3a0bb5de23c0 100644 --- a/HLTrigger/Configuration/python/HLT_GRun_cff.py +++ b/HLTrigger/Configuration/python/HLT_GRun_cff.py @@ -1,6 +1,6 @@ -# hltGetConfiguration /dev/CMSSW_15_0_0/GRun --cff --data --type GRun +# hltGetConfiguration /dev/CMSSW_15_1_0/GRun --cff --data --type GRun -# /dev/CMSSW_15_0_0/GRun/V114 (CMSSW_15_0_11) +# /dev/CMSSW_15_1_0/GRun/V10 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms @@ -9,7 +9,7 @@ fragment.load("Configuration.StandardSequences.Accelerators_cff") fragment.HLTConfigVersion = cms.PSet( - tableName = cms.string("/dev/CMSSW_15_0_0/GRun/V114") + tableName = cms.string("/dev/CMSSW_15_1_0/GRun/V10") ) fragment.HLTGroupedCkfTrajectoryBuilderP5 = cms.PSet( @@ -2675,6 +2675,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -2815,8 +2816,8 @@ 'HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay2nsInclusive_v14', 'HLT_HT200_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14', 'HLT_HT200_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v14', - 'HLT_HT200_L1SingleLLPJet_DisplacedDijet60_DisplacedTrack_v14', - 'HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p7_v10')+cms.vstring( 'HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p8_v10', + 'HLT_HT200_L1SingleLLPJet_DisplacedDijet60_DisplacedTrack_v14')+cms.vstring( 'HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p7_v10', + 'HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p8_v10', 'HLT_HT240_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11', 'HLT_HT270_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14', 'HLT_HT280_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11', @@ -3069,8 +3070,8 @@ 'HLT_Photon165_R9Id90_HE10_IsoM_v28', 'HLT_Photon175_v26', 'HLT_Photon200_v25', - 'HLT_Photon20_HoverELoose_v21', - 'HLT_Photon300_NoHE_v24')+cms.vstring( 'HLT_Photon30EB_TightID_TightIso_v15', + 'HLT_Photon20_HoverELoose_v21')+cms.vstring( 'HLT_Photon300_NoHE_v24', + 'HLT_Photon30EB_TightID_TightIso_v15', 'HLT_Photon30_HoverELoose_v21', 'HLT_Photon32_OneProng32_M50To105_v14', 'HLT_Photon33_v16', @@ -3142,6 +3143,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -3201,6 +3203,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -3260,6 +3263,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -3319,6 +3323,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -3378,6 +3383,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -3437,6 +3443,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -3496,6 +3503,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -3555,6 +3563,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -4677,7 +4686,9 @@ fragment.CSCObjectMapESProducer = cms.ESProducer( "CSCObjectMapESProducer", appendToDataLabel = cms.string( "" ) ) -fragment.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder" ) +fragment.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder", + appendToDataLabel = cms.string( "" ) +) fragment.CaloTowerConstituentsMapBuilder = cms.ESProducer( "CaloTowerConstituentsMapBuilder", MapFile = cms.untracked.string( "Geometry/CaloTopology/data/CaloTowerEEGeometric.map.gz" ), MapAuto = cms.untracked.bool( False ), @@ -4734,85 +4745,103 @@ appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterial" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMf" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOppositeForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositePropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStepOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) fragment.PropagatorWithMaterialForLoopers = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 4.0 ), ComponentName = cms.string( "PropagatorWithMaterialForLoopers" ), Mass = cms.double( 0.1396 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 4.0 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.PropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStep" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) fragment.SiPixelTemplateStoreESProducer = cms.ESProducer( "SiPixelTemplateStoreESProducer", appendToDataLabel = cms.string( "" ) @@ -4951,7 +4980,9 @@ ), timeThresh = cms.double( 2.0 ) ) -fragment.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP" ) +fragment.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP", + appendToDataLabel = cms.string( "" ) +) fragment.hcalDDDRecConstants = cms.ESProducer( "HcalDDDRecConstantsESModule", appendToDataLabel = cms.string( "" ) ) @@ -5252,13 +5283,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPBwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPBwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPChi2ChargeLooseMeasurementEstimator16 = cms.ESProducer( "Chi2ChargeMeasurementEstimatorESProducer", MaxChi2 = cms.double( 16.0 ), @@ -5634,13 +5667,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPFwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPFwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPGlobalDetLayerGeometry = cms.ESProducer( "GlobalDetLayerGeometryESProducer", ComponentName = cms.string( "hltESPGlobalDetLayerGeometry" ), @@ -6214,13 +6249,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPRungeKuttaTrackerPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPRungeKuttaTrackerPropagator" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( True ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPSiPixelCablingSoA = cms.ESProducer( "SiPixelCablingSoAESProducer@alpaka", CablingMapLabel = cms.string( "" ), @@ -6319,7 +6356,8 @@ mTIB_P0 = cms.double( -0.742 ), mTID_P1 = cms.double( 0.433 ), mTID_P0 = cms.double( -1.427 ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPTTRHBWithTrackAngle = cms.ESProducer( "TkTransientTrackingRecHitBuilderESProducer", ComponentName = cms.string( "hltESPTTRHBWithTrackAngle" ), @@ -6577,7 +6615,9 @@ UseQualityInfo = cms.bool( False ), appendToDataLabel = cms.string( "" ) ) -fragment.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer" ) +fragment.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer", + appendToDataLabel = cms.string( "" ) +) fragment.siStripBackPlaneCorrectionDepESProducer = cms.ESProducer( "SiStripBackPlaneCorrectionDepESProducer", LatencyRecord = cms.PSet( label = cms.untracked.string( "" ), @@ -6590,7 +6630,8 @@ BackPlaneCorrectionDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripBackPlaneCorrectionRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.siStripLorentzAngleDepESProducer = cms.ESProducer( "SiStripLorentzAngleDepESProducer", LatencyRecord = cms.PSet( @@ -6604,7 +6645,8 @@ LorentzAngleDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripLorentzAngleRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.zdcTopologyEP = cms.ESProducer( "ZdcTopologyEP", appendToDataLabel = cms.string( "" ) @@ -6777,9 +6819,9 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -7380,14 +7422,22 @@ fragment.hltSiPixelClustersSoA = cms.EDProducer( "SiPixelRawToClusterPhase1@alpaka", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) @@ -7413,36 +7463,38 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltSiPixelRecHits = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), src = cms.InputTag( "hltSiPixelClusters" ) ) fragment.hltPixelTracksSoA = cms.EDProducer( "CAHitNtupletAlpakaPhase1@alpaka", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -7454,9 +7506,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltPixelTracks = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", @@ -10301,74 +10360,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -11810,9 +11869,9 @@ shouldRunTimingComputation = cms.bool( True ) ) fragment.hltEcalUncalibRecHitSerialSync = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -11924,74 +11983,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbherecoSerialSync" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHitSerialSync:EcalRecHitsEB','hltEcalRecHitSerialSync:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbherecoSerialSync" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHitSerialSync:EcalRecHitsEB','hltEcalRecHitSerialSync:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -12227,14 +12286,22 @@ fragment.hltSiPixelClustersSoASerialSync = cms.EDProducer( "alpaka_serial_sync::SiPixelRawToClusterPhase1", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ) ) fragment.hltSiPixelClustersSerialSync = cms.EDProducer( "SiPixelDigisClustersFromSoAAlpakaPhase1", @@ -12258,6 +12325,7 @@ CPE = cms.string( "PixelCPEFastParams" ) ) fragment.hltSiPixelRecHitsSerialSync = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), src = cms.InputTag( "hltSiPixelClustersSerialSync" ) ) @@ -12526,31 +12594,32 @@ ) fragment.hltPixelTracksSoASerialSync = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -12562,9 +12631,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ) + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) fragment.hltPixelTracksSerialSync = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -19820,7 +19896,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 4096 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( False ) ) fragment.hltL1sHcalNZS = cms.EDFilter( "HLTL1TSeed", @@ -19865,7 +19941,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 107 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( True ) ) fragment.hltPrePhysics = cms.EDFilter( "HLTPrescaler", @@ -33003,74 +33079,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( True ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "" ), + ecalInputs = cms.VInputTag( ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -39888,74 +39964,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltCaloRecHitsBeamHaloCleaned" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEB','hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltCaloRecHitsBeamHaloCleaned" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEB','hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -40452,22 +40528,23 @@ TriggerTypes = cms.vint32( 86 ) ) fragment.hltDeepBLifetimeTagInfosPF = cms.EDProducer( "CandIPProducer", - primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), - computeProbabilities = cms.bool( True ), - computeGhostTrack = cms.bool( True ), - ghostTrackPriorDeltaR = cms.double( 0.03 ), - minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 3 ), maximumTransverseImpactParameter = cms.double( 0.2 ), + minimumNumberOfHits = cms.int32( 3 ), minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), + primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), maximumLongitudinalImpactParameter = cms.double( 17.0 ), - jetDirectionUsingTracks = cms.bool( False ), + computeGhostTrack = cms.bool( True ), + maxDeltaR = cms.double( 0.4 ), + candidates = cms.InputTag( "hltParticleFlow" ), jetDirectionUsingGhostTrack = cms.bool( False ), + minimumNumberOfPixelHits = cms.int32( 2 ), + jetDirectionUsingTracks = cms.bool( False ), + computeProbabilities = cms.bool( True ), useTrackQuality = cms.bool( False ), jets = cms.InputTag( "hltPFJetForBtag" ), - candidates = cms.InputTag( "hltParticleFlow" ), - maxDeltaR = cms.double( 0.4 ) + ghostTrackPriorDeltaR = cms.double( 0.03 ), + maximumChiSquared = cms.double( 5.0 ), + explicitJTA = cms.bool( False ) ) fragment.hltDeepInclusiveVertexFinderPF = cms.EDProducer( "InclusiveCandidateVertexFinder", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -42663,15 +42740,15 @@ etMin = cms.double( 20.0 ) ) fragment.hltBSoftMuonDiJet20L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet20L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -42712,15 +42789,15 @@ invertRapidityCut = cms.bool( False ) ) fragment.hltBSoftMuonDiJet20L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet20L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -42782,15 +42859,15 @@ etMin = cms.double( 40.0 ) ) fragment.hltBSoftMuonDiJet40L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet40L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -42808,15 +42885,15 @@ TriggerType = cms.int32( 86 ) ) fragment.hltBSoftMuonDiJet40L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet40L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -42878,15 +42955,15 @@ etMin = cms.double( 70.0 ) ) fragment.hltBSoftMuonDiJet70L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet70L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -42904,15 +42981,15 @@ TriggerType = cms.int32( 86 ) ) fragment.hltBSoftMuonDiJet70L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet70L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -42974,15 +43051,15 @@ etMin = cms.double( 110.0 ) ) fragment.hltBSoftMuonDiJet110L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet110L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43000,15 +43077,15 @@ TriggerType = cms.int32( 86 ) ) fragment.hltBSoftMuonDiJet110L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet110L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43070,15 +43147,15 @@ etMin = cms.double( 110.0 ) ) fragment.hltBSoftMuonDiJet200L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet200L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43096,15 +43173,15 @@ TriggerType = cms.int32( 86 ) ) fragment.hltBSoftMuonDiJet200L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonDiJet200L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43166,15 +43243,15 @@ etMin = cms.double( 300.0 ) ) fragment.hltBSoftMuonJet300L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonJet300L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43192,15 +43269,15 @@ TriggerType = cms.int32( 86 ) ) fragment.hltBSoftMuonJet300L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonJet300L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43249,15 +43326,15 @@ etMin = cms.double( 110.0 ) ) fragment.hltBSoftMuonAK8DiJet170L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonAK8DiJet170L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43275,15 +43352,15 @@ TriggerType = cms.int32( 85 ) ) fragment.hltBSoftMuonAK8DiJet170L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonAK8DiJet170L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43377,15 +43454,15 @@ etMin = cms.double( 170.0 ) ) fragment.hltBSoftMuonAK8Jet170L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonAK8Jet170L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43453,15 +43530,15 @@ invertRapidityCut = cms.bool( False ) ) fragment.hltBSoftMuonAK8Jet170L1FastJetDoubleMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonDoubleMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonAK8Jet170L1FastJetDoubleMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43510,15 +43587,15 @@ etMin = cms.double( 300.0 ) ) fragment.hltBSoftMuonJet300L1AK8FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonJet300L1AK8FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43536,15 +43613,15 @@ TriggerType = cms.int32( 85 ) ) fragment.hltBSoftMuonJet300L1AK8FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) fragment.hltBSoftMuonJet300L1AK8FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -49899,6 +49976,98 @@ BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), MuonTag = cms.InputTag( "hltIterL3MuonCandidates" ) ) +fragment.hltPreDimuon0LowMassInclusive = cms.EDFilter( "HLTPrescaler", + offset = cms.uint32( 0 ), + L1GtReadoutRecordTag = cms.InputTag( "hltGtStage2Digis" ) +) +fragment.hltL1fL1DoubleMu0SQInclusiveL1Filtered0 = cms.EDFilter( "HLTMuonL1TFilter", + saveTags = cms.bool( True ), + CandTag = cms.InputTag( 'hltGtStage2Digis','Muon' ), + PreviousCandTag = cms.InputTag( "hltL1sDoubleMu0SQOS" ), + MaxEta = cms.double( 2.5 ), + MinPt = cms.double( 0.0 ), + MaxDeltaR = cms.double( 0.3 ), + MinN = cms.int32( 2 ), + CentralBxOnly = cms.bool( True ), + SelectQualities = cms.vint32( ) +) +fragment.hltL2fL1sL1DoubleMu0SQInclusiveL2PreFiltered0 = cms.EDFilter( "HLTMuonL2FromL1TPreFilter", + saveTags = cms.bool( True ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltL1fL1DoubleMu0SQInclusiveL1Filtered0" ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MinN = cms.int32( 0 ), + MaxEta = cms.double( 2.5 ), + AbsEtaBins = cms.vdouble( 0.0 ), + MinNstations = cms.vint32( 0 ), + MinNhits = cms.vint32( 0 ), + CutOnChambers = cms.bool( False ), + MinNchambers = cms.vint32( 0 ), + MaxDr = cms.double( 9999.0 ), + MinDr = cms.double( -1.0 ), + MaxDz = cms.double( 9999.0 ), + MinDxySig = cms.double( -1.0 ), + MinPt = cms.double( 0.0 ), + NSigmaPt = cms.double( 0.0 ), + MatchToPreviousCand = cms.bool( True ) +) +fragment.hltL1fForIterL3L1fL1DoubleMu0SQInclusiveL1Filtered0 = cms.EDFilter( "HLTMuonL1TFilter", + saveTags = cms.bool( True ), + CandTag = cms.InputTag( "hltL1MuonsPt0" ), + PreviousCandTag = cms.InputTag( "hltL1fL1DoubleMu0SQInclusiveL1Filtered0" ), + MaxEta = cms.double( 2.5 ), + MinPt = cms.double( 0.0 ), + MaxDeltaR = cms.double( 0.3 ), + MinN = cms.int32( 1 ), + CentralBxOnly = cms.bool( True ), + SelectQualities = cms.vint32( ) +) +fragment.hltDimuon0LowMassInclusiveL3Filtered = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + CandTag = cms.InputTag( "hltIterL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltL2fL1sL1DoubleMu0SQInclusiveL2PreFiltered0" ), + L1CandTag = cms.InputTag( "hltL1fForIterL3L1fL1DoubleMu0SQInclusiveL1Filtered0" ), + inputMuonCollection = cms.InputTag( "hltIterL3Muons" ), + PreviousCandIsL2 = cms.bool( True ), + FastAccept = cms.bool( False ), + MinN = cms.int32( 1 ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.int32( 0 ), + MaxDr = cms.double( 2.0 ), + MaxDz = cms.double( 9999.0 ), + ChargeOpt = cms.int32( 0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MinPtMax = cms.vdouble( 0.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + MinInvMass = cms.vdouble( 0.2 ), + MaxInvMass = cms.vdouble( 12.0 ), + MinDiMuonDeltaR = cms.double( -1.0 ), + MinAcop = cms.double( -999.0 ), + MaxAcop = cms.double( 999.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxPtBalance = cms.double( 999999.0 ), + NSigmaPt = cms.double( 0.0 ), + MaxDCAMuMu = cms.double( 0.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + InputLinks = cms.InputTag( "hltL3MuonsIterL3Links" ), + L1MatchingdR = cms.double( 0.3 ), + MatchToPreviousCand = cms.bool( True ), + useSimpleGeometry = cms.bool( True ), + useStation2 = cms.bool( True ), + fallbackToME1 = cms.bool( False ), + cosmicPropagationHypothesis = cms.bool( False ), + useMB2InOverlap = cms.bool( False ), + useTrack = cms.string( "tracker" ), + useState = cms.string( "atVertex" ), + propagatorAlong = cms.ESInputTag( "","hltESPSteppingHelixPropagatorAlong" ), + propagatorAny = cms.ESInputTag( "","SteppingHelixPropagatorAny" ), + propagatorOpposite = cms.ESInputTag( "","hltESPSteppingHelixPropagatorOpposite" ) +) fragment.hltL1sTripleMu530NoMass = cms.EDFilter( "HLTL1TSeed", saveTags = cms.bool( True ), L1SeedsLogicalExpression = cms.string( "L1_TripleMu_5SQ_3SQ_0OQ" ), @@ -60056,74 +60225,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( True ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "" ), + hbheInput = cms.InputTag( "" ), + hoInput = cms.InputTag( "" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -66391,22 +66560,23 @@ TriggerTypes = cms.vint32( 86 ) ) fragment.hltDeepBLifetimeTagInfosPFMinPt20 = cms.EDProducer( "CandIPProducer", - primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), - computeProbabilities = cms.bool( True ), - computeGhostTrack = cms.bool( True ), - ghostTrackPriorDeltaR = cms.double( 0.03 ), - minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 3 ), maximumTransverseImpactParameter = cms.double( 0.2 ), + minimumNumberOfHits = cms.int32( 3 ), minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), + primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), maximumLongitudinalImpactParameter = cms.double( 17.0 ), - jetDirectionUsingTracks = cms.bool( False ), + computeGhostTrack = cms.bool( True ), + maxDeltaR = cms.double( 0.4 ), + candidates = cms.InputTag( "hltParticleFlow" ), jetDirectionUsingGhostTrack = cms.bool( False ), + minimumNumberOfPixelHits = cms.int32( 2 ), + jetDirectionUsingTracks = cms.bool( False ), + computeProbabilities = cms.bool( True ), useTrackQuality = cms.bool( False ), jets = cms.InputTag( "hltPFJetForBtagMinPt20" ), - candidates = cms.InputTag( "hltParticleFlow" ), - maxDeltaR = cms.double( 0.4 ) + ghostTrackPriorDeltaR = cms.double( 0.03 ), + maximumChiSquared = cms.double( 5.0 ), + explicitJTA = cms.bool( False ) ) fragment.hltPrimaryVertexAssociationMinPt20 = cms.EDProducer( "PFCandidatePrimaryVertexSorter", sorting = cms.PSet( ), @@ -72950,20 +73120,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerLowPtSingle = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPtSingle" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPtSingle" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLowPtSingle = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -73532,20 +73702,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPtSingle = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPtSingle" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPtSingle" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPtSingle = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -73694,20 +73864,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerLowPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLowPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -73736,20 +73906,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -74104,20 +74274,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerLow30Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow30PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74146,20 +74316,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow30Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow30Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74457,20 +74627,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLow30Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) fragment.hltL4DisplacedDijetFullTracksJetTagProducerLooseFromIPLow30Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1stLoose" ), @@ -74515,20 +74685,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerLow35Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow35PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74557,20 +74727,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow35Pt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow35Pt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74614,20 +74784,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow35Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow35Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74656,20 +74826,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLow35Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) fragment.hltL4DisplacedDijetFullTracksJetTagProducerLooseFromIPLow35Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1stLoose" ), @@ -74717,20 +74887,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74774,20 +74944,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74816,20 +74986,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLowPt1PtrkPt0p5ShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) fragment.hltL4DisplacedDijetFullTracksJetTagProducerLooseFromIPLowPt1PtrkPt0p5ShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1stLoose" ), @@ -74874,20 +75044,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerLow45Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow45Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow45Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow45PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74916,20 +75086,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow45Pt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow45Pt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow45Pt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow45Pt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74974,20 +75144,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerLow50Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow50Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow50Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow50PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75016,20 +75186,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow50Pt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow50Pt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow50Pt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow50Pt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75092,20 +75262,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducer45Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertex45Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertex45Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIP45PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75134,20 +75304,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducer45Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertex45Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertex45Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIP45Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75235,20 +75405,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLowPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) fragment.hltL4DisplacedDijetFullTracksJetTagProducerFromIPLowPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1st" ), @@ -75306,20 +75476,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedDijet100FullTracksTrackIPProducerMidPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedDijetFullTracksJetTagProducerFromIPMidPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -75348,20 +75518,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedDijetFullTracksTrackIPProducerMidPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexMidPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexMidPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPMidPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -75885,22 +76055,23 @@ TriggerTypes = cms.vint32( 86 ) ) fragment.hltDeepBLifetimeTagInfosPFMinPt10 = cms.EDProducer( "CandIPProducer", - primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), - computeProbabilities = cms.bool( True ), - computeGhostTrack = cms.bool( True ), - ghostTrackPriorDeltaR = cms.double( 0.03 ), - minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 3 ), maximumTransverseImpactParameter = cms.double( 0.2 ), + minimumNumberOfHits = cms.int32( 3 ), minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), + primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), maximumLongitudinalImpactParameter = cms.double( 17.0 ), - jetDirectionUsingTracks = cms.bool( False ), + computeGhostTrack = cms.bool( True ), + maxDeltaR = cms.double( 0.4 ), + candidates = cms.InputTag( "hltParticleFlow" ), jetDirectionUsingGhostTrack = cms.bool( False ), + minimumNumberOfPixelHits = cms.int32( 2 ), + jetDirectionUsingTracks = cms.bool( False ), + computeProbabilities = cms.bool( True ), useTrackQuality = cms.bool( False ), jets = cms.InputTag( "hltPFJetForBtagMinPt10" ), - candidates = cms.InputTag( "hltParticleFlow" ), - maxDeltaR = cms.double( 0.4 ) + ghostTrackPriorDeltaR = cms.double( 0.03 ), + maximumChiSquared = cms.double( 5.0 ), + explicitJTA = cms.bool( False ) ) fragment.hltPrimaryVertexAssociationMinPt10 = cms.EDProducer( "PFCandidatePrimaryVertexSorter", sorting = cms.PSet( ), @@ -76061,20 +76232,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedSingleJet100FullTracksTrackIPProducer30Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex30Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex30Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedSingleJetFullTracksJetTagProducerFromIP30PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76103,20 +76274,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedSingleJetFullTracksTrackIPProducer30Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex30Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex30Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedSingleJetFullTracksJetTagProducerFromIP30Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76185,20 +76356,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedSingleJet100FullTracksTrackIPProducer35Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex35Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex35Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedSingleJetFullTracksJetTagProducerFromIP35PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76227,20 +76398,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedSingleJetFullTracksTrackIPProducer35Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex35Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex35Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedSingleJetFullTracksJetTagProducerFromIP35Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76273,20 +76444,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL3DisplacedSingleJet100FullTracksTrackIPProducer40Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex40Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex40Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL3DisplacedSingleJetFullTracksJetTagProducerFromIP40PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76315,20 +76486,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4PromptDisplacedSingleJetFullTracksTrackIPProducer40Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex40Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex40Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) fragment.hltL4PromptDisplacedSingleJetFullTracksJetTagProducerFromIP40Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76611,20 +76782,20 @@ pvSrc = cms.InputTag( "" ) ) fragment.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerMidPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) fragment.hltL4DisplacedDijetFullTracksJetTagProducerFromIPMidPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1st" ), @@ -87230,6 +87401,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -87370,8 +87542,8 @@ 'HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay2nsInclusive_v14', 'HLT_HT200_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14', 'HLT_HT200_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v14', - 'HLT_HT200_L1SingleLLPJet_DisplacedDijet60_DisplacedTrack_v14', - 'HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p7_v10')+cms.vstring( 'HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p8_v10', + 'HLT_HT200_L1SingleLLPJet_DisplacedDijet60_DisplacedTrack_v14')+cms.vstring( 'HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p7_v10', + 'HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p8_v10', 'HLT_HT240_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11', 'HLT_HT270_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14', 'HLT_HT280_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11', @@ -87624,8 +87796,8 @@ 'HLT_Photon165_R9Id90_HE10_IsoM_v28', 'HLT_Photon175_v26', 'HLT_Photon200_v25', - 'HLT_Photon20_HoverELoose_v21', - 'HLT_Photon300_NoHE_v24')+cms.vstring( 'HLT_Photon30EB_TightID_TightIso_v15', + 'HLT_Photon20_HoverELoose_v21')+cms.vstring( 'HLT_Photon300_NoHE_v24', + 'HLT_Photon30EB_TightID_TightIso_v15', 'HLT_Photon30_HoverELoose_v21', 'HLT_Photon32_OneProng32_M50To105_v14', 'HLT_Photon33_v16', @@ -87703,6 +87875,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -89174,6 +89347,7 @@ fragment.HLT_Dimuon0_LowMass_L1_0er1p5_v24 = cms.Path( fragment.HLTBeginSequence + fragment.hltL1sDoubleMu0er1p5 + fragment.hltPreDimuon0LowMassL10er1p5 + fragment.hltL1sEmuDoubleMu0er1p5 + fragment.hltL1fL1sL1DoubleMu0er1p5L1Filtered0 + fragment.HLTL2muonrecoSequence + cms.ignore(fragment.hltL2fL1sL1DoubleMu0er1p5L1f0L2PreFiltered0) + fragment.HLTL3muonrecoSequence + cms.ignore(fragment.hltL1fForIterL3L1fL1sL1DoubleMu0er1p5L1Filtered0) + fragment.hltDimuon0LowMassL1s0er1p5L3Filtered + fragment.hltDisplacedmumuVtxProducerDimuon0LowMassL1s0er1p5 + fragment.hltDisplacedmumuFilterDimuon0LowMassL1s0er1p5 + fragment.HLTEndSequence ) fragment.HLT_Dimuon0_LowMass_v24 = cms.Path( fragment.HLTBeginSequence + fragment.hltL1sDoubleMu0SQOS + fragment.hltPreDimuon0LowMass + fragment.hltL1sEmuDoubleMu0SQOS + fragment.hltL1fL1DoubleMu0SQOSL1Filtered0 + fragment.HLTL2muonrecoSequence + cms.ignore(fragment.hltL2fL1sL1DoubleMu0SQOSL2PreFiltered0) + fragment.HLTL3muonrecoSequence + cms.ignore(fragment.hltL1fForIterL3L1fL1DoubleMu0SQOSL1Filtered0) + fragment.hltDimuon0LowMassL3Filtered + fragment.hltDisplacedmumuVtxProducerDimuon0LowMass + fragment.hltDisplacedmumuFilterDimuon0LowMass + fragment.HLTEndSequence ) fragment.HLT_Dimuon0_LowMass_L1_4_v24 = cms.Path( fragment.HLTBeginSequence + fragment.hltL1sDoubleMu4SQOS + fragment.hltPreDimuon0LowMassL14 + fragment.hltL1sEmuDoubleMu4SQOS + fragment.hltL1fL1sL1DoubleMu4SQOSL1Filtered0 + fragment.HLTL2muonrecoSequence + cms.ignore(fragment.hltL2fL1sL1DoubleMu4SQOSL1f0L2PreFiltered0) + fragment.HLTL3muonrecoSequence + cms.ignore(fragment.hltL1fForIterL3L1fL1sL1DoubleMu4SQOSL1Filtered0) + fragment.hltDimuon0LowMassL1s4L3Filtered + fragment.hltDisplacedmumuVtxProducerDimuon0LowMassL1s4 + fragment.hltDisplacedmumuFilterDimuon0LowMassL1s4 + fragment.HLTEndSequence ) +fragment.HLT_Dimuon0_LowMass_Inclusive_v1 = cms.Path( fragment.HLTBeginSequence + fragment.hltL1sDoubleMu0SQOS + fragment.hltPreDimuon0LowMassInclusive + fragment.hltL1fL1DoubleMu0SQInclusiveL1Filtered0 + fragment.HLTL2muonrecoSequence + cms.ignore(fragment.hltL2fL1sL1DoubleMu0SQInclusiveL2PreFiltered0) + fragment.HLTL3muonrecoSequence + cms.ignore(fragment.hltL1fForIterL3L1fL1DoubleMu0SQInclusiveL1Filtered0) + fragment.hltDimuon0LowMassInclusiveL3Filtered + fragment.HLTEndSequence ) fragment.HLT_Dimuon0_LowMass_L1_TM530_v22 = cms.Path( fragment.HLTBeginSequence + fragment.hltL1sTripleMu530NoMass + fragment.hltPreDimuon0LowMassL1TM530 + fragment.hltL1fL1sL1TripleMuNoMassL1Filtered0 + fragment.HLTL2muonrecoSequence + cms.ignore(fragment.hltL2fL1sL1TripleMuNoMassL1f0L2PreFiltered0) + fragment.HLTL3muonrecoSequence + cms.ignore(fragment.hltL1fForIterL3L1fL1sL1TripleMuNoMassL1Filtered0) + fragment.hltDimuon0LowMassL1sTM530L3Filtered + fragment.hltDisplacedmumuVtxProducerDimuon0LowMassL1sTM530 + fragment.hltDisplacedmumuFilterDimuon0LowMassL1sTM530 + fragment.HLTEndSequence ) fragment.HLT_Dimuon0_Upsilon_Muon_NoL1Mass_v22 = cms.Path( fragment.HLTBeginSequence + fragment.hltL1sTripleMu53p52p5 + fragment.hltPreDimuon0UpsilonMuonNoL1Mass + fragment.hltTripleMuon53p52p5L1Filtered0 + fragment.HLTL2muonrecoSequence + cms.ignore(fragment.hltTripleMuon53p52p5L2PreFiltered0) + fragment.HLTL3muonrecoSequence + cms.ignore(fragment.hltL1fForIterL3TripleMuon53p52p5L1Filtered0) + fragment.hltTripleMu0NoL1MassL3PreFiltered0 + fragment.hltUpsilon0MuonL3FilteredNoL1Mass + fragment.hltDisplacedmumuVtxProducerUpsilon0MuonNoL1Mass + fragment.hltVertexmumuFilterUpsilon0MuonNoL1Mass + fragment.HLTEndSequence ) fragment.HLT_Dimuon0_Upsilon_v2 = cms.Path( fragment.HLTBeginSequence + fragment.hltL1s12ForUpsilonDimuon0Mass8to12 + fragment.hltPreDimuon0Upsilon + fragment.hltL1fL1sL1s12DoubleMu0er2p0SQOSMass8to12L1v2Filtered0 + fragment.HLTL2muonrecoSequence + cms.ignore(fragment.hltL2fL1sL1s12DoubleMu0er2p0SQOSMass8to12L1f0L2v2PreFiltered0) + fragment.HLTL3muonrecoSequence + cms.ignore(fragment.hltL1fForIterL3L1fL1sL1s12DoubleMu0er2p0SQOSMass8to12L1v2Filtered0) + fragment.hltDimuon0UpsilonyL3fL3Filtered + fragment.hltDisplacedmumuVtxProducerDimuon0Upsilonsv3 + fragment.hltDisplacedmumuFilterDimuon0Upsilonsv3 + fragment.HLTEndSequence ) @@ -89719,7 +89893,7 @@ fragment.ScoutingPF1Output = cms.Path( ) -fragment.schedule = cms.Schedule( *(fragment.HLTriggerFirstPath, fragment.Status_OnCPU, fragment.Status_OnGPU, fragment.AlCa_EcalPhiSym_v22, fragment.AlCa_EcalEtaEBonly_v27, fragment.AlCa_EcalEtaEEonly_v27, fragment.AlCa_EcalPi0EBonly_v27, fragment.AlCa_EcalPi0EEonly_v27, fragment.AlCa_IsoTrackHBHE_v3, fragment.AlCa_RPCMuonNormalisation_v25, fragment.AlCa_LumiPixelsCounts_Random_v12, fragment.AlCa_LumiPixelsCounts_ZeroBias_v15, fragment.AlCa_PFJet40_v36, fragment.AlCa_PFJet40_CPUOnly_v15, fragment.AlCa_AK8PFJet40_v31, fragment.DQM_PixelReconstruction_v14, fragment.DQM_EcalReconstruction_v13, fragment.DQM_HcalReconstruction_v11, fragment.DST_ZeroBias_v12, fragment.DST_Physics_v17, fragment.DST_PFScouting_DoubleMuonNoVtx_v4, fragment.DST_PFScouting_DoubleMuonVtx_v4, fragment.DST_PFScouting_DoubleMuonVtxMonitorJPsi_v4, fragment.DST_PFScouting_DoubleMuonVtxMonitorZ_v4, fragment.DST_PFScouting_DoubleEG_v10, fragment.DST_PFScouting_DoubleEGMonitorJPsi_v1, fragment.DST_PFScouting_DoubleEGMonitorZ_v1, fragment.DST_PFScouting_SinglePhotonEBMonitorJPsi_v1, fragment.DST_PFScouting_SinglePhotonEBMonitorZ_v1, fragment.DST_PFScouting_JetHT_v10, fragment.DST_PFScouting_AXOVLoose_v8, fragment.DST_PFScouting_AXOLoose_v8, fragment.DST_PFScouting_AXOMedium_v4, fragment.DST_PFScouting_AXOTight_v10, fragment.DST_PFScouting_AXOVTight_v8, fragment.HLT_MonitorL1TPureRate_AXO_v1, fragment.DST_PFScouting_CICADAVLoose_v6, fragment.DST_PFScouting_CICADALoose_v6, fragment.DST_PFScouting_CICADAMedium_v6, fragment.DST_PFScouting_CICADATight_v6, fragment.DST_PFScouting_CICADAVTight_v6, fragment.HLT_MonitorL1TPureRate_CICADA_v1, fragment.DST_PFScouting_SingleMuon_v10, fragment.DST_PFScouting_SinglePhotonEB_v7, fragment.DST_PFScouting_ZeroBias_v8, fragment.HLT_TriggersForScoutingPFMonitor_PS125_v1, fragment.HLT_TriggersForScoutingPFMonitor_PS250_v1, fragment.HLT_TriggersForScoutingPFMonitor_PS500_v1, fragment.HLT_TriggersForScoutingPFMonitor_PS1000_v1, fragment.HLT_EphemeralPhysics_v10, fragment.HLT_EphemeralZeroBias_v10, fragment.HLT_EcalCalibration_v4, fragment.HLT_HcalCalibration_v6, fragment.HLT_HcalNZS_v22, fragment.HLT_HcalPhiSym_v24, fragment.HLT_Random_v3, fragment.HLT_Physics_v15, fragment.HLT_ZeroBias_v14, fragment.HLT_ZeroBias_Alignment_v9, fragment.HLT_ZeroBias_Beamspot_v20, fragment.HLT_ZeroBias_IsolatedBunches_v13, fragment.HLT_ZeroBias_FirstBXAfterTrain_v11, fragment.HLT_ZeroBias_FirstCollisionAfterAbortGap_v13, fragment.HLT_ZeroBias_FirstCollisionInTrain_v12, fragment.HLT_ZeroBias_LastCollisionInTrain_v11, fragment.HLT_HT300_Beamspot_v27, fragment.HLT_PFJet40_GPUvsCPU_v8, fragment.HLT_AK8PFJet380_SoftDropMass30_v10, fragment.HLT_AK8PFJet400_SoftDropMass30_v10, fragment.HLT_AK8PFJet425_SoftDropMass30_v10, fragment.HLT_AK8PFJet450_SoftDropMass30_v10, fragment.HLT_AK8DiPFJet250_250_SoftDropMass40_v10, fragment.HLT_AK8DiPFJet250_250_SoftDropMass50_v10, fragment.HLT_AK8DiPFJet260_260_SoftDropMass30_v10, fragment.HLT_AK8DiPFJet260_260_SoftDropMass40_v10, fragment.HLT_AK8DiPFJet270_270_SoftDropMass30_v10, fragment.HLT_AK8DiPFJet280_280_SoftDropMass30_v16, fragment.HLT_AK8DiPFJet290_290_SoftDropMass30_v10, fragment.HLT_CaloJet500_NoJetID_v24, fragment.HLT_CaloJet550_NoJetID_v19, fragment.HLT_DoubleMu5_Upsilon_DoubleEle3_CaloIdL_TrackIdL_v20, fragment.HLT_DoubleMu3_DoubleEle7p5_CaloIdL_TrackIdL_Upsilon_v20, fragment.HLT_Trimuon5_3p5_2_Upsilon_Muon_v21, fragment.HLT_TrimuonOpen_5_3p5_2_Upsilon_Muon_v18, fragment.HLT_DoubleEle25_CaloIdL_MW_v18, fragment.HLT_DoubleEle27_CaloIdL_MW_v18, fragment.HLT_DoubleEle33_CaloIdL_MW_v31, fragment.HLT_DoubleEle24_eta2p1_WPTight_Gsf_v22, fragment.HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_DZ_PFHT350_v36, fragment.HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_PFHT350_v36, fragment.HLT_Mu27_Ele37_CaloIdL_MW_v21, fragment.HLT_Mu37_Ele27_CaloIdL_MW_v21, fragment.HLT_Mu37_TkMu27_v21, fragment.HLT_DoubleMu4_3_Bs_v31, fragment.HLT_DoubleMu4_3_Jpsi_v31, fragment.HLT_DoubleMu4_3_LowMass_v17, fragment.HLT_DoubleMu4_LowMass_Displaced_v17, fragment.HLT_Mu0_L1DoubleMu_v17, fragment.HLT_Mu4_L1DoubleMu_v17, fragment.HLT_DoubleMu2_Jpsi_LowPt_v10, fragment.HLT_DoubleMu4_3_Photon4_BsToMMG_v16, fragment.HLT_DoubleMu4_3_Displaced_Photon4_BsToMMG_v16, fragment.HLT_DoubleMu3_Trk_Tau3mu_v28, fragment.HLT_DoubleMu3_TkMu_DsTau3Mu_v20, fragment.HLT_DoubleMu4_Mass3p8_DZ_PFHT350_v24, fragment.HLT_DoubleMu4_MuMuTrk_Displaced_v31, fragment.HLT_Mu3_PFJet40_v32, fragment.HLT_Mu7p5_L2Mu2_Jpsi_v26, fragment.HLT_Mu7p5_L2Mu2_Upsilon_v26, fragment.HLT_Mu3_L1SingleMu5orSingleMu7_v17, fragment.HLT_Mu0_Barrel_v10, fragment.HLT_Mu0_Barrel_L1HP6_v7, fragment.HLT_Mu0_Barrel_L1HP7_v7, fragment.HLT_Mu0_Barrel_L1HP8_v8, fragment.HLT_Mu0_Barrel_L1HP9_v8, fragment.HLT_Mu0_Barrel_L1HP10_v10, fragment.HLT_Mu0_Barrel_L1HP11_v10, fragment.HLT_Mu0_Barrel_L1HP13_v4, fragment.HLT_Mu0_Barrel_L1HP6_IP6_v7, fragment.HLT_Mu4_Barrel_IP4_v4, fragment.HLT_Mu4_Barrel_IP6_v4, fragment.HLT_Mu6_Barrel_L1HP7_IP6_v7, fragment.HLT_Mu7_Barrel_L1HP8_IP6_v8, fragment.HLT_Mu8_Barrel_L1HP9_IP6_v8, fragment.HLT_Mu9_Barrel_L1HP10_IP6_v10, fragment.HLT_Mu10_Barrel_L1HP11_IP4_v4, fragment.HLT_Mu10_Barrel_L1HP11_IP6_v10, fragment.HLT_Mu12_Barrel_L1HP13_IP4_v4, fragment.HLT_Mu12_Barrel_L1HP13_IP6_v4, fragment.HLT_DoublePhoton33_CaloIdL_v18, fragment.HLT_DoublePhoton70_v18, fragment.HLT_DoublePhoton85_v26, fragment.HLT_DiEle27_WPTightCaloOnly_L1DoubleEG_v16, fragment.HLT_Ele30_WPTight_Gsf_v16, fragment.HLT_Ele32_WPTight_Gsf_v30, fragment.HLT_Ele35_WPTight_Gsf_v24, fragment.HLT_Ele38_WPTight_Gsf_v24, fragment.HLT_Ele40_WPTight_Gsf_v24, fragment.HLT_Ele32_WPTight_Gsf_L1DoubleEG_v24, fragment.HLT_IsoMu20_v31, fragment.HLT_IsoMu24_v29, fragment.HLT_IsoMu24_HLTTracking_v4, fragment.HLT_IsoMu24_eta2p1_v31, fragment.HLT_IsoMu27_v32, fragment.HLT_UncorrectedJetE30_NoBPTX_v16, fragment.HLT_UncorrectedJetE30_NoBPTX3BX_v16, fragment.HLT_UncorrectedJetE60_NoBPTX3BX_v16, fragment.HLT_UncorrectedJetE70_NoBPTX3BX_v16, fragment.HLT_L1SingleMuCosmics_v9, fragment.HLT_L2Mu10_NoVertex_NoBPTX3BX_v15, fragment.HLT_L2Mu10_NoVertex_NoBPTX_v16, fragment.HLT_L2Mu45_NoVertex_3Sta_NoBPTX3BX_v14, fragment.HLT_L2Mu40_NoVertex_3Sta_NoBPTX3BX_v15, fragment.HLT_L2Mu23NoVtx_2Cha_v11, fragment.HLT_L2Mu23NoVtx_2Cha_CosmicSeed_v11, fragment.HLT_DoubleL2Mu30NoVtx_2Cha_CosmicSeed_Eta2p4_v12, fragment.HLT_DoubleL2Mu30NoVtx_2Cha_Eta2p4_v12, fragment.HLT_DoubleL2Mu50_v12, fragment.HLT_DoubleL2Mu23NoVtx_2Cha_CosmicSeed_v12, fragment.HLT_DoubleL2Mu25NoVtx_2Cha_CosmicSeed_v12, fragment.HLT_DoubleL2Mu25NoVtx_2Cha_CosmicSeed_Eta2p4_v12, fragment.HLT_DoubleL2Mu23NoVtx_2Cha_v12, fragment.HLT_DoubleL2Mu25NoVtx_2Cha_v12, fragment.HLT_DoubleL2Mu25NoVtx_2Cha_Eta2p4_v12, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v30, fragment.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_v19, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v31, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_HLTTracking_v4, fragment.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_v19, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_v21, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_PFJet30_v10, fragment.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_Mass8_v19, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass3p8_v21, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass3p8_HLTTracking_v4, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_CaloJet30_v9, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_AK8PFJet30_v9, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_AK8CaloJet30_v9, fragment.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_Mass3p8_v19, fragment.HLT_Mu30_TkMu0_Psi_v17, fragment.HLT_Mu30_TkMu0_Upsilon_v17, fragment.HLT_Mu25_TkMu0_Phi_v24, fragment.HLT_Mu15_v19, fragment.HLT_Mu20_v28, fragment.HLT_Mu27_v29, fragment.HLT_Mu50_v29, fragment.HLT_Mu55_v19, fragment.HLT_CascadeMu100_v16, fragment.HLT_HighPtTkMu100_v16, fragment.HLT_DiPFJetAve40_v30, fragment.HLT_DiPFJetAve60_v30, fragment.HLT_DiPFJetAve80_v30, fragment.HLT_DiPFJetAve140_v29, fragment.HLT_DiPFJetAve200_v29, fragment.HLT_DiPFJetAve260_v30, fragment.HLT_DiPFJetAve320_v30, fragment.HLT_DiPFJetAve400_v30, fragment.HLT_DiPFJetAve500_v30, fragment.HLT_DiPFJetAve60_HFJEC_v31, fragment.HLT_DiPFJetAve80_HFJEC_v33, fragment.HLT_DiPFJetAve100_HFJEC_v33, fragment.HLT_DiPFJetAve160_HFJEC_v32, fragment.HLT_DiPFJetAve220_HFJEC_v32, fragment.HLT_DiPFJetAve260_HFJEC_v15, fragment.HLT_DiPFJetAve300_HFJEC_v32, fragment.HLT_DiPFJetAve180_PPSMatch_Xi0p3_QuadJet_Max2ProtPerRP_v10, fragment.HLT_AK8PFJet40_v32, fragment.HLT_AK8PFJet60_v31, fragment.HLT_AK8PFJet80_v32, fragment.HLT_AK8PFJet140_v31, fragment.HLT_AK8PFJet200_v31, fragment.HLT_AK8PFJet260_v32, fragment.HLT_AK8PFJet320_v32, fragment.HLT_AK8PFJet400_v32, fragment.HLT_AK8PFJet450_v32, fragment.HLT_AK8PFJet500_v32, fragment.HLT_AK8PFJet550_v27, fragment.HLT_PFJet40_v37, fragment.HLT_PFJet60_v37, fragment.HLT_PFJet80_v37, fragment.HLT_PFJet110_v16, fragment.HLT_PFJet140_v35, fragment.HLT_PFJet200_v35, fragment.HLT_PFJet260_v36, fragment.HLT_PFJet320_v36, fragment.HLT_PFJet400_v36, fragment.HLT_PFJet450_v37, fragment.HLT_PFJet500_v37, fragment.HLT_PFJet550_v27, fragment.HLT_PFJetFwd40_v35, fragment.HLT_PFJetFwd60_v35, fragment.HLT_PFJetFwd80_v34, fragment.HLT_PFJetFwd140_v34, fragment.HLT_PFJetFwd200_v34, fragment.HLT_PFJetFwd260_v35, fragment.HLT_PFJetFwd320_v35, fragment.HLT_PFJetFwd400_v35, fragment.HLT_PFJetFwd450_v35, fragment.HLT_PFJetFwd500_v35, fragment.HLT_AK8PFJetFwd40_v31, fragment.HLT_AK8PFJetFwd60_v30, fragment.HLT_AK8PFJetFwd80_v30, fragment.HLT_AK8PFJetFwd140_v30, fragment.HLT_AK8PFJetFwd200_v30, fragment.HLT_AK8PFJetFwd260_v31, fragment.HLT_AK8PFJetFwd320_v31, fragment.HLT_AK8PFJetFwd400_v31, fragment.HLT_AK8PFJetFwd450_v31, fragment.HLT_AK8PFJetFwd500_v31, fragment.HLT_PFHT180_v33, fragment.HLT_PFHT250_v33, fragment.HLT_PFHT370_v33, fragment.HLT_PFHT430_v33, fragment.HLT_PFHT510_v33, fragment.HLT_PFHT590_v33, fragment.HLT_PFHT680_v33, fragment.HLT_PFHT780_v33, fragment.HLT_PFHT890_v33, fragment.HLT_PFHT1050_v34, fragment.HLT_PFHT500_PFMET100_PFMHT100_IDTight_v28, fragment.HLT_PFHT500_PFMET110_PFMHT110_IDTight_v28, fragment.HLT_PFHT700_PFMET85_PFMHT85_IDTight_v28, fragment.HLT_PFHT800_PFMET75_PFMHT75_IDTight_v28, fragment.HLT_PFMET120_PFMHT120_IDTight_v36, fragment.HLT_PFMET130_PFMHT130_IDTight_v36, fragment.HLT_PFMET140_PFMHT140_IDTight_v36, fragment.HLT_PFMET120_PFMHT120_IDTight_PFHT60_v25, fragment.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_PFHT60_v25, fragment.HLT_PFMETTypeOne140_PFMHT140_IDTight_v27, fragment.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_v36, fragment.HLT_PFMETNoMu130_PFMHTNoMu130_IDTight_v35, fragment.HLT_PFMETNoMu140_PFMHTNoMu140_IDTight_v35, fragment.HLT_PFMETNoMu110_PFMHTNoMu110_IDTight_FilterHF_v16, fragment.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_FilterHF_v16, fragment.HLT_PFMETNoMu130_PFMHTNoMu130_IDTight_FilterHF_v16, fragment.HLT_PFMETNoMu140_PFMHTNoMu140_IDTight_FilterHF_v16, fragment.HLT_L1ETMHadSeeds_v11, fragment.HLT_CaloMHT90_v16, fragment.HLT_CaloMET90_NotCleaned_v16, fragment.HLT_CaloMET350_NotCleaned_v16, fragment.HLT_PFMET200_NotCleaned_v25, fragment.HLT_PFMET250_NotCleaned_v25, fragment.HLT_PFMET300_NotCleaned_v25, fragment.HLT_PFMET200_BeamHaloCleaned_v25, fragment.HLT_PFMETTypeOne200_BeamHaloCleaned_v25, fragment.HLT_MET105_IsoTrk50_v23, fragment.HLT_MET120_IsoTrk50_v23, fragment.HLT_Mu12eta2p3_v17, fragment.HLT_Mu12eta2p3_PFJet40_v17, fragment.HLT_Mu12_DoublePFJets40_PNetBTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets100_PNetBTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets200_PNetBTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets350_PNetBTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets40MaxDeta1p6_PNet2BTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets54MaxDeta1p6_PNet2BTag_0p11_v10, fragment.HLT_DoublePFJets40_PNetBTag_0p11_v10, fragment.HLT_DoublePFJets100_PNetBTag_0p11_v10, fragment.HLT_DoublePFJets200_PNetBTag_0p11_v10, fragment.HLT_DoublePFJets350_PNetBTag_0p11_v10, fragment.HLT_DoublePFJets116MaxDeta1p6_PNet2BTag_0p11_v10, fragment.HLT_DoublePFJets128MaxDeta1p6_PNet2BTag_0p11_v10, fragment.HLT_Photon300_NoHE_v24, fragment.HLT_Mu8_TrkIsoVVL_v28, fragment.HLT_Mu8_DiEle12_CaloIdL_TrackIdL_DZ_v34, fragment.HLT_Mu8_DiEle12_CaloIdL_TrackIdL_v34, fragment.HLT_Mu8_Ele8_CaloIdM_TrackIdM_Mass8_PFHT350_DZ_v35, fragment.HLT_Mu8_Ele8_CaloIdM_TrackIdM_Mass8_PFHT350_v35, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_v29, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_v17, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v27, fragment.HLT_Mu17_TrkIsoVVL_v29, fragment.HLT_Mu19_TrkIsoVVL_v20, fragment.HLT_BTagMu_AK4DiJet20_Mu5_v29, fragment.HLT_BTagMu_AK4DiJet40_Mu5_v29, fragment.HLT_BTagMu_AK4DiJet70_Mu5_v29, fragment.HLT_BTagMu_AK4DiJet110_Mu5_v29, fragment.HLT_BTagMu_AK4DiJet170_Mu5_v28, fragment.HLT_BTagMu_AK4Jet300_Mu5_v28, fragment.HLT_BTagMu_AK8DiJet170_Mu5_v25, fragment.HLT_BTagMu_AK8Jet170_DoubleMu5_v18, fragment.HLT_BTagMu_AK8Jet300_Mu5_v28, fragment.HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v33, fragment.HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_v33, fragment.HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v31, fragment.HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v23, fragment.HLT_Mu12_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v23, fragment.HLT_Mu12_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_v31, fragment.HLT_Mu12_IsoVVL_PFHT150_PNetBTag0p53_v9, fragment.HLT_Photon33_v16, fragment.HLT_Photon50_v24, fragment.HLT_Photon75_v24, fragment.HLT_Photon90_v24, fragment.HLT_Photon120_v24, fragment.HLT_Photon150_v18, fragment.HLT_Photon175_v26, fragment.HLT_Photon200_v25, fragment.HLT_Photon45EB_v4, fragment.HLT_Photon40EB_v4, fragment.HLT_Photon50EB_v5, fragment.HLT_Photon30EB_TightID_TightIso_v15, fragment.HLT_Photon40EB_TightID_TightIso_v6, fragment.HLT_Photon45EB_TightID_TightIso_v6, fragment.HLT_Photon50EB_TightID_TightIso_PFJet30_v10, fragment.HLT_Photon50EB_TightID_TightIso_CaloJet30_v6, fragment.HLT_Photon50EB_TightID_TightIso_AK8PFJet30_v9, fragment.HLT_Photon50EB_TightID_TightIso_AK8CaloJet30_v6, fragment.HLT_Photon50EB_TightID_TightIso_v11, fragment.HLT_Photon55EB_TightID_TightIso_v7, fragment.HLT_Photon75EB_TightID_TightIso_v11, fragment.HLT_Photon90EB_TightID_TightIso_v11, fragment.HLT_Photon110EB_TightID_TightIso_v15, fragment.HLT_Photon110EB_TightID_TightIso_PFJet30_v10, fragment.HLT_Photon110EB_TightID_TightIso_CaloJet30_v6, fragment.HLT_Photon110EB_TightID_TightIso_AK8PFJet30_v9, fragment.HLT_Photon110EB_TightID_TightIso_AK8CaloJet30_v6, fragment.HLT_Photon100EBHE10_v13, fragment.HLT_Photon50_R9Id90_HE10_IsoM_v27, fragment.HLT_Photon75_R9Id90_HE10_IsoM_v27, fragment.HLT_Photon90_R9Id90_HE10_IsoM_v27, fragment.HLT_Photon120_R9Id90_HE10_IsoM_v27, fragment.HLT_Photon165_R9Id90_HE10_IsoM_v28, fragment.HLT_Diphoton30_22_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass90_v26, fragment.HLT_Diphoton30_22_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass95_v26, fragment.HLT_Photon35_TwoProngs35_v17, fragment.HLT_IsoMu24_TwoProngs35_v17, fragment.HLT_Dimuon0_Jpsi_L1_NoOS_v23, fragment.HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23, fragment.HLT_Dimuon0_Jpsi_v24, fragment.HLT_Dimuon0_Jpsi_NoVertexing_v24, fragment.HLT_Dimuon0_Jpsi_L1_4R_0er1p5R_v23, fragment.HLT_Dimuon0_Jpsi_NoVertexing_L1_4R_0er1p5R_v23, fragment.HLT_Dimuon0_Jpsi3p5_Muon2_v21, fragment.HLT_Dimuon0_Upsilon_L1_4p5_v25, fragment.HLT_Dimuon0_Upsilon_L1_4p5er2p0_v25, fragment.HLT_Dimuon0_Upsilon_L1_4p5er2p0M_v23, fragment.HLT_Dimuon0_Upsilon_NoVertexing_v23, fragment.HLT_Dimuon0_LowMass_L1_0er1p5_v24, fragment.HLT_Dimuon0_LowMass_v24, fragment.HLT_Dimuon0_LowMass_L1_4_v24, fragment.HLT_Dimuon0_LowMass_L1_TM530_v22, fragment.HLT_Dimuon0_Upsilon_Muon_NoL1Mass_v22, fragment.HLT_Dimuon0_Upsilon_v2, fragment.HLT_TripleMu_5_3_3_Mass3p8_DZ_v24, fragment.HLT_TripleMu_10_5_5_DZ_v26, fragment.HLT_TripleMu_12_10_5_v26, fragment.HLT_Tau3Mu_Mu7_Mu1_TkMu1_Tau15_v20, fragment.HLT_Tau3Mu_Mu7_Mu1_TkMu1_Tau15_Charge1_v20, fragment.HLT_Tau3Mu_Mu7_Mu1_TkMu1_IsoTau15_v20, fragment.HLT_Tau3Mu_Mu7_Mu1_TkMu1_IsoTau15_Charge1_v20, fragment.HLT_DoubleMu3_DZ_PFMET50_PFMHT60_v26, fragment.HLT_DoubleMu3_DZ_PFMET70_PFMHT70_v26, fragment.HLT_DoubleMu3_DZ_PFMET90_PFMHT90_v26, fragment.HLT_DoubleMu3_Trk_Tau3mu_NoL1Mass_v22, fragment.HLT_DoubleMu4_3_LowMass_SS_v10, fragment.HLT_DoubleMu4_Jpsi_Displaced_v23, fragment.HLT_DoubleMu4_Jpsi_NoVertexing_v23, fragment.HLT_DoubleMu4_JpsiTrkTrk_Displaced_v23, fragment.HLT_DoubleMu4_JpsiTrk_Bc_v16, fragment.HLT_DoubleMu43NoFiltersNoVtx_v17, fragment.HLT_DoubleMu48NoFiltersNoVtx_v17, fragment.HLT_Mu43NoFiltersNoVtx_Photon43_CaloIdL_v18, fragment.HLT_Mu48NoFiltersNoVtx_Photon48_CaloIdL_v18, fragment.HLT_Mu38NoFiltersNoVtxDisplaced_Photon38_CaloIdL_v14, fragment.HLT_Mu43NoFiltersNoVtxDisplaced_Photon43_CaloIdL_v14, fragment.HLT_Ele28_HighEta_SC20_Mass55_v27, fragment.HLT_Ele15_IsoVVVL_PFHT450_PFMET50_v32, fragment.HLT_Ele15_IsoVVVL_PFHT450_v32, fragment.HLT_Ele50_IsoVVVL_PFHT450_v32, fragment.HLT_Ele15_IsoVVVL_PFHT600_v36, fragment.HLT_Mu15_IsoVVVL_PFHT450_PFMET50_v31, fragment.HLT_Mu15_IsoVVVL_PFHT450_v31, fragment.HLT_Mu50_IsoVVVL_PFHT450_v31, fragment.HLT_Mu15_IsoVVVL_PFHT600_v35, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMET80_PFMHT80_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMET90_PFMHT90_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMET100_PFMHT100_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu80_PFMHTNoMu80_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu90_PFMHTNoMu90_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu100_PFMHTNoMu100_IDTight_v18, fragment.HLT_Dimuon10_Upsilon_y1p4_v17, fragment.HLT_Dimuon12_Upsilon_y1p4_v18, fragment.HLT_Dimuon14_Phi_Barrel_Seagulls_v23, fragment.HLT_Dimuon25_Jpsi_v30, fragment.HLT_Dimuon14_PsiPrime_v29, fragment.HLT_Dimuon14_PsiPrime_noCorrL1_v21, fragment.HLT_Dimuon18_PsiPrime_v30, fragment.HLT_Dimuon18_PsiPrime_noCorrL1_v22, fragment.HLT_Dimuon24_Upsilon_noCorrL1_v22, fragment.HLT_Dimuon24_Phi_noCorrL1_v22, fragment.HLT_Dimuon25_Jpsi_noCorrL1_v22, fragment.HLT_DiMu4_Ele9_CaloIdL_TrackIdL_DZ_Mass3p8_v33, fragment.HLT_DiMu9_Ele9_CaloIdL_TrackIdL_DZ_v33, fragment.HLT_DiMu9_Ele9_CaloIdL_TrackIdL_v33, fragment.HLT_DoubleIsoMu20_eta2p1_v23, fragment.HLT_TrkMu12_DoubleTrkMu5NoFiltersNoVtx_v21, fragment.HLT_Mu8_v28, fragment.HLT_Mu17_v29, fragment.HLT_Mu19_v20, fragment.HLT_Mu17_Photon30_IsoCaloId_v22, fragment.HLT_Ele8_CaloIdL_TrackIdL_IsoVL_PFJet30_v32, fragment.HLT_Ele12_CaloIdL_TrackIdL_IsoVL_PFJet30_v34, fragment.HLT_Ele14_eta2p5_IsoVVVL_Gsf_PFHT200_PNetBTag0p53_v9, fragment.HLT_Ele23_CaloIdL_TrackIdL_IsoVL_PFJet30_v34, fragment.HLT_Ele8_CaloIdM_TrackIdM_PFJet30_v34, fragment.HLT_Ele17_CaloIdM_TrackIdM_PFJet30_v32, fragment.HLT_Ele23_CaloIdM_TrackIdM_PFJet30_v34, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_PFJet165_v34, fragment.HLT_Ele115_CaloIdVT_GsfTrkIdT_v28, fragment.HLT_Ele135_CaloIdVT_GsfTrkIdT_v21, fragment.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_v25, fragment.HLT_PFHT400_SixPFJet32_v25, fragment.HLT_PFHT400_SixPFJet32_PNet2BTagMean0p50_v13, fragment.HLT_PFHT450_SixPFJet36_v24, fragment.HLT_PFHT450_SixPFJet36_PNetBTag0p35_v13, fragment.HLT_PFHT400_FivePFJet_120_120_60_30_30_v10, fragment.HLT_PFHT350_v35, fragment.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT350_v14, fragment.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT380_v14, fragment.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT400_v14, fragment.HLT_ECALHT800_v22, fragment.HLT_DiSC30_18_EIso_AND_HE_Mass70_v25, fragment.HLT_Photon20_HoverELoose_v21, fragment.HLT_Photon30_HoverELoose_v21, fragment.HLT_L1_CDC_SingleMu_3_er1p2_TOP120_DPHI2p618_3p142_v10, fragment.HLT_CDC_L2cosmic_10_er1p0_v11, fragment.HLT_CDC_L2cosmic_5p5_er1p0_v11, fragment.HLT_Photon60_R9Id90_HE10_IsoM_EBOnly_PFJetsMJJ300DEta3_v13, fragment.HLT_Photon75_R9Id90_HE10_IsoM_EBOnly_PFJetsMJJ300DEta3_v21, fragment.HLT_Mu18_Mu9_SameSign_v20, fragment.HLT_DoubleMu2_Jpsi_DoubleTrk1_Phi1p05_v22, fragment.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_v26, fragment.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_Mass2p0_v10, fragment.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_Mass2p0_noDCA_v10, fragment.HLT_TripleMu_5_3_3_Mass3p8_DCA_v19, fragment.HLT_QuadPFJet103_88_75_15_v21, fragment.HLT_QuadPFJet105_88_76_15_v21, fragment.HLT_QuadPFJet111_90_80_15_v21, fragment.HLT_Diphoton30_18_R9IdL_AND_HE_AND_IsoCaloId_v14, fragment.HLT_Diphoton30_18_R9IdL_AND_HE_AND_IsoCaloId_Mass55_v14, fragment.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Tight_eta2p3_CrossL1_v11, fragment.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Medium_eta2p3_CrossL1_v11, fragment.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Loose_eta2p3_CrossL1_v11, fragment.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_PNet3BTag_4p3_v9, fragment.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_PNet3BTag_2p0_v9, fragment.HLT_PFHT400_FivePFJet_120_120_60_30_30_PNet2BTag_5p6_v10, fragment.HLT_PFHT400_FivePFJet_120_120_60_30_30_PNet2BTag_4p3_v10, fragment.HLT_QuadPFJet103_88_75_15_PNetBTag_0p4_VBF2_v10, fragment.HLT_QuadPFJet103_88_75_15_PNet2BTag_0p4_0p12_VBF1_v10, fragment.HLT_QuadPFJet105_88_76_15_PNetBTag_0p4_VBF2_v10, fragment.HLT_QuadPFJet105_88_76_15_PNet2BTag_0p4_0p12_VBF1_v10, fragment.HLT_QuadPFJet111_90_80_15_PNetBTag_0p4_VBF2_v10, fragment.HLT_QuadPFJet111_90_80_15_PNet2BTag_0p4_0p12_VBF1_v10, fragment.HLT_PFHT250_QuadPFJet25_v10, fragment.HLT_PFHT250_QuadPFJet25_PNet2BTagMean0p55_v10, fragment.HLT_PFHT250_QuadPFJet25_PNet1BTag0p20_PNet1Tauh0p50_v10, fragment.HLT_PFHT250_QuadPFJet30_PNet2BTagMean0p55_v10, fragment.HLT_PFHT250_QuadPFJet30_PNet1BTag0p20_PNet1Tauh0p50_v10, fragment.HLT_PFHT280_QuadPFJet30_PNet1BTag0p20_PNet1Tauh0p50_v10, fragment.HLT_PFHT280_QuadPFJet30_v13, fragment.HLT_PFHT280_QuadPFJet30_PNet2BTagMean0p55_v13, fragment.HLT_PFHT280_QuadPFJet30_PNet2BTagMean0p60_v13, fragment.HLT_PFHT280_QuadPFJet35_PNet2BTagMean0p60_v13, fragment.HLT_PFHT340_QuadPFJet70_50_40_40_PNet2BTagMean0p70_v14, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_v13, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_QuadPFJet30_v13, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_QuadPFJet30_PNet2BTagMean0p55_v13, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PNet2BTagMean0p50_v13, fragment.HLT_QuadPFJet100_88_70_30_v14, fragment.HLT_QuadPFJet105_88_75_30_v13, fragment.HLT_QuadPFJet111_90_80_30_v13, fragment.HLT_QuadPFJet100_88_70_30_PNet1CvsAll0p5_VBF3Tight_v14, fragment.HLT_QuadPFJet105_88_75_30_PNet1CvsAll0p5_VBF3Tight_v14, fragment.HLT_QuadPFJet111_90_80_30_PNet1CvsAll0p6_VBF3Tight_v14, fragment.HLT_AK8PFJet220_SoftDropMass40_v17, fragment.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p50_v13, fragment.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p53_v13, fragment.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p55_v13, fragment.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p60_v13, fragment.HLT_AK8PFJet230_SoftDropMass40_v17, fragment.HLT_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_AK8PFJet230_SoftDropMass40_PNetTauTau0p03_v13, fragment.HLT_AK8PFJet230_SoftDropMass40_PNetTauTau0p05_v13, fragment.HLT_AK8PFJet250_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_AK8PFJet250_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_AK8PFJet250_SoftDropMass40_PNetTauTau0p03_v13, fragment.HLT_AK8PFJet250_SoftDropMass40_PNetTauTau0p05_v13, fragment.HLT_AK8PFJet275_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_AK8PFJet275_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_AK8PFJet275_SoftDropMass40_PNetTauTau0p03_v13, fragment.HLT_AK8PFJet275_SoftDropMass40_PNetTauTau0p05_v13, fragment.HLT_AK8PFJet275_Nch45_v10, fragment.HLT_AK8PFJet275_Nch40_v10, fragment.HLT_IsoMu50_AK8PFJet220_SoftDropMass40_v16, fragment.HLT_IsoMu50_AK8PFJet220_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_v16, fragment.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet220_SoftDropMass40_v16, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet220_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_v16, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_DoubleAK4PFJet60_30_v14, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_DoubleAK4PFJet60_30_PNet2BTagMean0p50_v14, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_v10, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_v10, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_PNet2BTagMean0p55_v10, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_PNet1BTag0p20_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Medium_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Tight_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_PFJet60_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_PFJet75_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Tight_eta2p3_CrossL1_ETau_Monitoring_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Medium_eta2p3_CrossL1_ETau_Monitoring_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Loose_eta2p3_CrossL1_ETau_Monitoring_v10, fragment.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Tight_eta2p3_CrossL1_v10, fragment.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Medium_eta2p3_CrossL1_v10, fragment.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Loose_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet20_eta2p2_SingleL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet45_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PFHT250_v10, fragment.HLT_IsoMu24_eta2p1_PFHT250_QuadPFJet25_v10, fragment.HLT_IsoMu24_eta2p1_PFHT250_QuadPFJet25_PNet1Tauh0p50_v10, fragment.HLT_IsoMu24_eta2p1_SinglePFJet25_PNet1Tauh0p50_v10, fragment.HLT_DoublePNetTauhPFJet30_Medium_L2NN_eta2p3_v10, fragment.HLT_DoublePNetTauhPFJet30_Tight_L2NN_eta2p3_v10, fragment.HLT_DoublePNetTauhPFJet26_L2NN_eta2p3_PFJet60_v10, fragment.HLT_DoublePNetTauhPFJet26_L2NN_eta2p3_PFJet75_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Loose_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Medium_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Tight_L2NN_eta2p3_CrossL1_v10, fragment.HLT_SinglePNetTauhPFJet130_Loose_L2NN_eta2p3_v10, fragment.HLT_SinglePNetTauhPFJet130_Medium_L2NN_eta2p3_v10, fragment.HLT_SinglePNetTauhPFJet130_Tight_L2NN_eta2p3_v10, fragment.HLT_DoubleL2Mu10NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v16, fragment.HLT_DoubleL2Mu12NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_DoubleL2Mu14NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_DoubleL3Mu16_10NoVtx_DxyMin0p01cm_v14, fragment.HLT_DoubleL3Mu18_10NoVtx_DxyMin0p01cm_v13, fragment.HLT_DoubleL3Mu20_10NoVtx_DxyMin0p01cm_v13, fragment.HLT_L2Mu10NoVtx_2Cha_v10, fragment.HLT_L2Mu10NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_L3Mu10NoVtx_v13, fragment.HLT_L3Mu10NoVtx_DxyMin0p01cm_v13, fragment.HLT_DoubleL2Mu_L3Mu16NoVtx_VetoL3Mu0DxyMax0p1cm_v13, fragment.HLT_DoubleL2Mu_L3Mu18NoVtx_VetoL3Mu0DxyMax0p1cm_v13, fragment.HLT_DoubleL2Mu10NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_DoubleL2Mu12NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_L2Mu10NoVtx_2Cha_CosmicSeed_v10, fragment.HLT_L2Mu10NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_DoubleL3dTksMu16_10NoVtx_DxyMin0p01cm_v14, fragment.HLT_L2Mu50NoVtx_3Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v8, fragment.HLT_L2Mu50NoVtx_3Cha_VetoL3Mu0DxyMax1cm_v8, fragment.HLT_L3Mu30NoVtx_DxyMin0p01cm_v6, fragment.HLT_L3Mu50NoVtx_DxyMin0p01cm_v6, fragment.HLT_L3dTksMu10_NoVtx_DxyMin0p01cm_v14, fragment.HLT_Mu20NoFiltersNoVtxDisplaced_Photon20_CaloCustomId_v14, fragment.HLT_DisplacedMu24_MediumChargedIsoDisplacedPFTauHPS24_v12, fragment.HLT_Photon34_R9Id90_CaloIdL_IsoL_DisplacedIdL_MediumChargedIsoDisplacedPFTauHPS34_v12, fragment.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS32_Trk1_eta2p1_v17, fragment.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS36_Trk1_eta2p1_v12, fragment.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS32_Trk1_eta2p1_noDxy_v12, fragment.HLT_IsoMu27_MediumChargedIsoDisplacedPFTauHPS24_eta2p1_SingleL1_v12, fragment.HLT_HT350_DelayedJet40_SingleDelay1p5To3p5nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay1p6To3p5nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay1p75To3p5nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay3nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay3p25nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay3p5nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay0p5nsInclusive_v11, fragment.HLT_HT430_DelayedJet40_SingleDelay1nsInclusive_v11, fragment.HLT_HT430_DelayedJet40_SingleDelay1To1p5nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay1p1To1p6nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay1p25To1p75nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay1p5nsInclusive_v11, fragment.HLT_HT430_DelayedJet40_SingleDelay2nsInclusive_v13, fragment.HLT_HT430_DelayedJet40_SingleDelay2p25nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay2p5nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay0p5nsTrackless_v12, fragment.HLT_HT430_DelayedJet40_SingleDelay1nsTrackless_v14, fragment.HLT_HT430_DelayedJet40_SingleDelay1p25nsTrackless_v10, fragment.HLT_HT430_DelayedJet40_SingleDelay1p5nsTrackless_v10, fragment.HLT_HT430_DelayedJet40_DoubleDelay0p5nsInclusive_v12, fragment.HLT_HT430_DelayedJet40_DoubleDelay1nsInclusive_v13, fragment.HLT_HT430_DelayedJet40_DoubleDelay1p25nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_DoubleDelay1p5nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_DoubleDelay0p5nsTrackless_v14, fragment.HLT_HT430_DelayedJet40_DoubleDelay0p75nsTrackless_v10, fragment.HLT_HT430_DelayedJet40_DoubleDelay1nsTrackless_v10, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p5To4nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p6To4nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p75To4nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay3p5nsInclusive_v11, fragment.HLT_L1Tau_DelayedJet40_SingleDelay3p75nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay4nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p5nsTrackless_v12, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p75nsTrackless_v10, fragment.HLT_L1Tau_DelayedJet40_SingleDelay3nsTrackless_v10, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay0p75nsInclusive_v11, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p25nsInclusive_v11, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p5nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p75nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay0p5nsTrackless_v12, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1nsTrackless_v12, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p25nsTrackless_v10, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p5nsTrackless_v10, fragment.HLT_L1Mu6HT240_v10, fragment.HLT_Mu6HT240_DisplacedDijet30_Inclusive1PtrkShortSig5_DisplacedLoose_v14, fragment.HLT_Mu6HT240_DisplacedDijet35_Inclusive0PtrkShortSig5_v14, fragment.HLT_Mu6HT240_DisplacedDijet35_Inclusive1PtrkShortSig5_DisplacedLoose_v14, fragment.HLT_Mu6HT240_DisplacedDijet40_Inclusive0PtrkShortSig5_v14, fragment.HLT_Mu6HT240_DisplacedDijet40_Inclusive1PtrkShortSig5_DisplacedLoose_v14, fragment.HLT_Mu6HT240_DisplacedDijet45_Inclusive0PtrkShortSig5_v14, fragment.HLT_Mu6HT240_DisplacedDijet50_Inclusive0PtrkShortSig5_v14, fragment.HLT_HT350_v9, fragment.HLT_HT425_v21, fragment.HLT_HT360_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT360_DisplacedDijet45_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT390_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT390_DisplacedDijet45_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT390eta2p0_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT430_DisplacedDijet40_Inclusive1PtrkShortSig5_v14, fragment.HLT_HT400_DisplacedDijet40_DisplacedTrack_v26, fragment.HLT_HT430_DisplacedDijet40_DisplacedTrack_v26, fragment.HLT_HT550_DisplacedDijet60_Inclusive_v26, fragment.HLT_HT650_DisplacedDijet60_Inclusive_v26, fragment.HLT_CaloMET60_DTCluster50_v13, fragment.HLT_CaloMET60_DTClusterNoMB1S50_v13, fragment.HLT_L1MET_DTCluster50_v13, fragment.HLT_L1MET_DTClusterNoMB1S50_v13, fragment.HLT_CscCluster_Loose_v11, fragment.HLT_CscCluster_Medium_v11, fragment.HLT_CscCluster_Tight_v11, fragment.HLT_CscCluster50_Photon20Unseeded_v5, fragment.HLT_CscCluster50_Photon30Unseeded_v5, fragment.HLT_CscCluster100_Ele5_v7, fragment.HLT_CscCluster100_Mu5_v10, fragment.HLT_CscCluster100_PNetTauhPFJet10_Loose_v10, fragment.HLT_CscCluster150_DisplacedSingleJet30_Inclusive1PtrkShortSig5_v3, fragment.HLT_CscCluster150_DisplacedSingleJet35_Inclusive1PtrkShortSig5_v3, fragment.HLT_CscCluster150_DisplacedSingleJet40_Inclusive1PtrkShortSig5_v3, fragment.HLT_DoubleCscCluster75_v8, fragment.HLT_IsoTrk200_L1SingleMuShower_v8, fragment.HLT_IsoTrk400_L1SingleMuShower_v8, fragment.HLT_DoubleCscCluster100_v8, fragment.HLT_L1CSCShower_DTCluster50_v11, fragment.HLT_L1CSCShower_DTCluster75_v11, fragment.HLT_PFMET105_IsoTrk50_v17, fragment.HLT_L1SingleLLPJet_v8, fragment.HLT_L1SingleMuShower_v1, fragment.HLT_HT170_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, fragment.HLT_HT200_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, fragment.HLT_HT200_L1SingleLLPJet_DisplacedDijet60_DisplacedTrack_v14, fragment.HLT_HT270_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, fragment.HLT_HT200_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v14, fragment.HLT_HT240_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11, fragment.HLT_HT280_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11, fragment.HLT_HT320_L1SingleLLPJet_DisplacedDijet60_Inclusive_v14, fragment.HLT_HT420_L1SingleLLPJet_DisplacedDijet60_Inclusive_v14, fragment.HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay1nsTrackless_v14, fragment.HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay2nsInclusive_v14, fragment.HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay0p5nsTrackless_v14, fragment.HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay1nsInclusive_v14, fragment.HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p7_v10, fragment.HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p8_v10, fragment.HLT_DiPhoton10Time1ns_v11, fragment.HLT_DiPhoton10Time1p2ns_v11, fragment.HLT_DiPhoton10Time1p4ns_v11, fragment.HLT_DiPhoton10Time1p6ns_v11, fragment.HLT_DiPhoton10Time1p8ns_v11, fragment.HLT_DiPhoton10Time2ns_v11, fragment.HLT_DiPhoton10_CaloIdL_v11, fragment.HLT_DiphotonMVA14p25_Low_Mass60_v1, fragment.HLT_DiphotonMVA14p25_Medium_Mass60_v1, fragment.HLT_DiphotonMVA14p25_High_Mass60_v1, fragment.HLT_DiphotonMVA14p25_TightLow_Mass60_v1, fragment.HLT_DiphotonMVA14p25_TightMedium_Mass60_v1, fragment.HLT_DiphotonMVA14p25_TightHigh_Mass60_v1, fragment.HLT_Diphoton15_10_EBEB_TightID_ECALTrackIsoDr0p2_v3, fragment.HLT_Diphoton15_12_EBEB_TightID_ECALTrackIsoDr0p2_v3, fragment.HLT_Diphoton15_10_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v3, fragment.HLT_Diphoton15_12_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v3, fragment.HLT_Dielectron12_5_EBEB_TightID_ECALTrackIsoDr0p2_v4, fragment.HLT_Dielectron12_5_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v4, fragment.HLT_DoubleEle6p5_eta1p22_mMax6_v13, fragment.HLT_DoubleEle8_eta1p22_mMax6_v13, fragment.HLT_DoubleEle10_eta1p22_mMax6_v13, fragment.HLT_SingleEle8_v12, fragment.HLT_SingleEle8_SingleEGL1_v12, fragment.HLT_Diphoton20_14_eta1p5_R9IdL_AND_HE_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton20_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton22_14_eta1p5_R9IdL_AND_HE_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton22_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton24_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton24_16_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, fragment.HLT_Mu50_L1SingleMuShower_v15, fragment.HLT_IsoMu24_OneProng32_v13, fragment.HLT_Photon32_OneProng32_M50To105_v14, fragment.HLT_VBF_DiPFJet125_45_Mjj1050_v12, fragment.HLT_VBF_DiPFJet125_45_Mjj1150_v4, fragment.HLT_VBF_DiPFJet125_45_Mjj1250_v4, fragment.HLT_VBF_DiPFJet75_45_Mjj800_DiPFJet60_v10, fragment.HLT_VBF_DiPFJet75_45_Mjj900_DiPFJet60_v4, fragment.HLT_VBF_DiPFJet75_45_Mjj1000_DiPFJet60_v4, fragment.HLT_VBF_DiPFJet80_45_Mjj650_PFMETNoMu85_v10, fragment.HLT_VBF_DiPFJet80_45_Mjj750_PFMETNoMu85_v10, fragment.HLT_VBF_DiPFJet80_45_Mjj850_PFMETNoMu85_v4, fragment.HLT_VBF_DiPFJet95_45_Mjj750_Mu3_TrkIsoVVL_v10, fragment.HLT_VBF_DiPFJet95_45_Mjj850_Mu3_TrkIsoVVL_v10, fragment.HLT_VBF_DiPFJet95_45_Mjj950_Mu3_TrkIsoVVL_v4, fragment.HLT_VBF_DiPFJet50_Mjj650_Photon22_v10, fragment.HLT_VBF_DiPFJet50_Mjj750_Photon22_v10, fragment.HLT_VBF_DiPFJet50_Mjj850_Photon22_v4, fragment.HLT_VBF_DiPFJet50_Mjj600_Ele22_eta2p1_WPTight_Gsf_v11, fragment.HLT_VBF_DiPFJet50_Mjj700_Ele22_eta2p1_WPTight_Gsf_v5, fragment.HLT_VBF_DiPFJet50_Mjj800_Ele22_eta2p1_WPTight_Gsf_v5, fragment.HLT_VBF_DiPFJet115_40_Mjj850_DoublePNetTauhPFJet20_eta2p3_v4, fragment.HLT_VBF_DiPFJet115_40_Mjj1000_DoublePNetTauhPFJet20_eta2p3_v4, fragment.HLT_VBF_DiPFJet115_40_Mjj1100_DoublePNetTauhPFJet20_eta2p3_v4, fragment.HLT_VBF_DiPFJet115_40_Mjj1200_DoublePNetTauhPFJet20_eta2p3_v4, fragment.HLT_VBF_DiPFJet45_Mjj650_PNetTauhPFJet45_L2NN_eta2p3_v10, fragment.HLT_VBF_DiPFJet45_Mjj750_PNetTauhPFJet45_L2NN_eta2p3_v10, fragment.HLT_VBF_DiPFJet45_Mjj850_PNetTauhPFJet45_L2NN_eta2p3_v4, fragment.HLT_L1HT200_QuadPFJet20_PNet1BTag0p50_PNet1Tauh0p50_v4, fragment.HLT_L1HT200_QuadPFJet25_PNet1BTag0p50_PNet1Tauh0p50_v4, fragment.HLT_IsoMu24_eta2p1_L1HT200_v4, fragment.HLT_IsoMu24_eta2p1_L1HT200_QuadPFJet25_v4, fragment.HLT_IsoMu24_eta2p1_L1HT200_QuadPFJet25_PNet1Tauh0p50_v4, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_v4, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet20_v4, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet25_v4, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet25_PNet1BTag0p50_v4, fragment.HLT_PFJet200_TimeLtNeg2p5ns_v14, fragment.HLT_PFJet200_TimeGt2p5ns_v14, fragment.HLT_Photon50_TimeLtNeg2p5ns_v8, fragment.HLT_Photon50_TimeGt2p5ns_v8, fragment.HLT_PPSMaxTracksPerArm1_v10, fragment.HLT_PPSMaxTracksPerRP4_v10, fragment.HLT_PPSRandom_v1, fragment.HLT_TestData_v1, fragment.MC_ReducedIterativeTracking_v26, fragment.MC_AK4CaloJets_v21, fragment.MC_AK4CaloJetsFromPV_v21, fragment.MC_CaloHT_v20, fragment.MC_AK8CaloHT_v20, fragment.MC_CaloMHT_v20, fragment.MC_AK4PFJets_v33, fragment.MC_PFHT_v32, fragment.MC_AK8PFJets_v33, fragment.MC_AK8PFHT_v32, fragment.MC_CaloMET_v20, fragment.MC_CaloMET_JetIdCleaned_v21, fragment.MC_PFMET_v33, fragment.MC_PFMHT_v32, fragment.MC_AK4PFJetPNet_v9, fragment.MC_AK8PFJetPNet_v9, fragment.MC_Egamma_Open_v12, fragment.MC_Egamma_Open_Unseeded_v12, fragment.MC_Ele5_WPTight_Gsf_v23, fragment.MC_Ele15_Ele10_CaloIdL_TrackIdL_IsoVL_DZ_v29, fragment.MC_Diphoton10_10_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass10_v26, fragment.MC_DoubleEle5_CaloIdL_MW_v29, fragment.MC_IsoMu_v31, fragment.MC_DoubleMu_TrkIsoVVL_DZ_v27, fragment.MC_DoubleMuNoFiltersNoVtx_v20, fragment.MC_PFScouting_v10, fragment.HLT_L1AlwaysTrue_v1, fragment.HLT_L1AXOVVTight_v1, fragment.HLT_L1AXOVVVTight_v1, fragment.HLT_L1CICADA_VVTight_v1, fragment.HLT_L1CICADA_VVVTight_v1, fragment.HLT_L1CICADA_VVVVTight_v1, fragment.HLTriggerFinalPath, fragment.HLTAnalyzerEndpath, fragment.Dataset_AlCaHcalIsoTrk, fragment.Dataset_AlCaLowPtJet, fragment.Dataset_AlCaLumiPixelsCountsExpress, fragment.Dataset_AlCaLumiPixelsCountsPrompt, fragment.Dataset_AlCaP0, fragment.Dataset_AlCaPPSExpress, fragment.Dataset_AlCaPPSPrompt, fragment.Dataset_AlCaPhiSym, fragment.Dataset_BTagMu, fragment.Dataset_Commissioning, fragment.Dataset_Cosmics, fragment.Dataset_DQMGPUvsCPU, fragment.Dataset_DQMOnlineBeamspot, fragment.Dataset_DQMPPSRandom, fragment.Dataset_EGamma0, fragment.Dataset_EGamma1, fragment.Dataset_EGamma2, fragment.Dataset_EGamma3, fragment.Dataset_EcalLaser, fragment.Dataset_EphemeralHLTPhysics0, fragment.Dataset_EphemeralHLTPhysics1, fragment.Dataset_EphemeralHLTPhysics2, fragment.Dataset_EphemeralHLTPhysics3, fragment.Dataset_EphemeralHLTPhysics4, fragment.Dataset_EphemeralHLTPhysics5, fragment.Dataset_EphemeralHLTPhysics6, fragment.Dataset_EphemeralHLTPhysics7, fragment.Dataset_EphemeralZeroBias0, fragment.Dataset_EphemeralZeroBias1, fragment.Dataset_EphemeralZeroBias2, fragment.Dataset_EphemeralZeroBias3, fragment.Dataset_EphemeralZeroBias4, fragment.Dataset_EphemeralZeroBias5, fragment.Dataset_EphemeralZeroBias6, fragment.Dataset_EphemeralZeroBias7, fragment.Dataset_EventDisplay, fragment.Dataset_ExpressAlignment, fragment.Dataset_ExpressPhysics, fragment.Dataset_HLTMonitor, fragment.Dataset_HLTPhysics, fragment.Dataset_HcalNZS, fragment.Dataset_JetMET0, fragment.Dataset_JetMET1, fragment.Dataset_L1Accept, fragment.Dataset_MonteCarlo, fragment.Dataset_Muon0, fragment.Dataset_Muon1, fragment.Dataset_MuonEG, fragment.Dataset_NoBPTX, fragment.Dataset_OnlineMonitor, fragment.Dataset_ParkingDoubleMuonLowMass0, fragment.Dataset_ParkingDoubleMuonLowMass1, fragment.Dataset_ParkingDoubleMuonLowMass2, fragment.Dataset_ParkingDoubleMuonLowMass3, fragment.Dataset_ParkingDoubleMuonLowMass4, fragment.Dataset_ParkingDoubleMuonLowMass5, fragment.Dataset_ParkingDoubleMuonLowMass6, fragment.Dataset_ParkingDoubleMuonLowMass7, fragment.Dataset_ParkingHH0, fragment.Dataset_ParkingHH1, fragment.Dataset_ParkingLLP0, fragment.Dataset_ParkingLLP1, fragment.Dataset_ParkingSingleMuon0, fragment.Dataset_ParkingSingleMuon1, fragment.Dataset_ParkingSingleMuon2, fragment.Dataset_ParkingSingleMuon3, fragment.Dataset_ParkingSingleMuon4, fragment.Dataset_ParkingSingleMuon5, fragment.Dataset_ParkingSingleMuon6, fragment.Dataset_ParkingSingleMuon7, fragment.Dataset_ParkingSingleMuon8, fragment.Dataset_ParkingSingleMuon9, fragment.Dataset_ParkingSingleMuon10, fragment.Dataset_ParkingSingleMuon11, fragment.Dataset_ParkingSingleMuon12, fragment.Dataset_ParkingSingleMuon13, fragment.Dataset_ParkingSingleMuon14, fragment.Dataset_ParkingSingleMuon15, fragment.Dataset_ParkingVBF0, fragment.Dataset_ParkingVBF1, fragment.Dataset_ParkingVBF2, fragment.Dataset_ParkingVBF3, fragment.Dataset_ParkingVBF4, fragment.Dataset_ParkingVBF5, fragment.Dataset_ParkingVBF6, fragment.Dataset_ParkingVBF7, fragment.Dataset_ParkingAnomalyDetection, fragment.Dataset_RPCMonitor, fragment.Dataset_ScoutingPFMonitor, fragment.Dataset_ScoutingPF0, fragment.Dataset_ScoutingPF1, fragment.Dataset_Tau, fragment.Dataset_TestEnablesEcalHcal, fragment.Dataset_TestEnablesEcalHcalDQM, fragment.Dataset_ZeroBias, fragment.Dataset_TestDataRaw, fragment.Dataset_TestDataScouting, fragment.Dataset_EmittanceScan0, fragment.Dataset_EmittanceScan1, fragment.Dataset_EmittanceScan2, fragment.Dataset_EmittanceScan3, fragment.Dataset_EmittanceScan4, fragment.Dataset_EmittanceScan5, fragment.Dataset_DQMOnlineScouting, fragment.ScoutingPF0Output, fragment.ScoutingPF1Output, )) +fragment.schedule = cms.Schedule( *(fragment.HLTriggerFirstPath, fragment.Status_OnCPU, fragment.Status_OnGPU, fragment.AlCa_EcalPhiSym_v22, fragment.AlCa_EcalEtaEBonly_v27, fragment.AlCa_EcalEtaEEonly_v27, fragment.AlCa_EcalPi0EBonly_v27, fragment.AlCa_EcalPi0EEonly_v27, fragment.AlCa_IsoTrackHBHE_v3, fragment.AlCa_RPCMuonNormalisation_v25, fragment.AlCa_LumiPixelsCounts_Random_v12, fragment.AlCa_LumiPixelsCounts_ZeroBias_v15, fragment.AlCa_PFJet40_v36, fragment.AlCa_PFJet40_CPUOnly_v15, fragment.AlCa_AK8PFJet40_v31, fragment.DQM_PixelReconstruction_v14, fragment.DQM_EcalReconstruction_v13, fragment.DQM_HcalReconstruction_v11, fragment.DST_ZeroBias_v12, fragment.DST_Physics_v17, fragment.DST_PFScouting_DoubleMuonNoVtx_v4, fragment.DST_PFScouting_DoubleMuonVtx_v4, fragment.DST_PFScouting_DoubleMuonVtxMonitorJPsi_v4, fragment.DST_PFScouting_DoubleMuonVtxMonitorZ_v4, fragment.DST_PFScouting_DoubleEG_v10, fragment.DST_PFScouting_DoubleEGMonitorJPsi_v1, fragment.DST_PFScouting_DoubleEGMonitorZ_v1, fragment.DST_PFScouting_SinglePhotonEBMonitorJPsi_v1, fragment.DST_PFScouting_SinglePhotonEBMonitorZ_v1, fragment.DST_PFScouting_JetHT_v10, fragment.DST_PFScouting_AXOVLoose_v8, fragment.DST_PFScouting_AXOLoose_v8, fragment.DST_PFScouting_AXOMedium_v4, fragment.DST_PFScouting_AXOTight_v10, fragment.DST_PFScouting_AXOVTight_v8, fragment.HLT_MonitorL1TPureRate_AXO_v1, fragment.DST_PFScouting_CICADAVLoose_v6, fragment.DST_PFScouting_CICADALoose_v6, fragment.DST_PFScouting_CICADAMedium_v6, fragment.DST_PFScouting_CICADATight_v6, fragment.DST_PFScouting_CICADAVTight_v6, fragment.HLT_MonitorL1TPureRate_CICADA_v1, fragment.DST_PFScouting_SingleMuon_v10, fragment.DST_PFScouting_SinglePhotonEB_v7, fragment.DST_PFScouting_ZeroBias_v8, fragment.HLT_TriggersForScoutingPFMonitor_PS125_v1, fragment.HLT_TriggersForScoutingPFMonitor_PS250_v1, fragment.HLT_TriggersForScoutingPFMonitor_PS500_v1, fragment.HLT_TriggersForScoutingPFMonitor_PS1000_v1, fragment.HLT_EphemeralPhysics_v10, fragment.HLT_EphemeralZeroBias_v10, fragment.HLT_EcalCalibration_v4, fragment.HLT_HcalCalibration_v6, fragment.HLT_HcalNZS_v22, fragment.HLT_HcalPhiSym_v24, fragment.HLT_Random_v3, fragment.HLT_Physics_v15, fragment.HLT_ZeroBias_v14, fragment.HLT_ZeroBias_Alignment_v9, fragment.HLT_ZeroBias_Beamspot_v20, fragment.HLT_ZeroBias_IsolatedBunches_v13, fragment.HLT_ZeroBias_FirstBXAfterTrain_v11, fragment.HLT_ZeroBias_FirstCollisionAfterAbortGap_v13, fragment.HLT_ZeroBias_FirstCollisionInTrain_v12, fragment.HLT_ZeroBias_LastCollisionInTrain_v11, fragment.HLT_HT300_Beamspot_v27, fragment.HLT_PFJet40_GPUvsCPU_v8, fragment.HLT_AK8PFJet380_SoftDropMass30_v10, fragment.HLT_AK8PFJet400_SoftDropMass30_v10, fragment.HLT_AK8PFJet425_SoftDropMass30_v10, fragment.HLT_AK8PFJet450_SoftDropMass30_v10, fragment.HLT_AK8DiPFJet250_250_SoftDropMass40_v10, fragment.HLT_AK8DiPFJet250_250_SoftDropMass50_v10, fragment.HLT_AK8DiPFJet260_260_SoftDropMass30_v10, fragment.HLT_AK8DiPFJet260_260_SoftDropMass40_v10, fragment.HLT_AK8DiPFJet270_270_SoftDropMass30_v10, fragment.HLT_AK8DiPFJet280_280_SoftDropMass30_v16, fragment.HLT_AK8DiPFJet290_290_SoftDropMass30_v10, fragment.HLT_CaloJet500_NoJetID_v24, fragment.HLT_CaloJet550_NoJetID_v19, fragment.HLT_DoubleMu5_Upsilon_DoubleEle3_CaloIdL_TrackIdL_v20, fragment.HLT_DoubleMu3_DoubleEle7p5_CaloIdL_TrackIdL_Upsilon_v20, fragment.HLT_Trimuon5_3p5_2_Upsilon_Muon_v21, fragment.HLT_TrimuonOpen_5_3p5_2_Upsilon_Muon_v18, fragment.HLT_DoubleEle25_CaloIdL_MW_v18, fragment.HLT_DoubleEle27_CaloIdL_MW_v18, fragment.HLT_DoubleEle33_CaloIdL_MW_v31, fragment.HLT_DoubleEle24_eta2p1_WPTight_Gsf_v22, fragment.HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_DZ_PFHT350_v36, fragment.HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_PFHT350_v36, fragment.HLT_Mu27_Ele37_CaloIdL_MW_v21, fragment.HLT_Mu37_Ele27_CaloIdL_MW_v21, fragment.HLT_Mu37_TkMu27_v21, fragment.HLT_DoubleMu4_3_Bs_v31, fragment.HLT_DoubleMu4_3_Jpsi_v31, fragment.HLT_DoubleMu4_3_LowMass_v17, fragment.HLT_DoubleMu4_LowMass_Displaced_v17, fragment.HLT_Mu0_L1DoubleMu_v17, fragment.HLT_Mu4_L1DoubleMu_v17, fragment.HLT_DoubleMu2_Jpsi_LowPt_v10, fragment.HLT_DoubleMu4_3_Photon4_BsToMMG_v16, fragment.HLT_DoubleMu4_3_Displaced_Photon4_BsToMMG_v16, fragment.HLT_DoubleMu3_Trk_Tau3mu_v28, fragment.HLT_DoubleMu3_TkMu_DsTau3Mu_v20, fragment.HLT_DoubleMu4_Mass3p8_DZ_PFHT350_v24, fragment.HLT_DoubleMu4_MuMuTrk_Displaced_v31, fragment.HLT_Mu3_PFJet40_v32, fragment.HLT_Mu7p5_L2Mu2_Jpsi_v26, fragment.HLT_Mu7p5_L2Mu2_Upsilon_v26, fragment.HLT_Mu3_L1SingleMu5orSingleMu7_v17, fragment.HLT_Mu0_Barrel_v10, fragment.HLT_Mu0_Barrel_L1HP6_v7, fragment.HLT_Mu0_Barrel_L1HP7_v7, fragment.HLT_Mu0_Barrel_L1HP8_v8, fragment.HLT_Mu0_Barrel_L1HP9_v8, fragment.HLT_Mu0_Barrel_L1HP10_v10, fragment.HLT_Mu0_Barrel_L1HP11_v10, fragment.HLT_Mu0_Barrel_L1HP13_v4, fragment.HLT_Mu0_Barrel_L1HP6_IP6_v7, fragment.HLT_Mu4_Barrel_IP4_v4, fragment.HLT_Mu4_Barrel_IP6_v4, fragment.HLT_Mu6_Barrel_L1HP7_IP6_v7, fragment.HLT_Mu7_Barrel_L1HP8_IP6_v8, fragment.HLT_Mu8_Barrel_L1HP9_IP6_v8, fragment.HLT_Mu9_Barrel_L1HP10_IP6_v10, fragment.HLT_Mu10_Barrel_L1HP11_IP4_v4, fragment.HLT_Mu10_Barrel_L1HP11_IP6_v10, fragment.HLT_Mu12_Barrel_L1HP13_IP4_v4, fragment.HLT_Mu12_Barrel_L1HP13_IP6_v4, fragment.HLT_DoublePhoton33_CaloIdL_v18, fragment.HLT_DoublePhoton70_v18, fragment.HLT_DoublePhoton85_v26, fragment.HLT_DiEle27_WPTightCaloOnly_L1DoubleEG_v16, fragment.HLT_Ele30_WPTight_Gsf_v16, fragment.HLT_Ele32_WPTight_Gsf_v30, fragment.HLT_Ele35_WPTight_Gsf_v24, fragment.HLT_Ele38_WPTight_Gsf_v24, fragment.HLT_Ele40_WPTight_Gsf_v24, fragment.HLT_Ele32_WPTight_Gsf_L1DoubleEG_v24, fragment.HLT_IsoMu20_v31, fragment.HLT_IsoMu24_v29, fragment.HLT_IsoMu24_HLTTracking_v4, fragment.HLT_IsoMu24_eta2p1_v31, fragment.HLT_IsoMu27_v32, fragment.HLT_UncorrectedJetE30_NoBPTX_v16, fragment.HLT_UncorrectedJetE30_NoBPTX3BX_v16, fragment.HLT_UncorrectedJetE60_NoBPTX3BX_v16, fragment.HLT_UncorrectedJetE70_NoBPTX3BX_v16, fragment.HLT_L1SingleMuCosmics_v9, fragment.HLT_L2Mu10_NoVertex_NoBPTX3BX_v15, fragment.HLT_L2Mu10_NoVertex_NoBPTX_v16, fragment.HLT_L2Mu45_NoVertex_3Sta_NoBPTX3BX_v14, fragment.HLT_L2Mu40_NoVertex_3Sta_NoBPTX3BX_v15, fragment.HLT_L2Mu23NoVtx_2Cha_v11, fragment.HLT_L2Mu23NoVtx_2Cha_CosmicSeed_v11, fragment.HLT_DoubleL2Mu30NoVtx_2Cha_CosmicSeed_Eta2p4_v12, fragment.HLT_DoubleL2Mu30NoVtx_2Cha_Eta2p4_v12, fragment.HLT_DoubleL2Mu50_v12, fragment.HLT_DoubleL2Mu23NoVtx_2Cha_CosmicSeed_v12, fragment.HLT_DoubleL2Mu25NoVtx_2Cha_CosmicSeed_v12, fragment.HLT_DoubleL2Mu25NoVtx_2Cha_CosmicSeed_Eta2p4_v12, fragment.HLT_DoubleL2Mu23NoVtx_2Cha_v12, fragment.HLT_DoubleL2Mu25NoVtx_2Cha_v12, fragment.HLT_DoubleL2Mu25NoVtx_2Cha_Eta2p4_v12, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v30, fragment.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_v19, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v31, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_HLTTracking_v4, fragment.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_v19, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_v21, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_PFJet30_v10, fragment.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_Mass8_v19, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass3p8_v21, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass3p8_HLTTracking_v4, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_CaloJet30_v9, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_AK8PFJet30_v9, fragment.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_AK8CaloJet30_v9, fragment.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_Mass3p8_v19, fragment.HLT_Mu30_TkMu0_Psi_v17, fragment.HLT_Mu30_TkMu0_Upsilon_v17, fragment.HLT_Mu25_TkMu0_Phi_v24, fragment.HLT_Mu15_v19, fragment.HLT_Mu20_v28, fragment.HLT_Mu27_v29, fragment.HLT_Mu50_v29, fragment.HLT_Mu55_v19, fragment.HLT_CascadeMu100_v16, fragment.HLT_HighPtTkMu100_v16, fragment.HLT_DiPFJetAve40_v30, fragment.HLT_DiPFJetAve60_v30, fragment.HLT_DiPFJetAve80_v30, fragment.HLT_DiPFJetAve140_v29, fragment.HLT_DiPFJetAve200_v29, fragment.HLT_DiPFJetAve260_v30, fragment.HLT_DiPFJetAve320_v30, fragment.HLT_DiPFJetAve400_v30, fragment.HLT_DiPFJetAve500_v30, fragment.HLT_DiPFJetAve60_HFJEC_v31, fragment.HLT_DiPFJetAve80_HFJEC_v33, fragment.HLT_DiPFJetAve100_HFJEC_v33, fragment.HLT_DiPFJetAve160_HFJEC_v32, fragment.HLT_DiPFJetAve220_HFJEC_v32, fragment.HLT_DiPFJetAve260_HFJEC_v15, fragment.HLT_DiPFJetAve300_HFJEC_v32, fragment.HLT_DiPFJetAve180_PPSMatch_Xi0p3_QuadJet_Max2ProtPerRP_v10, fragment.HLT_AK8PFJet40_v32, fragment.HLT_AK8PFJet60_v31, fragment.HLT_AK8PFJet80_v32, fragment.HLT_AK8PFJet140_v31, fragment.HLT_AK8PFJet200_v31, fragment.HLT_AK8PFJet260_v32, fragment.HLT_AK8PFJet320_v32, fragment.HLT_AK8PFJet400_v32, fragment.HLT_AK8PFJet450_v32, fragment.HLT_AK8PFJet500_v32, fragment.HLT_AK8PFJet550_v27, fragment.HLT_PFJet40_v37, fragment.HLT_PFJet60_v37, fragment.HLT_PFJet80_v37, fragment.HLT_PFJet110_v16, fragment.HLT_PFJet140_v35, fragment.HLT_PFJet200_v35, fragment.HLT_PFJet260_v36, fragment.HLT_PFJet320_v36, fragment.HLT_PFJet400_v36, fragment.HLT_PFJet450_v37, fragment.HLT_PFJet500_v37, fragment.HLT_PFJet550_v27, fragment.HLT_PFJetFwd40_v35, fragment.HLT_PFJetFwd60_v35, fragment.HLT_PFJetFwd80_v34, fragment.HLT_PFJetFwd140_v34, fragment.HLT_PFJetFwd200_v34, fragment.HLT_PFJetFwd260_v35, fragment.HLT_PFJetFwd320_v35, fragment.HLT_PFJetFwd400_v35, fragment.HLT_PFJetFwd450_v35, fragment.HLT_PFJetFwd500_v35, fragment.HLT_AK8PFJetFwd40_v31, fragment.HLT_AK8PFJetFwd60_v30, fragment.HLT_AK8PFJetFwd80_v30, fragment.HLT_AK8PFJetFwd140_v30, fragment.HLT_AK8PFJetFwd200_v30, fragment.HLT_AK8PFJetFwd260_v31, fragment.HLT_AK8PFJetFwd320_v31, fragment.HLT_AK8PFJetFwd400_v31, fragment.HLT_AK8PFJetFwd450_v31, fragment.HLT_AK8PFJetFwd500_v31, fragment.HLT_PFHT180_v33, fragment.HLT_PFHT250_v33, fragment.HLT_PFHT370_v33, fragment.HLT_PFHT430_v33, fragment.HLT_PFHT510_v33, fragment.HLT_PFHT590_v33, fragment.HLT_PFHT680_v33, fragment.HLT_PFHT780_v33, fragment.HLT_PFHT890_v33, fragment.HLT_PFHT1050_v34, fragment.HLT_PFHT500_PFMET100_PFMHT100_IDTight_v28, fragment.HLT_PFHT500_PFMET110_PFMHT110_IDTight_v28, fragment.HLT_PFHT700_PFMET85_PFMHT85_IDTight_v28, fragment.HLT_PFHT800_PFMET75_PFMHT75_IDTight_v28, fragment.HLT_PFMET120_PFMHT120_IDTight_v36, fragment.HLT_PFMET130_PFMHT130_IDTight_v36, fragment.HLT_PFMET140_PFMHT140_IDTight_v36, fragment.HLT_PFMET120_PFMHT120_IDTight_PFHT60_v25, fragment.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_PFHT60_v25, fragment.HLT_PFMETTypeOne140_PFMHT140_IDTight_v27, fragment.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_v36, fragment.HLT_PFMETNoMu130_PFMHTNoMu130_IDTight_v35, fragment.HLT_PFMETNoMu140_PFMHTNoMu140_IDTight_v35, fragment.HLT_PFMETNoMu110_PFMHTNoMu110_IDTight_FilterHF_v16, fragment.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_FilterHF_v16, fragment.HLT_PFMETNoMu130_PFMHTNoMu130_IDTight_FilterHF_v16, fragment.HLT_PFMETNoMu140_PFMHTNoMu140_IDTight_FilterHF_v16, fragment.HLT_L1ETMHadSeeds_v11, fragment.HLT_CaloMHT90_v16, fragment.HLT_CaloMET90_NotCleaned_v16, fragment.HLT_CaloMET350_NotCleaned_v16, fragment.HLT_PFMET200_NotCleaned_v25, fragment.HLT_PFMET250_NotCleaned_v25, fragment.HLT_PFMET300_NotCleaned_v25, fragment.HLT_PFMET200_BeamHaloCleaned_v25, fragment.HLT_PFMETTypeOne200_BeamHaloCleaned_v25, fragment.HLT_MET105_IsoTrk50_v23, fragment.HLT_MET120_IsoTrk50_v23, fragment.HLT_Mu12eta2p3_v17, fragment.HLT_Mu12eta2p3_PFJet40_v17, fragment.HLT_Mu12_DoublePFJets40_PNetBTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets100_PNetBTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets200_PNetBTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets350_PNetBTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets40MaxDeta1p6_PNet2BTag_0p11_v10, fragment.HLT_Mu12_DoublePFJets54MaxDeta1p6_PNet2BTag_0p11_v10, fragment.HLT_DoublePFJets40_PNetBTag_0p11_v10, fragment.HLT_DoublePFJets100_PNetBTag_0p11_v10, fragment.HLT_DoublePFJets200_PNetBTag_0p11_v10, fragment.HLT_DoublePFJets350_PNetBTag_0p11_v10, fragment.HLT_DoublePFJets116MaxDeta1p6_PNet2BTag_0p11_v10, fragment.HLT_DoublePFJets128MaxDeta1p6_PNet2BTag_0p11_v10, fragment.HLT_Photon300_NoHE_v24, fragment.HLT_Mu8_TrkIsoVVL_v28, fragment.HLT_Mu8_DiEle12_CaloIdL_TrackIdL_DZ_v34, fragment.HLT_Mu8_DiEle12_CaloIdL_TrackIdL_v34, fragment.HLT_Mu8_Ele8_CaloIdM_TrackIdM_Mass8_PFHT350_DZ_v35, fragment.HLT_Mu8_Ele8_CaloIdM_TrackIdM_Mass8_PFHT350_v35, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_v29, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_v17, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v27, fragment.HLT_Mu17_TrkIsoVVL_v29, fragment.HLT_Mu19_TrkIsoVVL_v20, fragment.HLT_BTagMu_AK4DiJet20_Mu5_v29, fragment.HLT_BTagMu_AK4DiJet40_Mu5_v29, fragment.HLT_BTagMu_AK4DiJet70_Mu5_v29, fragment.HLT_BTagMu_AK4DiJet110_Mu5_v29, fragment.HLT_BTagMu_AK4DiJet170_Mu5_v28, fragment.HLT_BTagMu_AK4Jet300_Mu5_v28, fragment.HLT_BTagMu_AK8DiJet170_Mu5_v25, fragment.HLT_BTagMu_AK8Jet170_DoubleMu5_v18, fragment.HLT_BTagMu_AK8Jet300_Mu5_v28, fragment.HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v33, fragment.HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_v33, fragment.HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v31, fragment.HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v23, fragment.HLT_Mu12_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v23, fragment.HLT_Mu12_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_v31, fragment.HLT_Mu12_IsoVVL_PFHT150_PNetBTag0p53_v9, fragment.HLT_Photon33_v16, fragment.HLT_Photon50_v24, fragment.HLT_Photon75_v24, fragment.HLT_Photon90_v24, fragment.HLT_Photon120_v24, fragment.HLT_Photon150_v18, fragment.HLT_Photon175_v26, fragment.HLT_Photon200_v25, fragment.HLT_Photon45EB_v4, fragment.HLT_Photon40EB_v4, fragment.HLT_Photon50EB_v5, fragment.HLT_Photon30EB_TightID_TightIso_v15, fragment.HLT_Photon40EB_TightID_TightIso_v6, fragment.HLT_Photon45EB_TightID_TightIso_v6, fragment.HLT_Photon50EB_TightID_TightIso_PFJet30_v10, fragment.HLT_Photon50EB_TightID_TightIso_CaloJet30_v6, fragment.HLT_Photon50EB_TightID_TightIso_AK8PFJet30_v9, fragment.HLT_Photon50EB_TightID_TightIso_AK8CaloJet30_v6, fragment.HLT_Photon50EB_TightID_TightIso_v11, fragment.HLT_Photon55EB_TightID_TightIso_v7, fragment.HLT_Photon75EB_TightID_TightIso_v11, fragment.HLT_Photon90EB_TightID_TightIso_v11, fragment.HLT_Photon110EB_TightID_TightIso_v15, fragment.HLT_Photon110EB_TightID_TightIso_PFJet30_v10, fragment.HLT_Photon110EB_TightID_TightIso_CaloJet30_v6, fragment.HLT_Photon110EB_TightID_TightIso_AK8PFJet30_v9, fragment.HLT_Photon110EB_TightID_TightIso_AK8CaloJet30_v6, fragment.HLT_Photon100EBHE10_v13, fragment.HLT_Photon50_R9Id90_HE10_IsoM_v27, fragment.HLT_Photon75_R9Id90_HE10_IsoM_v27, fragment.HLT_Photon90_R9Id90_HE10_IsoM_v27, fragment.HLT_Photon120_R9Id90_HE10_IsoM_v27, fragment.HLT_Photon165_R9Id90_HE10_IsoM_v28, fragment.HLT_Diphoton30_22_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass90_v26, fragment.HLT_Diphoton30_22_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass95_v26, fragment.HLT_Photon35_TwoProngs35_v17, fragment.HLT_IsoMu24_TwoProngs35_v17, fragment.HLT_Dimuon0_Jpsi_L1_NoOS_v23, fragment.HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23, fragment.HLT_Dimuon0_Jpsi_v24, fragment.HLT_Dimuon0_Jpsi_NoVertexing_v24, fragment.HLT_Dimuon0_Jpsi_L1_4R_0er1p5R_v23, fragment.HLT_Dimuon0_Jpsi_NoVertexing_L1_4R_0er1p5R_v23, fragment.HLT_Dimuon0_Jpsi3p5_Muon2_v21, fragment.HLT_Dimuon0_Upsilon_L1_4p5_v25, fragment.HLT_Dimuon0_Upsilon_L1_4p5er2p0_v25, fragment.HLT_Dimuon0_Upsilon_L1_4p5er2p0M_v23, fragment.HLT_Dimuon0_Upsilon_NoVertexing_v23, fragment.HLT_Dimuon0_LowMass_L1_0er1p5_v24, fragment.HLT_Dimuon0_LowMass_v24, fragment.HLT_Dimuon0_LowMass_L1_4_v24, fragment.HLT_Dimuon0_LowMass_Inclusive_v1, fragment.HLT_Dimuon0_LowMass_L1_TM530_v22, fragment.HLT_Dimuon0_Upsilon_Muon_NoL1Mass_v22, fragment.HLT_Dimuon0_Upsilon_v2, fragment.HLT_TripleMu_5_3_3_Mass3p8_DZ_v24, fragment.HLT_TripleMu_10_5_5_DZ_v26, fragment.HLT_TripleMu_12_10_5_v26, fragment.HLT_Tau3Mu_Mu7_Mu1_TkMu1_Tau15_v20, fragment.HLT_Tau3Mu_Mu7_Mu1_TkMu1_Tau15_Charge1_v20, fragment.HLT_Tau3Mu_Mu7_Mu1_TkMu1_IsoTau15_v20, fragment.HLT_Tau3Mu_Mu7_Mu1_TkMu1_IsoTau15_Charge1_v20, fragment.HLT_DoubleMu3_DZ_PFMET50_PFMHT60_v26, fragment.HLT_DoubleMu3_DZ_PFMET70_PFMHT70_v26, fragment.HLT_DoubleMu3_DZ_PFMET90_PFMHT90_v26, fragment.HLT_DoubleMu3_Trk_Tau3mu_NoL1Mass_v22, fragment.HLT_DoubleMu4_3_LowMass_SS_v10, fragment.HLT_DoubleMu4_Jpsi_Displaced_v23, fragment.HLT_DoubleMu4_Jpsi_NoVertexing_v23, fragment.HLT_DoubleMu4_JpsiTrkTrk_Displaced_v23, fragment.HLT_DoubleMu4_JpsiTrk_Bc_v16, fragment.HLT_DoubleMu43NoFiltersNoVtx_v17, fragment.HLT_DoubleMu48NoFiltersNoVtx_v17, fragment.HLT_Mu43NoFiltersNoVtx_Photon43_CaloIdL_v18, fragment.HLT_Mu48NoFiltersNoVtx_Photon48_CaloIdL_v18, fragment.HLT_Mu38NoFiltersNoVtxDisplaced_Photon38_CaloIdL_v14, fragment.HLT_Mu43NoFiltersNoVtxDisplaced_Photon43_CaloIdL_v14, fragment.HLT_Ele28_HighEta_SC20_Mass55_v27, fragment.HLT_Ele15_IsoVVVL_PFHT450_PFMET50_v32, fragment.HLT_Ele15_IsoVVVL_PFHT450_v32, fragment.HLT_Ele50_IsoVVVL_PFHT450_v32, fragment.HLT_Ele15_IsoVVVL_PFHT600_v36, fragment.HLT_Mu15_IsoVVVL_PFHT450_PFMET50_v31, fragment.HLT_Mu15_IsoVVVL_PFHT450_v31, fragment.HLT_Mu50_IsoVVVL_PFHT450_v31, fragment.HLT_Mu15_IsoVVVL_PFHT600_v35, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMET80_PFMHT80_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMET90_PFMHT90_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMET100_PFMHT100_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu80_PFMHTNoMu80_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu90_PFMHTNoMu90_IDTight_v18, fragment.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu100_PFMHTNoMu100_IDTight_v18, fragment.HLT_Dimuon10_Upsilon_y1p4_v17, fragment.HLT_Dimuon12_Upsilon_y1p4_v18, fragment.HLT_Dimuon14_Phi_Barrel_Seagulls_v23, fragment.HLT_Dimuon25_Jpsi_v30, fragment.HLT_Dimuon14_PsiPrime_v29, fragment.HLT_Dimuon14_PsiPrime_noCorrL1_v21, fragment.HLT_Dimuon18_PsiPrime_v30, fragment.HLT_Dimuon18_PsiPrime_noCorrL1_v22, fragment.HLT_Dimuon24_Upsilon_noCorrL1_v22, fragment.HLT_Dimuon24_Phi_noCorrL1_v22, fragment.HLT_Dimuon25_Jpsi_noCorrL1_v22, fragment.HLT_DiMu4_Ele9_CaloIdL_TrackIdL_DZ_Mass3p8_v33, fragment.HLT_DiMu9_Ele9_CaloIdL_TrackIdL_DZ_v33, fragment.HLT_DiMu9_Ele9_CaloIdL_TrackIdL_v33, fragment.HLT_DoubleIsoMu20_eta2p1_v23, fragment.HLT_TrkMu12_DoubleTrkMu5NoFiltersNoVtx_v21, fragment.HLT_Mu8_v28, fragment.HLT_Mu17_v29, fragment.HLT_Mu19_v20, fragment.HLT_Mu17_Photon30_IsoCaloId_v22, fragment.HLT_Ele8_CaloIdL_TrackIdL_IsoVL_PFJet30_v32, fragment.HLT_Ele12_CaloIdL_TrackIdL_IsoVL_PFJet30_v34, fragment.HLT_Ele14_eta2p5_IsoVVVL_Gsf_PFHT200_PNetBTag0p53_v9, fragment.HLT_Ele23_CaloIdL_TrackIdL_IsoVL_PFJet30_v34, fragment.HLT_Ele8_CaloIdM_TrackIdM_PFJet30_v34, fragment.HLT_Ele17_CaloIdM_TrackIdM_PFJet30_v32, fragment.HLT_Ele23_CaloIdM_TrackIdM_PFJet30_v34, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_PFJet165_v34, fragment.HLT_Ele115_CaloIdVT_GsfTrkIdT_v28, fragment.HLT_Ele135_CaloIdVT_GsfTrkIdT_v21, fragment.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_v25, fragment.HLT_PFHT400_SixPFJet32_v25, fragment.HLT_PFHT400_SixPFJet32_PNet2BTagMean0p50_v13, fragment.HLT_PFHT450_SixPFJet36_v24, fragment.HLT_PFHT450_SixPFJet36_PNetBTag0p35_v13, fragment.HLT_PFHT400_FivePFJet_120_120_60_30_30_v10, fragment.HLT_PFHT350_v35, fragment.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT350_v14, fragment.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT380_v14, fragment.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT400_v14, fragment.HLT_ECALHT800_v22, fragment.HLT_DiSC30_18_EIso_AND_HE_Mass70_v25, fragment.HLT_Photon20_HoverELoose_v21, fragment.HLT_Photon30_HoverELoose_v21, fragment.HLT_L1_CDC_SingleMu_3_er1p2_TOP120_DPHI2p618_3p142_v10, fragment.HLT_CDC_L2cosmic_10_er1p0_v11, fragment.HLT_CDC_L2cosmic_5p5_er1p0_v11, fragment.HLT_Photon60_R9Id90_HE10_IsoM_EBOnly_PFJetsMJJ300DEta3_v13, fragment.HLT_Photon75_R9Id90_HE10_IsoM_EBOnly_PFJetsMJJ300DEta3_v21, fragment.HLT_Mu18_Mu9_SameSign_v20, fragment.HLT_DoubleMu2_Jpsi_DoubleTrk1_Phi1p05_v22, fragment.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_v26, fragment.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_Mass2p0_v10, fragment.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_Mass2p0_noDCA_v10, fragment.HLT_TripleMu_5_3_3_Mass3p8_DCA_v19, fragment.HLT_QuadPFJet103_88_75_15_v21, fragment.HLT_QuadPFJet105_88_76_15_v21, fragment.HLT_QuadPFJet111_90_80_15_v21, fragment.HLT_Diphoton30_18_R9IdL_AND_HE_AND_IsoCaloId_v14, fragment.HLT_Diphoton30_18_R9IdL_AND_HE_AND_IsoCaloId_Mass55_v14, fragment.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Tight_eta2p3_CrossL1_v11, fragment.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Medium_eta2p3_CrossL1_v11, fragment.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Loose_eta2p3_CrossL1_v11, fragment.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_PNet3BTag_4p3_v9, fragment.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_PNet3BTag_2p0_v9, fragment.HLT_PFHT400_FivePFJet_120_120_60_30_30_PNet2BTag_5p6_v10, fragment.HLT_PFHT400_FivePFJet_120_120_60_30_30_PNet2BTag_4p3_v10, fragment.HLT_QuadPFJet103_88_75_15_PNetBTag_0p4_VBF2_v10, fragment.HLT_QuadPFJet103_88_75_15_PNet2BTag_0p4_0p12_VBF1_v10, fragment.HLT_QuadPFJet105_88_76_15_PNetBTag_0p4_VBF2_v10, fragment.HLT_QuadPFJet105_88_76_15_PNet2BTag_0p4_0p12_VBF1_v10, fragment.HLT_QuadPFJet111_90_80_15_PNetBTag_0p4_VBF2_v10, fragment.HLT_QuadPFJet111_90_80_15_PNet2BTag_0p4_0p12_VBF1_v10, fragment.HLT_PFHT250_QuadPFJet25_v10, fragment.HLT_PFHT250_QuadPFJet25_PNet2BTagMean0p55_v10, fragment.HLT_PFHT250_QuadPFJet25_PNet1BTag0p20_PNet1Tauh0p50_v10, fragment.HLT_PFHT250_QuadPFJet30_PNet2BTagMean0p55_v10, fragment.HLT_PFHT250_QuadPFJet30_PNet1BTag0p20_PNet1Tauh0p50_v10, fragment.HLT_PFHT280_QuadPFJet30_PNet1BTag0p20_PNet1Tauh0p50_v10, fragment.HLT_PFHT280_QuadPFJet30_v13, fragment.HLT_PFHT280_QuadPFJet30_PNet2BTagMean0p55_v13, fragment.HLT_PFHT280_QuadPFJet30_PNet2BTagMean0p60_v13, fragment.HLT_PFHT280_QuadPFJet35_PNet2BTagMean0p60_v13, fragment.HLT_PFHT340_QuadPFJet70_50_40_40_PNet2BTagMean0p70_v14, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_v13, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_QuadPFJet30_v13, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_QuadPFJet30_PNet2BTagMean0p55_v13, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PNet2BTagMean0p50_v13, fragment.HLT_QuadPFJet100_88_70_30_v14, fragment.HLT_QuadPFJet105_88_75_30_v13, fragment.HLT_QuadPFJet111_90_80_30_v13, fragment.HLT_QuadPFJet100_88_70_30_PNet1CvsAll0p5_VBF3Tight_v14, fragment.HLT_QuadPFJet105_88_75_30_PNet1CvsAll0p5_VBF3Tight_v14, fragment.HLT_QuadPFJet111_90_80_30_PNet1CvsAll0p6_VBF3Tight_v14, fragment.HLT_AK8PFJet220_SoftDropMass40_v17, fragment.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p50_v13, fragment.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p53_v13, fragment.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p55_v13, fragment.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p60_v13, fragment.HLT_AK8PFJet230_SoftDropMass40_v17, fragment.HLT_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_AK8PFJet230_SoftDropMass40_PNetTauTau0p03_v13, fragment.HLT_AK8PFJet230_SoftDropMass40_PNetTauTau0p05_v13, fragment.HLT_AK8PFJet250_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_AK8PFJet250_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_AK8PFJet250_SoftDropMass40_PNetTauTau0p03_v13, fragment.HLT_AK8PFJet250_SoftDropMass40_PNetTauTau0p05_v13, fragment.HLT_AK8PFJet275_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_AK8PFJet275_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_AK8PFJet275_SoftDropMass40_PNetTauTau0p03_v13, fragment.HLT_AK8PFJet275_SoftDropMass40_PNetTauTau0p05_v13, fragment.HLT_AK8PFJet275_Nch45_v10, fragment.HLT_AK8PFJet275_Nch40_v10, fragment.HLT_IsoMu50_AK8PFJet220_SoftDropMass40_v16, fragment.HLT_IsoMu50_AK8PFJet220_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_v16, fragment.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet220_SoftDropMass40_v16, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet220_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_v16, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, fragment.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_DoubleAK4PFJet60_30_v14, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_DoubleAK4PFJet60_30_PNet2BTagMean0p50_v14, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_v10, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_v10, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_PNet2BTagMean0p55_v10, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_PNet1BTag0p20_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Medium_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Tight_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_PFJet60_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_PFJet75_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Tight_eta2p3_CrossL1_ETau_Monitoring_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Medium_eta2p3_CrossL1_ETau_Monitoring_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Loose_eta2p3_CrossL1_ETau_Monitoring_v10, fragment.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Tight_eta2p3_CrossL1_v10, fragment.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Medium_eta2p3_CrossL1_v10, fragment.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Loose_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet20_eta2p2_SingleL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet45_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PFHT250_v10, fragment.HLT_IsoMu24_eta2p1_PFHT250_QuadPFJet25_v10, fragment.HLT_IsoMu24_eta2p1_PFHT250_QuadPFJet25_PNet1Tauh0p50_v10, fragment.HLT_IsoMu24_eta2p1_SinglePFJet25_PNet1Tauh0p50_v10, fragment.HLT_DoublePNetTauhPFJet30_Medium_L2NN_eta2p3_v10, fragment.HLT_DoublePNetTauhPFJet30_Tight_L2NN_eta2p3_v10, fragment.HLT_DoublePNetTauhPFJet26_L2NN_eta2p3_PFJet60_v10, fragment.HLT_DoublePNetTauhPFJet26_L2NN_eta2p3_PFJet75_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Loose_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Medium_L2NN_eta2p3_CrossL1_v10, fragment.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Tight_L2NN_eta2p3_CrossL1_v10, fragment.HLT_SinglePNetTauhPFJet130_Loose_L2NN_eta2p3_v10, fragment.HLT_SinglePNetTauhPFJet130_Medium_L2NN_eta2p3_v10, fragment.HLT_SinglePNetTauhPFJet130_Tight_L2NN_eta2p3_v10, fragment.HLT_DoubleL2Mu10NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v16, fragment.HLT_DoubleL2Mu12NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_DoubleL2Mu14NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_DoubleL3Mu16_10NoVtx_DxyMin0p01cm_v14, fragment.HLT_DoubleL3Mu18_10NoVtx_DxyMin0p01cm_v13, fragment.HLT_DoubleL3Mu20_10NoVtx_DxyMin0p01cm_v13, fragment.HLT_L2Mu10NoVtx_2Cha_v10, fragment.HLT_L2Mu10NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_L3Mu10NoVtx_v13, fragment.HLT_L3Mu10NoVtx_DxyMin0p01cm_v13, fragment.HLT_DoubleL2Mu_L3Mu16NoVtx_VetoL3Mu0DxyMax0p1cm_v13, fragment.HLT_DoubleL2Mu_L3Mu18NoVtx_VetoL3Mu0DxyMax0p1cm_v13, fragment.HLT_DoubleL2Mu10NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_DoubleL2Mu12NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_L2Mu10NoVtx_2Cha_CosmicSeed_v10, fragment.HLT_L2Mu10NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, fragment.HLT_DoubleL3dTksMu16_10NoVtx_DxyMin0p01cm_v14, fragment.HLT_L2Mu50NoVtx_3Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v8, fragment.HLT_L2Mu50NoVtx_3Cha_VetoL3Mu0DxyMax1cm_v8, fragment.HLT_L3Mu30NoVtx_DxyMin0p01cm_v6, fragment.HLT_L3Mu50NoVtx_DxyMin0p01cm_v6, fragment.HLT_L3dTksMu10_NoVtx_DxyMin0p01cm_v14, fragment.HLT_Mu20NoFiltersNoVtxDisplaced_Photon20_CaloCustomId_v14, fragment.HLT_DisplacedMu24_MediumChargedIsoDisplacedPFTauHPS24_v12, fragment.HLT_Photon34_R9Id90_CaloIdL_IsoL_DisplacedIdL_MediumChargedIsoDisplacedPFTauHPS34_v12, fragment.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS32_Trk1_eta2p1_v17, fragment.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS36_Trk1_eta2p1_v12, fragment.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS32_Trk1_eta2p1_noDxy_v12, fragment.HLT_IsoMu27_MediumChargedIsoDisplacedPFTauHPS24_eta2p1_SingleL1_v12, fragment.HLT_HT350_DelayedJet40_SingleDelay1p5To3p5nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay1p6To3p5nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay1p75To3p5nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay3nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay3p25nsInclusive_v9, fragment.HLT_HT350_DelayedJet40_SingleDelay3p5nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay0p5nsInclusive_v11, fragment.HLT_HT430_DelayedJet40_SingleDelay1nsInclusive_v11, fragment.HLT_HT430_DelayedJet40_SingleDelay1To1p5nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay1p1To1p6nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay1p25To1p75nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay1p5nsInclusive_v11, fragment.HLT_HT430_DelayedJet40_SingleDelay2nsInclusive_v13, fragment.HLT_HT430_DelayedJet40_SingleDelay2p25nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay2p5nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_SingleDelay0p5nsTrackless_v12, fragment.HLT_HT430_DelayedJet40_SingleDelay1nsTrackless_v14, fragment.HLT_HT430_DelayedJet40_SingleDelay1p25nsTrackless_v10, fragment.HLT_HT430_DelayedJet40_SingleDelay1p5nsTrackless_v10, fragment.HLT_HT430_DelayedJet40_DoubleDelay0p5nsInclusive_v12, fragment.HLT_HT430_DelayedJet40_DoubleDelay1nsInclusive_v13, fragment.HLT_HT430_DelayedJet40_DoubleDelay1p25nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_DoubleDelay1p5nsInclusive_v9, fragment.HLT_HT430_DelayedJet40_DoubleDelay0p5nsTrackless_v14, fragment.HLT_HT430_DelayedJet40_DoubleDelay0p75nsTrackless_v10, fragment.HLT_HT430_DelayedJet40_DoubleDelay1nsTrackless_v10, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p5To4nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p6To4nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p75To4nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay3p5nsInclusive_v11, fragment.HLT_L1Tau_DelayedJet40_SingleDelay3p75nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay4nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p5nsTrackless_v12, fragment.HLT_L1Tau_DelayedJet40_SingleDelay2p75nsTrackless_v10, fragment.HLT_L1Tau_DelayedJet40_SingleDelay3nsTrackless_v10, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay0p75nsInclusive_v11, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p25nsInclusive_v11, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p5nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p75nsInclusive_v9, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay0p5nsTrackless_v12, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1nsTrackless_v12, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p25nsTrackless_v10, fragment.HLT_L1Tau_DelayedJet40_DoubleDelay1p5nsTrackless_v10, fragment.HLT_L1Mu6HT240_v10, fragment.HLT_Mu6HT240_DisplacedDijet30_Inclusive1PtrkShortSig5_DisplacedLoose_v14, fragment.HLT_Mu6HT240_DisplacedDijet35_Inclusive0PtrkShortSig5_v14, fragment.HLT_Mu6HT240_DisplacedDijet35_Inclusive1PtrkShortSig5_DisplacedLoose_v14, fragment.HLT_Mu6HT240_DisplacedDijet40_Inclusive0PtrkShortSig5_v14, fragment.HLT_Mu6HT240_DisplacedDijet40_Inclusive1PtrkShortSig5_DisplacedLoose_v14, fragment.HLT_Mu6HT240_DisplacedDijet45_Inclusive0PtrkShortSig5_v14, fragment.HLT_Mu6HT240_DisplacedDijet50_Inclusive0PtrkShortSig5_v14, fragment.HLT_HT350_v9, fragment.HLT_HT425_v21, fragment.HLT_HT360_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT360_DisplacedDijet45_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT390_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT390_DisplacedDijet45_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT390eta2p0_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, fragment.HLT_HT430_DisplacedDijet40_Inclusive1PtrkShortSig5_v14, fragment.HLT_HT400_DisplacedDijet40_DisplacedTrack_v26, fragment.HLT_HT430_DisplacedDijet40_DisplacedTrack_v26, fragment.HLT_HT550_DisplacedDijet60_Inclusive_v26, fragment.HLT_HT650_DisplacedDijet60_Inclusive_v26, fragment.HLT_CaloMET60_DTCluster50_v13, fragment.HLT_CaloMET60_DTClusterNoMB1S50_v13, fragment.HLT_L1MET_DTCluster50_v13, fragment.HLT_L1MET_DTClusterNoMB1S50_v13, fragment.HLT_CscCluster_Loose_v11, fragment.HLT_CscCluster_Medium_v11, fragment.HLT_CscCluster_Tight_v11, fragment.HLT_CscCluster50_Photon20Unseeded_v5, fragment.HLT_CscCluster50_Photon30Unseeded_v5, fragment.HLT_CscCluster100_Ele5_v7, fragment.HLT_CscCluster100_Mu5_v10, fragment.HLT_CscCluster100_PNetTauhPFJet10_Loose_v10, fragment.HLT_CscCluster150_DisplacedSingleJet30_Inclusive1PtrkShortSig5_v3, fragment.HLT_CscCluster150_DisplacedSingleJet35_Inclusive1PtrkShortSig5_v3, fragment.HLT_CscCluster150_DisplacedSingleJet40_Inclusive1PtrkShortSig5_v3, fragment.HLT_DoubleCscCluster75_v8, fragment.HLT_IsoTrk200_L1SingleMuShower_v8, fragment.HLT_IsoTrk400_L1SingleMuShower_v8, fragment.HLT_DoubleCscCluster100_v8, fragment.HLT_L1CSCShower_DTCluster50_v11, fragment.HLT_L1CSCShower_DTCluster75_v11, fragment.HLT_PFMET105_IsoTrk50_v17, fragment.HLT_L1SingleLLPJet_v8, fragment.HLT_L1SingleMuShower_v1, fragment.HLT_HT170_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, fragment.HLT_HT200_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, fragment.HLT_HT200_L1SingleLLPJet_DisplacedDijet60_DisplacedTrack_v14, fragment.HLT_HT270_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, fragment.HLT_HT200_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v14, fragment.HLT_HT240_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11, fragment.HLT_HT280_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11, fragment.HLT_HT320_L1SingleLLPJet_DisplacedDijet60_Inclusive_v14, fragment.HLT_HT420_L1SingleLLPJet_DisplacedDijet60_Inclusive_v14, fragment.HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay1nsTrackless_v14, fragment.HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay2nsInclusive_v14, fragment.HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay0p5nsTrackless_v14, fragment.HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay1nsInclusive_v14, fragment.HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p7_v10, fragment.HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p8_v10, fragment.HLT_DiPhoton10Time1ns_v11, fragment.HLT_DiPhoton10Time1p2ns_v11, fragment.HLT_DiPhoton10Time1p4ns_v11, fragment.HLT_DiPhoton10Time1p6ns_v11, fragment.HLT_DiPhoton10Time1p8ns_v11, fragment.HLT_DiPhoton10Time2ns_v11, fragment.HLT_DiPhoton10_CaloIdL_v11, fragment.HLT_DiphotonMVA14p25_Low_Mass60_v1, fragment.HLT_DiphotonMVA14p25_Medium_Mass60_v1, fragment.HLT_DiphotonMVA14p25_High_Mass60_v1, fragment.HLT_DiphotonMVA14p25_TightLow_Mass60_v1, fragment.HLT_DiphotonMVA14p25_TightMedium_Mass60_v1, fragment.HLT_DiphotonMVA14p25_TightHigh_Mass60_v1, fragment.HLT_Diphoton15_10_EBEB_TightID_ECALTrackIsoDr0p2_v3, fragment.HLT_Diphoton15_12_EBEB_TightID_ECALTrackIsoDr0p2_v3, fragment.HLT_Diphoton15_10_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v3, fragment.HLT_Diphoton15_12_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v3, fragment.HLT_Dielectron12_5_EBEB_TightID_ECALTrackIsoDr0p2_v4, fragment.HLT_Dielectron12_5_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v4, fragment.HLT_DoubleEle6p5_eta1p22_mMax6_v13, fragment.HLT_DoubleEle8_eta1p22_mMax6_v13, fragment.HLT_DoubleEle10_eta1p22_mMax6_v13, fragment.HLT_SingleEle8_v12, fragment.HLT_SingleEle8_SingleEGL1_v12, fragment.HLT_Diphoton20_14_eta1p5_R9IdL_AND_HE_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton20_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton22_14_eta1p5_R9IdL_AND_HE_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton22_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton24_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, fragment.HLT_Diphoton24_16_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, fragment.HLT_Mu50_L1SingleMuShower_v15, fragment.HLT_IsoMu24_OneProng32_v13, fragment.HLT_Photon32_OneProng32_M50To105_v14, fragment.HLT_VBF_DiPFJet125_45_Mjj1050_v12, fragment.HLT_VBF_DiPFJet125_45_Mjj1150_v4, fragment.HLT_VBF_DiPFJet125_45_Mjj1250_v4, fragment.HLT_VBF_DiPFJet75_45_Mjj800_DiPFJet60_v10, fragment.HLT_VBF_DiPFJet75_45_Mjj900_DiPFJet60_v4, fragment.HLT_VBF_DiPFJet75_45_Mjj1000_DiPFJet60_v4, fragment.HLT_VBF_DiPFJet80_45_Mjj650_PFMETNoMu85_v10, fragment.HLT_VBF_DiPFJet80_45_Mjj750_PFMETNoMu85_v10, fragment.HLT_VBF_DiPFJet80_45_Mjj850_PFMETNoMu85_v4, fragment.HLT_VBF_DiPFJet95_45_Mjj750_Mu3_TrkIsoVVL_v10, fragment.HLT_VBF_DiPFJet95_45_Mjj850_Mu3_TrkIsoVVL_v10, fragment.HLT_VBF_DiPFJet95_45_Mjj950_Mu3_TrkIsoVVL_v4, fragment.HLT_VBF_DiPFJet50_Mjj650_Photon22_v10, fragment.HLT_VBF_DiPFJet50_Mjj750_Photon22_v10, fragment.HLT_VBF_DiPFJet50_Mjj850_Photon22_v4, fragment.HLT_VBF_DiPFJet50_Mjj600_Ele22_eta2p1_WPTight_Gsf_v11, fragment.HLT_VBF_DiPFJet50_Mjj700_Ele22_eta2p1_WPTight_Gsf_v5, fragment.HLT_VBF_DiPFJet50_Mjj800_Ele22_eta2p1_WPTight_Gsf_v5, fragment.HLT_VBF_DiPFJet115_40_Mjj850_DoublePNetTauhPFJet20_eta2p3_v4, fragment.HLT_VBF_DiPFJet115_40_Mjj1000_DoublePNetTauhPFJet20_eta2p3_v4, fragment.HLT_VBF_DiPFJet115_40_Mjj1100_DoublePNetTauhPFJet20_eta2p3_v4, fragment.HLT_VBF_DiPFJet115_40_Mjj1200_DoublePNetTauhPFJet20_eta2p3_v4, fragment.HLT_VBF_DiPFJet45_Mjj650_PNetTauhPFJet45_L2NN_eta2p3_v10, fragment.HLT_VBF_DiPFJet45_Mjj750_PNetTauhPFJet45_L2NN_eta2p3_v10, fragment.HLT_VBF_DiPFJet45_Mjj850_PNetTauhPFJet45_L2NN_eta2p3_v4, fragment.HLT_L1HT200_QuadPFJet20_PNet1BTag0p50_PNet1Tauh0p50_v4, fragment.HLT_L1HT200_QuadPFJet25_PNet1BTag0p50_PNet1Tauh0p50_v4, fragment.HLT_IsoMu24_eta2p1_L1HT200_v4, fragment.HLT_IsoMu24_eta2p1_L1HT200_QuadPFJet25_v4, fragment.HLT_IsoMu24_eta2p1_L1HT200_QuadPFJet25_PNet1Tauh0p50_v4, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_v4, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet20_v4, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet25_v4, fragment.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet25_PNet1BTag0p50_v4, fragment.HLT_PFJet200_TimeLtNeg2p5ns_v14, fragment.HLT_PFJet200_TimeGt2p5ns_v14, fragment.HLT_Photon50_TimeLtNeg2p5ns_v8, fragment.HLT_Photon50_TimeGt2p5ns_v8, fragment.HLT_PPSMaxTracksPerArm1_v10, fragment.HLT_PPSMaxTracksPerRP4_v10, fragment.HLT_PPSRandom_v1, fragment.HLT_TestData_v1, fragment.MC_ReducedIterativeTracking_v26, fragment.MC_AK4CaloJets_v21, fragment.MC_AK4CaloJetsFromPV_v21, fragment.MC_CaloHT_v20, fragment.MC_AK8CaloHT_v20, fragment.MC_CaloMHT_v20, fragment.MC_AK4PFJets_v33, fragment.MC_PFHT_v32, fragment.MC_AK8PFJets_v33, fragment.MC_AK8PFHT_v32, fragment.MC_CaloMET_v20, fragment.MC_CaloMET_JetIdCleaned_v21, fragment.MC_PFMET_v33, fragment.MC_PFMHT_v32, fragment.MC_AK4PFJetPNet_v9, fragment.MC_AK8PFJetPNet_v9, fragment.MC_Egamma_Open_v12, fragment.MC_Egamma_Open_Unseeded_v12, fragment.MC_Ele5_WPTight_Gsf_v23, fragment.MC_Ele15_Ele10_CaloIdL_TrackIdL_IsoVL_DZ_v29, fragment.MC_Diphoton10_10_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass10_v26, fragment.MC_DoubleEle5_CaloIdL_MW_v29, fragment.MC_IsoMu_v31, fragment.MC_DoubleMu_TrkIsoVVL_DZ_v27, fragment.MC_DoubleMuNoFiltersNoVtx_v20, fragment.MC_PFScouting_v10, fragment.HLT_L1AlwaysTrue_v1, fragment.HLT_L1AXOVVTight_v1, fragment.HLT_L1AXOVVVTight_v1, fragment.HLT_L1CICADA_VVTight_v1, fragment.HLT_L1CICADA_VVVTight_v1, fragment.HLT_L1CICADA_VVVVTight_v1, fragment.HLTriggerFinalPath, fragment.HLTAnalyzerEndpath, fragment.Dataset_AlCaHcalIsoTrk, fragment.Dataset_AlCaLowPtJet, fragment.Dataset_AlCaLumiPixelsCountsExpress, fragment.Dataset_AlCaLumiPixelsCountsPrompt, fragment.Dataset_AlCaP0, fragment.Dataset_AlCaPPSExpress, fragment.Dataset_AlCaPPSPrompt, fragment.Dataset_AlCaPhiSym, fragment.Dataset_BTagMu, fragment.Dataset_Commissioning, fragment.Dataset_Cosmics, fragment.Dataset_DQMGPUvsCPU, fragment.Dataset_DQMOnlineBeamspot, fragment.Dataset_DQMPPSRandom, fragment.Dataset_EGamma0, fragment.Dataset_EGamma1, fragment.Dataset_EGamma2, fragment.Dataset_EGamma3, fragment.Dataset_EcalLaser, fragment.Dataset_EphemeralHLTPhysics0, fragment.Dataset_EphemeralHLTPhysics1, fragment.Dataset_EphemeralHLTPhysics2, fragment.Dataset_EphemeralHLTPhysics3, fragment.Dataset_EphemeralHLTPhysics4, fragment.Dataset_EphemeralHLTPhysics5, fragment.Dataset_EphemeralHLTPhysics6, fragment.Dataset_EphemeralHLTPhysics7, fragment.Dataset_EphemeralZeroBias0, fragment.Dataset_EphemeralZeroBias1, fragment.Dataset_EphemeralZeroBias2, fragment.Dataset_EphemeralZeroBias3, fragment.Dataset_EphemeralZeroBias4, fragment.Dataset_EphemeralZeroBias5, fragment.Dataset_EphemeralZeroBias6, fragment.Dataset_EphemeralZeroBias7, fragment.Dataset_EventDisplay, fragment.Dataset_ExpressAlignment, fragment.Dataset_ExpressPhysics, fragment.Dataset_HLTMonitor, fragment.Dataset_HLTPhysics, fragment.Dataset_HcalNZS, fragment.Dataset_JetMET0, fragment.Dataset_JetMET1, fragment.Dataset_L1Accept, fragment.Dataset_MonteCarlo, fragment.Dataset_Muon0, fragment.Dataset_Muon1, fragment.Dataset_MuonEG, fragment.Dataset_NoBPTX, fragment.Dataset_OnlineMonitor, fragment.Dataset_ParkingDoubleMuonLowMass0, fragment.Dataset_ParkingDoubleMuonLowMass1, fragment.Dataset_ParkingDoubleMuonLowMass2, fragment.Dataset_ParkingDoubleMuonLowMass3, fragment.Dataset_ParkingDoubleMuonLowMass4, fragment.Dataset_ParkingDoubleMuonLowMass5, fragment.Dataset_ParkingDoubleMuonLowMass6, fragment.Dataset_ParkingDoubleMuonLowMass7, fragment.Dataset_ParkingHH0, fragment.Dataset_ParkingHH1, fragment.Dataset_ParkingLLP0, fragment.Dataset_ParkingLLP1, fragment.Dataset_ParkingSingleMuon0, fragment.Dataset_ParkingSingleMuon1, fragment.Dataset_ParkingSingleMuon2, fragment.Dataset_ParkingSingleMuon3, fragment.Dataset_ParkingSingleMuon4, fragment.Dataset_ParkingSingleMuon5, fragment.Dataset_ParkingSingleMuon6, fragment.Dataset_ParkingSingleMuon7, fragment.Dataset_ParkingSingleMuon8, fragment.Dataset_ParkingSingleMuon9, fragment.Dataset_ParkingSingleMuon10, fragment.Dataset_ParkingSingleMuon11, fragment.Dataset_ParkingSingleMuon12, fragment.Dataset_ParkingSingleMuon13, fragment.Dataset_ParkingSingleMuon14, fragment.Dataset_ParkingSingleMuon15, fragment.Dataset_ParkingVBF0, fragment.Dataset_ParkingVBF1, fragment.Dataset_ParkingVBF2, fragment.Dataset_ParkingVBF3, fragment.Dataset_ParkingVBF4, fragment.Dataset_ParkingVBF5, fragment.Dataset_ParkingVBF6, fragment.Dataset_ParkingVBF7, fragment.Dataset_ParkingAnomalyDetection, fragment.Dataset_RPCMonitor, fragment.Dataset_ScoutingPFMonitor, fragment.Dataset_ScoutingPF0, fragment.Dataset_ScoutingPF1, fragment.Dataset_Tau, fragment.Dataset_TestEnablesEcalHcal, fragment.Dataset_TestEnablesEcalHcalDQM, fragment.Dataset_ZeroBias, fragment.Dataset_TestDataRaw, fragment.Dataset_TestDataScouting, fragment.Dataset_EmittanceScan0, fragment.Dataset_EmittanceScan1, fragment.Dataset_EmittanceScan2, fragment.Dataset_EmittanceScan3, fragment.Dataset_EmittanceScan4, fragment.Dataset_EmittanceScan5, fragment.Dataset_DQMOnlineScouting, fragment.ScoutingPF0Output, fragment.ScoutingPF1Output, )) # dummify hltGetConditions in cff's diff --git a/HLTrigger/Configuration/python/HLT_HIon_cff.py b/HLTrigger/Configuration/python/HLT_HIon_cff.py index bd6f00d1879db..66082360de609 100644 --- a/HLTrigger/Configuration/python/HLT_HIon_cff.py +++ b/HLTrigger/Configuration/python/HLT_HIon_cff.py @@ -1,6 +1,6 @@ -# hltGetConfiguration /dev/CMSSW_15_0_0/HIon --cff --data --type HIon +# hltGetConfiguration /dev/CMSSW_15_1_0/HIon --cff --data --type HIon -# /dev/CMSSW_15_0_0/HIon/V114 (CMSSW_15_0_11) +# /dev/CMSSW_15_1_0/HIon/V10 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms @@ -9,7 +9,7 @@ fragment.load("Configuration.StandardSequences.Accelerators_cff") fragment.HLTConfigVersion = cms.PSet( - tableName = cms.string("/dev/CMSSW_15_0_0/HIon/V114") + tableName = cms.string("/dev/CMSSW_15_1_0/HIon/V10") ) fragment.HLTGroupedCkfTrajectoryBuilderP5 = cms.PSet( @@ -9425,7 +9425,9 @@ fragment.CSCObjectMapESProducer = cms.ESProducer( "CSCObjectMapESProducer", appendToDataLabel = cms.string( "" ) ) -fragment.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder" ) +fragment.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder", + appendToDataLabel = cms.string( "" ) +) fragment.CaloTowerConstituentsMapBuilder = cms.ESProducer( "CaloTowerConstituentsMapBuilder", MapFile = cms.untracked.string( "Geometry/CaloTopology/data/CaloTowerEEGeometric.map.gz" ), MapAuto = cms.untracked.bool( False ), @@ -9482,85 +9484,103 @@ appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterial" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMf" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOppositeForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositePropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStepOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) fragment.PropagatorWithMaterialForLoopers = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 4.0 ), ComponentName = cms.string( "PropagatorWithMaterialForLoopers" ), Mass = cms.double( 0.1396 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 4.0 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.PropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStep" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) fragment.SiPixelTemplateStoreESProducer = cms.ESProducer( "SiPixelTemplateStoreESProducer", appendToDataLabel = cms.string( "" ) @@ -9699,7 +9719,9 @@ ), timeThresh = cms.double( 2.0 ) ) -fragment.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP" ) +fragment.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP", + appendToDataLabel = cms.string( "" ) +) fragment.hcalDDDRecConstants = cms.ESProducer( "HcalDDDRecConstantsESModule", appendToDataLabel = cms.string( "" ) ) @@ -10000,13 +10022,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPBwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPBwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPChi2ChargeLooseMeasurementEstimator16 = cms.ESProducer( "Chi2ChargeMeasurementEstimatorESProducer", MaxChi2 = cms.double( 16.0 ), @@ -10382,13 +10406,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPFwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPFwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPGlobalDetLayerGeometry = cms.ESProducer( "GlobalDetLayerGeometryESProducer", ComponentName = cms.string( "hltESPGlobalDetLayerGeometry" ), @@ -10962,13 +10988,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPRungeKuttaTrackerPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPRungeKuttaTrackerPropagator" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( True ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPSiPixelCablingSoA = cms.ESProducer( "SiPixelCablingSoAESProducer@alpaka", CablingMapLabel = cms.string( "" ), @@ -11067,7 +11095,8 @@ mTIB_P0 = cms.double( -0.742 ), mTID_P1 = cms.double( 0.433 ), mTID_P0 = cms.double( -1.427 ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPTTRHBWithTrackAngle = cms.ESProducer( "TkTransientTrackingRecHitBuilderESProducer", ComponentName = cms.string( "hltESPTTRHBWithTrackAngle" ), @@ -11325,7 +11354,9 @@ UseQualityInfo = cms.bool( False ), appendToDataLabel = cms.string( "" ) ) -fragment.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer" ) +fragment.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer", + appendToDataLabel = cms.string( "" ) +) fragment.siStripBackPlaneCorrectionDepESProducer = cms.ESProducer( "SiStripBackPlaneCorrectionDepESProducer", LatencyRecord = cms.PSet( label = cms.untracked.string( "" ), @@ -11338,7 +11369,8 @@ BackPlaneCorrectionDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripBackPlaneCorrectionRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.siStripLorentzAngleDepESProducer = cms.ESProducer( "SiStripLorentzAngleDepESProducer", LatencyRecord = cms.PSet( @@ -11352,7 +11384,8 @@ LorentzAngleDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripLorentzAngleRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.zdcTopologyEP = cms.ESProducer( "ZdcTopologyEP", appendToDataLabel = cms.string( "" ) @@ -11525,9 +11558,9 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -12192,14 +12225,22 @@ fragment.hltSiPixelClustersPPOnAASoA = cms.EDProducer( "SiPixelRawToClusterHIonPhase1@alpaka", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 1000 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) @@ -12229,6 +12270,7 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltSiPixelRecHitsPPOnAA = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaHIonPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsPPOnAASoA" ), src = cms.InputTag( "hltSiPixelClustersPPOnAA" ) ) @@ -12238,14 +12280,22 @@ fragment.hltSiPixelClustersPPOnAASoASerialSync = cms.EDProducer( "alpaka_serial_sync::SiPixelRawToClusterHIonPhase1", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 1000 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ) ) fragment.hltSiPixelClustersPPOnAASerialSync = cms.EDProducer( "SiPixelDigisClustersFromSoAAlpakaHIonPhase1", @@ -12273,50 +12323,59 @@ CPE = cms.string( "PixelCPEFastParamsHIonPhase1" ) ) fragment.hltSiPixelRecHitsPPOnAASerialSync = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaHIonPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsPPOnAASoASerialSync" ), src = cms.InputTag( "hltSiPixelClustersPPOnAASerialSync" ) ) fragment.hltPixelTracksPPOnAASoA = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaHIonPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsPPOnAASoA" ), - CPE = cms.string( "PixelCPEFastParamsHIonPhase1" ), - ptmin = cms.double( 0.8999999761581421 ), - CAThetaCutBarrel = cms.double( 0.0010000000949949026 ), - CAThetaCutForward = cms.double( 0.002000000026077032 ), - hardCurvCut = cms.double( 0.03284072249589491 ), - dcaCutInnerTriplet = cms.double( 0.05000000596046448 ), - dcaCutOuterTriplet = cms.double( 0.1 ), + cellZ0Cut = cms.double( 8.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 36 ), + minYsizeB2 = cms.int32( 28 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "3145728" ), + maxNumberOfTuples = cms.string( "262144" ), + avgHitsPerTrack = cms.double( 5.0 ), + avgCellsPerHit = cms.double( 40.0 ), + avgCellsPerCell = cms.double( 0.5 ), + avgTracksPerCell = cms.double( 0.5 ), + ptmin = cms.double( 0.899999976158 ), + hardCurvCut = cms.double( 0.0328407224959 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 4 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 3145728 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 8.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), - chi2Coeff = cms.vdouble( 0.9, 1.8 ), - chi2Scale = cms.double( 1.8 ), - tripletMinPt = cms.double( 0.1 ), tripletMaxTip = cms.double( 0.3 ), - tripletMaxZip = cms.double( 12.0 ), - quadrupletMinPt = cms.double( 0.1 ), + chi2Scale = cms.double( 1.8 ), quadrupletMaxTip = cms.double( 0.5 ), - quadrupletMaxZip = cms.double( 12.0 ) + quadrupletMinPt = cms.double( 0.1 ), + quadrupletMaxZip = cms.double( 12.0 ), + tripletMaxZip = cms.double( 12.0 ), + tripletMinPt = cms.double( 0.1 ), + chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 36 ), - minYsizeB2 = cms.int32( 28 ), - phiCuts = cms.vint32( 522, 730, 730, 522, 626, 626, 522, 522, 626, 626, 626, 522, 522, 522, 522, 522, 522, 522, 522 ) + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.001, 0.001, 0.001, 0.001, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.05, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 522, 730, 730, 522, 626, 626, 522, 522, 626, 626, 626, 522, 522, 522, 522, 522, 522, 522, 522 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) fragment.hltPixelTracksPPOnAA = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaHIonPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -12354,45 +12413,53 @@ ) fragment.hltPixelTracksPPOnAASoASerialSync = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaHIonPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsPPOnAASoASerialSync" ), - CPE = cms.string( "PixelCPEFastParamsHIonPhase1" ), - ptmin = cms.double( 0.8999999761581421 ), - CAThetaCutBarrel = cms.double( 0.0010000000949949026 ), - CAThetaCutForward = cms.double( 0.002000000026077032 ), - hardCurvCut = cms.double( 0.03284072249589491 ), - dcaCutInnerTriplet = cms.double( 0.05000000596046448 ), - dcaCutOuterTriplet = cms.double( 0.1 ), + cellZ0Cut = cms.double( 8.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 36 ), + minYsizeB2 = cms.int32( 28 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "3145728" ), + maxNumberOfTuples = cms.string( "262144" ), + avgHitsPerTrack = cms.double( 5.0 ), + avgCellsPerHit = cms.double( 40.0 ), + avgCellsPerCell = cms.double( 0.5 ), + avgTracksPerCell = cms.double( 0.5 ), + ptmin = cms.double( 0.899999976158 ), + hardCurvCut = cms.double( 0.0328407224959 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 4 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 3145728 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 8.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), - chi2Coeff = cms.vdouble( 0.9, 1.8 ), - chi2Scale = cms.double( 1.8 ), - tripletMinPt = cms.double( 0.1 ), tripletMaxTip = cms.double( 0.3 ), - tripletMaxZip = cms.double( 12.0 ), - quadrupletMinPt = cms.double( 0.1 ), + chi2Scale = cms.double( 1.8 ), quadrupletMaxTip = cms.double( 0.5 ), - quadrupletMaxZip = cms.double( 12.0 ) + quadrupletMinPt = cms.double( 0.1 ), + quadrupletMaxZip = cms.double( 12.0 ), + tripletMaxZip = cms.double( 12.0 ), + tripletMinPt = cms.double( 0.1 ), + chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 36 ), - minYsizeB2 = cms.int32( 28 ), - phiCuts = cms.vint32( 522, 730, 730, 522, 626, 626, 522, 522, 626, 626, 626, 522, 522, 522, 522, 522, 522, 522, 522 ) + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.001, 0.001, 0.001, 0.001, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.05, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 522, 730, 730, 522, 626, 626, 522, 522, 626, 626, 626, 522, 522, 522, 522, 522, 522, 522, 522 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) fragment.hltPixelTracksPPOnAASerialSync = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaHIonPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -12542,9 +12609,9 @@ shouldRunTimingComputation = cms.bool( True ) ) fragment.hltEcalUncalibRecHitSerialSync = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -13410,7 +13477,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 107 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( True ) ) fragment.hltPreHIPhysics = cms.EDFilter( "HLTPrescaler", @@ -13436,7 +13503,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 4096 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( False ) ) fragment.hltL1sHIHcalNZS = cms.EDFilter( "HLTL1TSeed", @@ -13616,74 +13683,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -18055,74 +18122,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0E-99 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.1 ), HBThreshold2 = cms.double( 0.2 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0E-99 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 11 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( True ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "" ), + hoInput = cms.InputTag( "" ), + ecalInputs = cms.VInputTag( ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 11 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -19645,7 +19712,7 @@ trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "" ), produceSeedingHitSets = cms.bool( True ), - produceIntermediateHitDoublets = cms.bool( True ), + produceIntermediateHitDoublets = cms.bool( False ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), putEmptyIfMaxElementReached = cms.bool( False ), @@ -19667,7 +19734,7 @@ trackingRegions = cms.InputTag( "hltEleSeedsTrackingRegionsPPOnAA" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -25591,7 +25658,7 @@ trackingRegions = cms.InputTag( "hltFullIter2PixelTrackingRegionsPPOnAAForDmeson" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter2PixelClusterCheckPPOnAAForDmeson" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -25795,7 +25862,7 @@ trackingRegions = cms.InputTag( "hltFullIter3PixelTrackingRegionsPPOnAA" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter3PixelClusterCheckPPOnAA" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -25994,7 +26061,7 @@ trackingRegions = cms.InputTag( "hltFullIter7MixedTrackingRegionsAPPOnAA" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter7MixedClusterCheckPPOnAA" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -26091,7 +26158,7 @@ trackingRegions = cms.InputTag( "hltFullIter7MixedTrackingRegionsBPPOnAA" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter7MixedClusterCheckPPOnAA" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -26689,7 +26756,7 @@ trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter9TobTecClusterCheckPPOnAA" ), produceSeedingHitSets = cms.bool( True ), - produceIntermediateHitDoublets = cms.bool( True ), + produceIntermediateHitDoublets = cms.bool( False ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), putEmptyIfMaxElementReached = cms.bool( False ), diff --git a/HLTrigger/Configuration/python/HLT_PIon_cff.py b/HLTrigger/Configuration/python/HLT_PIon_cff.py index 819073eb16e6b..4d40661e9be7c 100644 --- a/HLTrigger/Configuration/python/HLT_PIon_cff.py +++ b/HLTrigger/Configuration/python/HLT_PIon_cff.py @@ -1,6 +1,6 @@ -# hltGetConfiguration /dev/CMSSW_15_0_0/PIon --cff --data --type PIon +# hltGetConfiguration /dev/CMSSW_15_1_0/PIon --cff --data --type PIon -# /dev/CMSSW_15_0_0/PIon/V114 (CMSSW_15_0_11) +# /dev/CMSSW_15_1_0/PIon/V10 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms @@ -9,7 +9,7 @@ fragment.load("Configuration.StandardSequences.Accelerators_cff") fragment.HLTConfigVersion = cms.PSet( - tableName = cms.string("/dev/CMSSW_15_0_0/PIon/V114") + tableName = cms.string("/dev/CMSSW_15_1_0/PIon/V10") ) fragment.HLTGroupedCkfTrajectoryBuilderP5 = cms.PSet( @@ -1557,7 +1557,9 @@ fragment.CSCObjectMapESProducer = cms.ESProducer( "CSCObjectMapESProducer", appendToDataLabel = cms.string( "" ) ) -fragment.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder" ) +fragment.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder", + appendToDataLabel = cms.string( "" ) +) fragment.CaloTowerConstituentsMapBuilder = cms.ESProducer( "CaloTowerConstituentsMapBuilder", MapFile = cms.untracked.string( "Geometry/CaloTopology/data/CaloTowerEEGeometric.map.gz" ), MapAuto = cms.untracked.bool( False ), @@ -1614,85 +1616,103 @@ appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterial" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMf" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOppositeForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositePropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStepOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) fragment.PropagatorWithMaterialForLoopers = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 4.0 ), ComponentName = cms.string( "PropagatorWithMaterialForLoopers" ), Mass = cms.double( 0.1396 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 4.0 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.PropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStep" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) fragment.SiPixelTemplateStoreESProducer = cms.ESProducer( "SiPixelTemplateStoreESProducer", appendToDataLabel = cms.string( "" ) @@ -1831,7 +1851,9 @@ ), timeThresh = cms.double( 2.0 ) ) -fragment.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP" ) +fragment.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP", + appendToDataLabel = cms.string( "" ) +) fragment.hcalDDDRecConstants = cms.ESProducer( "HcalDDDRecConstantsESModule", appendToDataLabel = cms.string( "" ) ) @@ -2132,13 +2154,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPBwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPBwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPChi2ChargeLooseMeasurementEstimator16 = cms.ESProducer( "Chi2ChargeMeasurementEstimatorESProducer", MaxChi2 = cms.double( 16.0 ), @@ -2514,13 +2538,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPFwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPFwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPGlobalDetLayerGeometry = cms.ESProducer( "GlobalDetLayerGeometryESProducer", ComponentName = cms.string( "hltESPGlobalDetLayerGeometry" ), @@ -3094,13 +3120,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPRungeKuttaTrackerPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPRungeKuttaTrackerPropagator" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( True ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPSiPixelCablingSoA = cms.ESProducer( "SiPixelCablingSoAESProducer@alpaka", CablingMapLabel = cms.string( "" ), @@ -3199,7 +3227,8 @@ mTIB_P0 = cms.double( -0.742 ), mTID_P1 = cms.double( 0.433 ), mTID_P0 = cms.double( -1.427 ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPTTRHBWithTrackAngle = cms.ESProducer( "TkTransientTrackingRecHitBuilderESProducer", ComponentName = cms.string( "hltESPTTRHBWithTrackAngle" ), @@ -3457,7 +3486,9 @@ UseQualityInfo = cms.bool( False ), appendToDataLabel = cms.string( "" ) ) -fragment.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer" ) +fragment.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer", + appendToDataLabel = cms.string( "" ) +) fragment.siStripBackPlaneCorrectionDepESProducer = cms.ESProducer( "SiStripBackPlaneCorrectionDepESProducer", LatencyRecord = cms.PSet( label = cms.untracked.string( "" ), @@ -3470,7 +3501,8 @@ BackPlaneCorrectionDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripBackPlaneCorrectionRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.siStripLorentzAngleDepESProducer = cms.ESProducer( "SiStripLorentzAngleDepESProducer", LatencyRecord = cms.PSet( @@ -3484,7 +3516,8 @@ LorentzAngleDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripLorentzAngleRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.zdcTopologyEP = cms.ESProducer( "ZdcTopologyEP", appendToDataLabel = cms.string( "" ) @@ -3657,9 +3690,9 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -4321,14 +4354,22 @@ fragment.hltSiPixelClustersSoA = cms.EDProducer( "SiPixelRawToClusterPhase1@alpaka", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) @@ -4354,6 +4395,7 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltSiPixelRecHits = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), src = cms.InputTag( "hltSiPixelClusters" ) ) @@ -4402,14 +4444,22 @@ fragment.hltSiPixelClustersSoASerialSync = cms.EDProducer( "alpaka_serial_sync::SiPixelRawToClusterPhase1", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ) ) fragment.hltSiPixelClustersSerialSync = cms.EDProducer( "SiPixelDigisClustersFromSoAAlpakaPhase1", @@ -4433,36 +4483,38 @@ CPE = cms.string( "PixelCPEFastParams" ) ) fragment.hltSiPixelRecHitsSerialSync = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), src = cms.InputTag( "hltSiPixelClustersSerialSync" ) ) fragment.hltPixelTracksSoA = cms.EDProducer( "CAHitNtupletAlpakaPhase1@alpaka", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -4474,9 +4526,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltPixelTracks = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", @@ -4516,31 +4575,32 @@ ) fragment.hltPixelTracksSoASerialSync = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -4552,9 +4612,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ) + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) fragment.hltPixelTracksSerialSync = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -4704,9 +4771,9 @@ shouldRunTimingComputation = cms.bool( True ) ) fragment.hltEcalUncalibRecHitSerialSync = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -5389,7 +5456,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 4096 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( False ) ) fragment.hltL1sHcalNZS = cms.EDFilter( "HLTL1TSeed", @@ -5434,7 +5501,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 107 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( True ) ) fragment.hltPrePhysics = cms.EDFilter( "HLTPrescaler", @@ -5466,74 +5533,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) diff --git a/HLTrigger/Configuration/python/HLT_PRef_cff.py b/HLTrigger/Configuration/python/HLT_PRef_cff.py index d2853b1879b6c..7e5e17c4b5918 100644 --- a/HLTrigger/Configuration/python/HLT_PRef_cff.py +++ b/HLTrigger/Configuration/python/HLT_PRef_cff.py @@ -1,6 +1,6 @@ -# hltGetConfiguration /dev/CMSSW_15_0_0/PRef --cff --data --type PRef +# hltGetConfiguration /dev/CMSSW_15_1_0/PRef --cff --data --type PRef -# /dev/CMSSW_15_0_0/PRef/V114 (CMSSW_15_0_11) +# /dev/CMSSW_15_1_0/PRef/V10 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms @@ -9,7 +9,7 @@ fragment.load("Configuration.StandardSequences.Accelerators_cff") fragment.HLTConfigVersion = cms.PSet( - tableName = cms.string("/dev/CMSSW_15_0_0/PRef/V114") + tableName = cms.string("/dev/CMSSW_15_1_0/PRef/V10") ) fragment.HLTGroupedCkfTrajectoryBuilderP5 = cms.PSet( @@ -2320,7 +2320,9 @@ fragment.CSCObjectMapESProducer = cms.ESProducer( "CSCObjectMapESProducer", appendToDataLabel = cms.string( "" ) ) -fragment.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder" ) +fragment.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder", + appendToDataLabel = cms.string( "" ) +) fragment.CaloTowerConstituentsMapBuilder = cms.ESProducer( "CaloTowerConstituentsMapBuilder", MapFile = cms.untracked.string( "Geometry/CaloTopology/data/CaloTowerEEGeometric.map.gz" ), MapAuto = cms.untracked.bool( False ), @@ -2377,85 +2379,103 @@ appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterial" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMf" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOppositeForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositePropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStepOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) fragment.PropagatorWithMaterialForLoopers = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 4.0 ), ComponentName = cms.string( "PropagatorWithMaterialForLoopers" ), Mass = cms.double( 0.1396 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 4.0 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.PropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStep" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) fragment.SiPixelTemplateStoreESProducer = cms.ESProducer( "SiPixelTemplateStoreESProducer", appendToDataLabel = cms.string( "" ) @@ -2594,7 +2614,9 @@ ), timeThresh = cms.double( 2.0 ) ) -fragment.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP" ) +fragment.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP", + appendToDataLabel = cms.string( "" ) +) fragment.hcalDDDRecConstants = cms.ESProducer( "HcalDDDRecConstantsESModule", appendToDataLabel = cms.string( "" ) ) @@ -2895,13 +2917,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPBwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPBwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPChi2ChargeLooseMeasurementEstimator16 = cms.ESProducer( "Chi2ChargeMeasurementEstimatorESProducer", MaxChi2 = cms.double( 16.0 ), @@ -3277,13 +3301,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPFwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPFwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPGlobalDetLayerGeometry = cms.ESProducer( "GlobalDetLayerGeometryESProducer", ComponentName = cms.string( "hltESPGlobalDetLayerGeometry" ), @@ -3857,13 +3883,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPRungeKuttaTrackerPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPRungeKuttaTrackerPropagator" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( True ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPSiPixelCablingSoA = cms.ESProducer( "SiPixelCablingSoAESProducer@alpaka", CablingMapLabel = cms.string( "" ), @@ -3962,7 +3990,8 @@ mTIB_P0 = cms.double( -0.742 ), mTID_P1 = cms.double( 0.433 ), mTID_P0 = cms.double( -1.427 ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPTTRHBWithTrackAngle = cms.ESProducer( "TkTransientTrackingRecHitBuilderESProducer", ComponentName = cms.string( "hltESPTTRHBWithTrackAngle" ), @@ -4220,7 +4249,9 @@ UseQualityInfo = cms.bool( False ), appendToDataLabel = cms.string( "" ) ) -fragment.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer" ) +fragment.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer", + appendToDataLabel = cms.string( "" ) +) fragment.siStripBackPlaneCorrectionDepESProducer = cms.ESProducer( "SiStripBackPlaneCorrectionDepESProducer", LatencyRecord = cms.PSet( label = cms.untracked.string( "" ), @@ -4233,7 +4264,8 @@ BackPlaneCorrectionDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripBackPlaneCorrectionRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.siStripLorentzAngleDepESProducer = cms.ESProducer( "SiStripLorentzAngleDepESProducer", LatencyRecord = cms.PSet( @@ -4247,7 +4279,8 @@ LorentzAngleDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripLorentzAngleRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.zdcTopologyEP = cms.ESProducer( "ZdcTopologyEP", appendToDataLabel = cms.string( "" ) @@ -4420,9 +4453,9 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -5084,14 +5117,22 @@ fragment.hltSiPixelClustersSoA = cms.EDProducer( "SiPixelRawToClusterPhase1@alpaka", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) @@ -5117,6 +5158,7 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltSiPixelRecHits = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), src = cms.InputTag( "hltSiPixelClusters" ) ) @@ -5165,14 +5207,22 @@ fragment.hltSiPixelClustersSoASerialSync = cms.EDProducer( "alpaka_serial_sync::SiPixelRawToClusterPhase1", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ) ) fragment.hltSiPixelClustersSerialSync = cms.EDProducer( "SiPixelDigisClustersFromSoAAlpakaPhase1", @@ -5196,36 +5246,38 @@ CPE = cms.string( "PixelCPEFastParams" ) ) fragment.hltSiPixelRecHitsSerialSync = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), src = cms.InputTag( "hltSiPixelClustersSerialSync" ) ) fragment.hltPixelTracksSoA = cms.EDProducer( "CAHitNtupletAlpakaPhase1@alpaka", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -5237,9 +5289,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltPixelTracks = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", @@ -5279,31 +5338,32 @@ ) fragment.hltPixelTracksSoASerialSync = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -5315,9 +5375,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ) + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) fragment.hltPixelTracksSerialSync = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -5467,9 +5534,9 @@ shouldRunTimingComputation = cms.bool( True ) ) fragment.hltEcalUncalibRecHitSerialSync = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -6152,7 +6219,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 4096 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( False ) ) fragment.hltL1sHcalNZS = cms.EDFilter( "HLTL1TSeed", @@ -6197,7 +6264,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 107 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( True ) ) fragment.hltPrePhysics = cms.EDFilter( "HLTPrescaler", @@ -6229,74 +6296,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) diff --git a/HLTrigger/Configuration/python/HLT_Special_cff.py b/HLTrigger/Configuration/python/HLT_Special_cff.py index 1e46b55a34c4e..d6fdb115c3acf 100644 --- a/HLTrigger/Configuration/python/HLT_Special_cff.py +++ b/HLTrigger/Configuration/python/HLT_Special_cff.py @@ -1,6 +1,6 @@ -# hltGetConfiguration /dev/CMSSW_15_0_0/Special --cff --data --type Special +# hltGetConfiguration /dev/CMSSW_15_1_0/Special --cff --data --type Special -# /dev/CMSSW_15_0_0/Special/V114 (CMSSW_15_0_11) +# /dev/CMSSW_15_1_0/Special/V10 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms @@ -9,7 +9,7 @@ fragment.load("Configuration.StandardSequences.Accelerators_cff") fragment.HLTConfigVersion = cms.PSet( - tableName = cms.string("/dev/CMSSW_15_0_0/Special/V114") + tableName = cms.string("/dev/CMSSW_15_1_0/Special/V10") ) fragment.HLTGroupedCkfTrajectoryBuilderP5 = cms.PSet( @@ -1909,7 +1909,9 @@ fragment.CSCObjectMapESProducer = cms.ESProducer( "CSCObjectMapESProducer", appendToDataLabel = cms.string( "" ) ) -fragment.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder" ) +fragment.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder", + appendToDataLabel = cms.string( "" ) +) fragment.CaloTowerConstituentsMapBuilder = cms.ESProducer( "CaloTowerConstituentsMapBuilder", MapFile = cms.untracked.string( "Geometry/CaloTopology/data/CaloTowerEEGeometric.map.gz" ), MapAuto = cms.untracked.bool( False ), @@ -1966,85 +1968,103 @@ appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterial" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.MaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMf" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOppositeForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositeMaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.OppositePropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStepOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) fragment.PropagatorWithMaterialForLoopers = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 4.0 ), ComponentName = cms.string( "PropagatorWithMaterialForLoopers" ), Mass = cms.double( 0.1396 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 4.0 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.PropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStep" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) fragment.SiPixelTemplateStoreESProducer = cms.ESProducer( "SiPixelTemplateStoreESProducer", appendToDataLabel = cms.string( "" ) @@ -2183,7 +2203,9 @@ ), timeThresh = cms.double( 2.0 ) ) -fragment.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP" ) +fragment.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP", + appendToDataLabel = cms.string( "" ) +) fragment.hcalDDDRecConstants = cms.ESProducer( "HcalDDDRecConstantsESModule", appendToDataLabel = cms.string( "" ) ) @@ -2484,13 +2506,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPBwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPBwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPChi2ChargeLooseMeasurementEstimator16 = cms.ESProducer( "Chi2ChargeMeasurementEstimatorESProducer", MaxChi2 = cms.double( 16.0 ), @@ -2866,13 +2890,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPFwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPFwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPGlobalDetLayerGeometry = cms.ESProducer( "GlobalDetLayerGeometryESProducer", ComponentName = cms.string( "hltESPGlobalDetLayerGeometry" ), @@ -3446,13 +3472,15 @@ appendToDataLabel = cms.string( "" ) ) fragment.hltESPRungeKuttaTrackerPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPRungeKuttaTrackerPropagator" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( True ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPSiPixelCablingSoA = cms.ESProducer( "SiPixelCablingSoAESProducer@alpaka", CablingMapLabel = cms.string( "" ), @@ -3551,7 +3579,8 @@ mTIB_P0 = cms.double( -0.742 ), mTID_P1 = cms.double( 0.433 ), mTID_P0 = cms.double( -1.427 ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.hltESPTTRHBWithTrackAngle = cms.ESProducer( "TkTransientTrackingRecHitBuilderESProducer", ComponentName = cms.string( "hltESPTTRHBWithTrackAngle" ), @@ -3809,7 +3838,9 @@ UseQualityInfo = cms.bool( False ), appendToDataLabel = cms.string( "" ) ) -fragment.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer" ) +fragment.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer", + appendToDataLabel = cms.string( "" ) +) fragment.siStripBackPlaneCorrectionDepESProducer = cms.ESProducer( "SiStripBackPlaneCorrectionDepESProducer", LatencyRecord = cms.PSet( label = cms.untracked.string( "" ), @@ -3822,7 +3853,8 @@ BackPlaneCorrectionDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripBackPlaneCorrectionRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.siStripLorentzAngleDepESProducer = cms.ESProducer( "SiStripLorentzAngleDepESProducer", LatencyRecord = cms.PSet( @@ -3836,7 +3868,8 @@ LorentzAngleDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripLorentzAngleRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) fragment.zdcTopologyEP = cms.ESProducer( "ZdcTopologyEP", appendToDataLabel = cms.string( "" ) @@ -4009,9 +4042,9 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -4612,14 +4645,22 @@ fragment.hltSiPixelClustersSoA = cms.EDProducer( "SiPixelRawToClusterPhase1@alpaka", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) @@ -4645,36 +4686,38 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltSiPixelRecHits = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), src = cms.InputTag( "hltSiPixelClusters" ) ) fragment.hltPixelTracksSoA = cms.EDProducer( "CAHitNtupletAlpakaPhase1@alpaka", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -4686,9 +4729,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) fragment.hltPixelTracks = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", @@ -7535,14 +7585,22 @@ fragment.hltSiPixelClustersSoASerialSync = cms.EDProducer( "alpaka_serial_sync::SiPixelRawToClusterPhase1", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ) ) fragment.hltSiPixelClustersSerialSync = cms.EDProducer( "SiPixelDigisClustersFromSoAAlpakaPhase1", @@ -7566,36 +7624,38 @@ CPE = cms.string( "PixelCPEFastParams" ) ) fragment.hltSiPixelRecHitsSerialSync = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), src = cms.InputTag( "hltSiPixelClustersSerialSync" ) ) fragment.hltPixelTracksSoASerialSync = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -7607,9 +7667,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ) + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) fragment.hltPixelTracksSerialSync = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -7759,9 +7826,9 @@ shouldRunTimingComputation = cms.bool( True ) ) fragment.hltEcalUncalibRecHitSerialSync = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -8397,74 +8464,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -12290,7 +12357,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 4096 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( False ) ) fragment.hltL1sHcalNZS = cms.EDFilter( "HLTL1TSeed", @@ -12335,7 +12402,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 107 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( True ) ) fragment.hltPrePhysics = cms.EDFilter( "HLTPrescaler", diff --git a/HLTrigger/Configuration/python/HLTrigger_Datasets_GRun_cff.py b/HLTrigger/Configuration/python/HLTrigger_Datasets_GRun_cff.py index 7687c2f3353ea..8275b4d87b9ec 100644 --- a/HLTrigger/Configuration/python/HLTrigger_Datasets_GRun_cff.py +++ b/HLTrigger/Configuration/python/HLTrigger_Datasets_GRun_cff.py @@ -1,4 +1,4 @@ -# /dev/CMSSW_15_0_0/GRun +# /dev/CMSSW_15_1_0/GRun import FWCore.ParameterSet.Config as cms @@ -32,6 +32,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -98,6 +99,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -167,6 +169,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -233,6 +236,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -302,6 +306,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -368,6 +373,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -437,6 +443,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -503,6 +510,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', diff --git a/HLTrigger/Configuration/python/HLTrigger_Datasets_HIon_cff.py b/HLTrigger/Configuration/python/HLTrigger_Datasets_HIon_cff.py index 2b66ca5785349..0ae2ee81641e3 100644 --- a/HLTrigger/Configuration/python/HLTrigger_Datasets_HIon_cff.py +++ b/HLTrigger/Configuration/python/HLTrigger_Datasets_HIon_cff.py @@ -1,4 +1,4 @@ -# /dev/CMSSW_15_0_0/HIon +# /dev/CMSSW_15_1_0/HIon import FWCore.ParameterSet.Config as cms diff --git a/HLTrigger/Configuration/python/HLTrigger_Datasets_PIon_cff.py b/HLTrigger/Configuration/python/HLTrigger_Datasets_PIon_cff.py index ed997a6cf351b..435f67947a666 100644 --- a/HLTrigger/Configuration/python/HLTrigger_Datasets_PIon_cff.py +++ b/HLTrigger/Configuration/python/HLTrigger_Datasets_PIon_cff.py @@ -1,4 +1,4 @@ -# /dev/CMSSW_15_0_0/PIon +# /dev/CMSSW_15_1_0/PIon import FWCore.ParameterSet.Config as cms diff --git a/HLTrigger/Configuration/python/HLTrigger_Datasets_PRef_cff.py b/HLTrigger/Configuration/python/HLTrigger_Datasets_PRef_cff.py index d0eba741c1a6d..14c3c9ab3d52d 100644 --- a/HLTrigger/Configuration/python/HLTrigger_Datasets_PRef_cff.py +++ b/HLTrigger/Configuration/python/HLTrigger_Datasets_PRef_cff.py @@ -1,4 +1,4 @@ -# /dev/CMSSW_15_0_0/PRef +# /dev/CMSSW_15_1_0/PRef import FWCore.ParameterSet.Config as cms diff --git a/HLTrigger/Configuration/python/HLTrigger_Datasets_Special_cff.py b/HLTrigger/Configuration/python/HLTrigger_Datasets_Special_cff.py index 1fd4726075e7d..b14f80118691b 100644 --- a/HLTrigger/Configuration/python/HLTrigger_Datasets_Special_cff.py +++ b/HLTrigger/Configuration/python/HLTrigger_Datasets_Special_cff.py @@ -1,4 +1,4 @@ -# /dev/CMSSW_15_0_0/Special +# /dev/CMSSW_15_1_0/Special import FWCore.ParameterSet.Config as cms diff --git a/HLTrigger/Configuration/python/HLTrigger_EventContent_cff.py b/HLTrigger/Configuration/python/HLTrigger_EventContent_cff.py index 2f811a23a4ec9..b558510c68d65 100644 --- a/HLTrigger/Configuration/python/HLTrigger_EventContent_cff.py +++ b/HLTrigger/Configuration/python/HLTrigger_EventContent_cff.py @@ -124,8 +124,12 @@ 'keep *_hltDoubletRecoveryPFlowTrackSelectionHighPurityPPOnAA_*_*', 'keep *_hltDoubletRecoveryPFlowTrackSelectionHighPurity_*_*', 'keep *_hltDt4DSegments_*_*', + 'keep *_hltEcalDigisSerialSync_*_*', + 'keep *_hltEcalDigis_*_*', 'keep *_hltEcalPhiSymFilter_*_*', 'keep *_hltEcalRecHit_*_*', + 'keep *_hltEcalUncalibRecHitSerialSync_*_*', + 'keep *_hltEcalUncalibRecHit_*_*', 'keep *_hltEgammaCandidates_*_*', 'keep *_hltEgammaGsfTracks_*_*', 'keep *_hltFEDSelectorL1_*_*', @@ -140,6 +144,7 @@ 'keep *_hltGlbTrkMuonCandsNoVtx_*_*', 'keep *_hltGtStage2Digis_*_*', 'keep *_hltHITrackingSiStripRawToClustersFacilityFullZeroSuppression_*_*', + 'keep *_hltHbherecoSerialSync_*_*', 'keep *_hltHbhereco_*_*', 'keep *_hltHfreco_*_*', 'keep *_hltHoreco_*_*', @@ -202,6 +207,8 @@ 'keep *_hltPFTau35Track_*_*', 'keep *_hltPFTau35_*_*', 'keep *_hltPPSCalibrationRaw_*_*', + 'keep *_hltParticleFlowClusterHCALSerialSync_*_*', + 'keep *_hltParticleFlowClusterHCAL_*_*', 'keep *_hltParticleFlowForTaus_*_*', 'keep *_hltParticleFlow_*_*', 'keep *_hltParticleNetDiscriminatorsJetTagsAK8_*_*', @@ -217,6 +224,8 @@ 'keep *_hltSiPixelClustersAfterSplittingPPOnAA_*_*', 'keep *_hltSiPixelClustersCache_*_*', 'keep *_hltSiPixelClusters_*_*', + 'keep *_hltSiPixelDigiErrorsSerialSync_*_*', + 'keep *_hltSiPixelDigiErrors_*_*', 'keep *_hltSiStripClusterizerForRawPrime_*_*', 'keep *_hltSiStripClusters2ApproxClusters_*_*', 'keep *_hltSiStripRawToClustersFacilityOnDemand_*_*', @@ -296,8 +305,12 @@ 'keep *_hltDoubletRecoveryPFlowTrackSelectionHighPurityPPOnAA_*_*', 'keep *_hltDoubletRecoveryPFlowTrackSelectionHighPurity_*_*', 'keep *_hltDt4DSegments_*_*', + 'keep *_hltEcalDigisSerialSync_*_*', + 'keep *_hltEcalDigis_*_*', 'keep *_hltEcalPhiSymFilter_*_*', 'keep *_hltEcalRecHit_*_*', + 'keep *_hltEcalUncalibRecHitSerialSync_*_*', + 'keep *_hltEcalUncalibRecHit_*_*', 'keep *_hltEgammaCandidates_*_*', 'keep *_hltEgammaGsfTracks_*_*', 'keep *_hltFEDSelectorL1_*_*', @@ -312,6 +325,7 @@ 'keep *_hltGlbTrkMuonCandsNoVtx_*_*', 'keep *_hltGtStage2Digis_*_*', 'keep *_hltHITrackingSiStripRawToClustersFacilityFullZeroSuppression_*_*', + 'keep *_hltHbherecoSerialSync_*_*', 'keep *_hltHbhereco_*_*', 'keep *_hltHfreco_*_*', 'keep *_hltHoreco_*_*', @@ -374,6 +388,8 @@ 'keep *_hltPFTau35Track_*_*', 'keep *_hltPFTau35_*_*', 'keep *_hltPPSCalibrationRaw_*_*', + 'keep *_hltParticleFlowClusterHCALSerialSync_*_*', + 'keep *_hltParticleFlowClusterHCAL_*_*', 'keep *_hltParticleFlowForTaus_*_*', 'keep *_hltParticleFlow_*_*', 'keep *_hltParticleNetDiscriminatorsJetTagsAK8_*_*', @@ -389,6 +405,8 @@ 'keep *_hltSiPixelClustersAfterSplittingPPOnAA_*_*', 'keep *_hltSiPixelClustersCache_*_*', 'keep *_hltSiPixelClusters_*_*', + 'keep *_hltSiPixelDigiErrorsSerialSync_*_*', + 'keep *_hltSiPixelDigiErrors_*_*', 'keep *_hltSiStripClusterizerForRawPrime_*_*', 'keep *_hltSiStripClusters2ApproxClusters_*_*', 'keep *_hltSiStripRawToClustersFacilityOnDemand_*_*', diff --git a/HLTrigger/Configuration/python/customizeHLTforCMSSW.py b/HLTrigger/Configuration/python/customizeHLTforCMSSW.py index 06e9872a30baf..df6fd4bdf2923 100644 --- a/HLTrigger/Configuration/python/customizeHLTforCMSSW.py +++ b/HLTrigger/Configuration/python/customizeHLTforCMSSW.py @@ -37,160 +37,6 @@ def customiseForOffline(process): return process -def customizeHLTfor47611(process): - """ This customizer - - cleans up the CANtupletAlpaka producers paramters; - - adds the geometry paramters used to fill the CAGeometry; - - adds the average sizes paramters to the CANtupletAlpaka producers; - - for pp and HIN hlt setups. - """ - - ca_producers_pp = ['CAHitNtupletAlpakaPhase1@alpaka','alpaka_serial_sync::CAHitNtupletAlpakaPhase1'] - ca_producers_hi = ['CAHitNtupletAlpakaHIonPhase1@alpaka','alpaka_serial_sync::CAHitNtupletAlpakaHIonPhase1'] - ca_producers = ca_producers_pp + ca_producers_hi - ca_parameters = [ 'CAThetaCutBarrel', 'CAThetaCutForward', - 'dcaCutInnerTriplet', 'dcaCutOuterTriplet', - 'doPtCut', 'doZ0Cut', 'idealConditions', - 'includeJumpingForwardDoublets', 'phiCuts','doClusterCut','CPE'] - - has_pp_producers = False - has_hi_producers = False - - for ca_producer in ca_producers: - for prod in producers_by_type(process, ca_producer): - - for par in ca_parameters: - if hasattr(prod, par): - delattr(prod,par) - - if not hasattr(prod, 'dzdrFact'): - setattr(prod, 'dzdrFact', cms.double(8.0 * 0.0285 / 0.015)) - if not hasattr(prod, 'maxDYsize12'): - setattr(prod, 'maxDYsize12', cms.int32(28)) - if not hasattr(prod, 'maxDYsize'): - setattr(prod, 'maxDYsize', cms.int32(20)) - if not hasattr(prod, 'maxDYPred'): - setattr(prod, 'maxDYPred', cms.int32(20)) - - if hasattr(prod, 'maxNumberOfDoublets'): - v = getattr(prod, 'maxNumberOfDoublets') - delattr(prod, 'maxNumberOfDoublets') - setattr(prod, 'maxNumberOfDoublets', cms.string(str(v.value()))) - - for ca_producer in ca_producers_pp: - for prod in producers_by_type(process, ca_producer): - - has_pp_producers = True - - if not hasattr(prod, 'maxNumberOfTuples'): - setattr(prod,'maxNumberOfTuples',cms.string(str(32*1024))) - - if not hasattr(prod, 'avgCellsPerCell'): - setattr(prod, 'avgCellsPerCell', cms.double(0.071)) - - if not hasattr(prod, 'avgCellsPerHit'): - setattr(prod, 'avgCellsPerHit', cms.double(27)) - - if not hasattr(prod, 'avgHitsPerTrack'): - setattr(prod, 'avgHitsPerTrack', cms.double(4.5)) - - if not hasattr(prod, 'avgTracksPerCell'): - setattr(prod, 'avgTracksPerCell', cms.double(0.127)) - - if not hasattr(prod, 'geometry'): - - geometryPS = cms.PSet( - startingPairs = cms.vuint32( [i for i in range(8)] + [i for i in range(13,20)]), - caDCACuts = cms.vdouble( [0.0918113099491] + [0.420724617835] * 9), - caThetaCuts = cms.vdouble([0.00123302705499] * 4 + [0.00355691321774] * 6), - pairGraph = cms.vuint32( - 0, 1, 0, 4, 0, - 7, 1, 2, 1, 4, - 1, 7, 4, 5, 7, - 8, 2, 3, 2, 4, - 2, 7, 5, 6, 8, - 9, 0, 2, 1, 3, - 0, 5, 0, 8, - 4, 6, 7, 9 - ), - phiCuts = cms.vint32( - 965, 1241, 395, 698, 1058, - 1211, 348, 782, 1016, 810, - 463, 755, 694, 531, 770, - 471, 592, 750, 348 - ), - minZ = cms.vdouble( - -20., 0., -30., -22., 10., - -30., -70., -70., -22., 15., - -30, -70., -70., -20., -22., - 0, -30., -70., -70. - ), - maxZ = cms.vdouble( 20., 30., 0., 22., 30., - -10., 70., 70., 22., 30., - -15., 70., 70., 20., 22., - 30., 0., 70., 70.), - maxR = cms.vdouble(20., 9., 9., 20., 7., - 7., 5., 5., 20., 6., - 6., 5., 5., 20., 20., - 9., 9., 9., 9.) - ) - - setattr(prod, 'geometry', geometryPS) - - for ca_producer in ca_producers_hi: - for prod in producers_by_type(process, ca_producer): - - has_hi_producers = True - - if not hasattr(prod, 'maxNumberOfTuples'): - setattr(prod,'maxNumberOfTuples',cms.string(str(256 * 1024))) # way too much, could be ~20k - - if not hasattr(prod, 'avgCellsPerCell'): - setattr(prod, 'avgCellsPerCell', cms.double(0.5)) - - if not hasattr(prod, 'avgCellsPerHit'): - setattr(prod, 'avgCellsPerHit', cms.double(40)) - - if not hasattr(prod, 'avgHitsPerTrack'): - setattr(prod, 'avgHitsPerTrack', cms.double(5.0)) - - if not hasattr(prod, 'avgTracksPerCell'): - setattr(prod, 'avgTracksPerCell', cms.double(0.5)) - - if not hasattr(prod, 'geometry'): - - geometryPS = cms.PSet( - caDCACuts = cms.vdouble( - 0.05, 0.1, 0.1, 0.1, 0.1, - 0.1, 0.1, 0.1, 0.1, 0.1 - ), - caThetaCuts = cms.vdouble( - 0.001, 0.001, 0.001, 0.001, 0.002, - 0.002, 0.002, 0.002, 0.002, 0.002 - ), - - ## This are the defaults actually - startingPairs = cms.vuint32(0,1,2), - pairGraph = cms.vuint32(0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9), - phiCuts = cms.vint32(522, 730, 730, 522, 626, 626, 522, 522, 626, 626, 626, 522, 522, 522, 522, 522, 522, 522, 522), - minZ = cms.vdouble(-20, 0, -30, -22, 10, -30, -70, -70, -22, 15, -30, -70, -70, -20, -22, 0, -30, -70, -70), - maxZ = cms.vdouble(20, 30, 0, 22, 30, -10, 70, 70, 22, 30, -15, 70, 70, 20, 22, 30, 0, 70, 70), - maxR = cms.vdouble(20, 9, 9, 20, 7, 7, 5, 5, 20, 6, 6, 5, 5, 20, 20, 9, 9, 9, 9) - ) - - setattr(prod, 'geometry', geometryPS) - - return process - -def customizeHLTfor48957(process): - for filt in filters_by_type(process, "HLTL1NumberFilter"): - if hasattr(filt, "fedId"): - value = filt.fedId.value() - del filt.fedId - filt.fedIds = cms.vint32([value]) - - return process - # CMSSW version specific customizations def customizeHLTforCMSSW(process, menuType="GRun"): @@ -199,8 +45,5 @@ def customizeHLTforCMSSW(process, menuType="GRun"): # add call to action function in proper order: newest last! # process = customiseFor12718(process) - process = customizeHLTfor47611(process) - process = customizeHLTfor48957(process) - return process diff --git a/HLTrigger/Configuration/tables/GRun.txt b/HLTrigger/Configuration/tables/GRun.txt index ef64344b2845f..6b13f7878a831 100644 --- a/HLTrigger/Configuration/tables/GRun.txt +++ b/HLTrigger/Configuration/tables/GRun.txt @@ -228,6 +228,7 @@ HLT_Dimuon0_Jpsi_v* # CMSHLT-1298 HLT_Dimuon0_LowMass_L1_0er1p5_v* # CMSHLT-1298 HLT_Dimuon0_LowMass_L1_4_v* # CMSHLT-1298 HLT_Dimuon0_LowMass_v* # CMSHLT-1298 +HLT_Dimuon0_LowMass_Inclusive_v* # CMSHLT-3629 HLT_Dimuon0_Upsilon_L1_4p5_v* # CMSHLT-1298 HLT_Dimuon0_Upsilon_L1_4p5er2p0_v* # CMSHLT-1298 HLT_Dimuon0_Upsilon_L1_4p5er2p0M_v* # CMSHLT-1298 diff --git a/HLTrigger/Configuration/tables/online_grun.txt b/HLTrigger/Configuration/tables/online_grun.txt index e8ff98a2450de..2076f2f921677 100644 --- a/HLTrigger/Configuration/tables/online_grun.txt +++ b/HLTrigger/Configuration/tables/online_grun.txt @@ -228,6 +228,7 @@ HLT_Dimuon0_Jpsi_v* # CMSHLT-1298 HLT_Dimuon0_LowMass_L1_0er1p5_v* # CMSHLT-1298 HLT_Dimuon0_LowMass_L1_4_v* # CMSHLT-1298 HLT_Dimuon0_LowMass_v* # CMSHLT-1298 +HLT_Dimuon0_LowMass_Inclusive_v* # CMSHLT-3629 HLT_Dimuon0_Upsilon_L1_4p5_v* # CMSHLT-1298 HLT_Dimuon0_Upsilon_L1_4p5er2p0_v* # CMSHLT-1298 HLT_Dimuon0_Upsilon_L1_4p5er2p0M_v* # CMSHLT-1298 diff --git a/HLTrigger/Configuration/test/OnLine_HLT_2025v13.py b/HLTrigger/Configuration/test/OnLine_HLT_2025v13.py index dce5b124518a6..c19daff482f00 100644 --- a/HLTrigger/Configuration/test/OnLine_HLT_2025v13.py +++ b/HLTrigger/Configuration/test/OnLine_HLT_2025v13.py @@ -1,6 +1,6 @@ -# hltGetConfiguration /frozen/2025/2e34/v1.3/HLT --full --data --type 2025v13 --unprescale --process HLT2025v13 --globaltag auto:run3_hlt_2025v13 --input file:RelVal_Raw_2025v13_DATA.root +# hltGetConfiguration /frozen/2025/2e34/v1.3/CMSSW_15_1_X/HLT --full --data --type 2025v13 --unprescale --process HLT2025v13 --globaltag auto:run3_hlt_2025v13 --input file:RelVal_Raw_2025v13_DATA.root -# /frozen/2025/2e34/v1.3/HLT/V1 (CMSSW_15_0_11) +# /frozen/2025/2e34/v1.3/CMSSW_15_1_X/HLT/V4 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms @@ -9,7 +9,7 @@ process.load("Configuration.StandardSequences.Accelerators_cff") process.HLTConfigVersion = cms.PSet( - tableName = cms.string("/frozen/2025/2e34/v1.3/HLT/V1") + tableName = cms.string("/frozen/2025/2e34/v1.3/CMSSW_15_1_X/HLT/V4") ) process.HLTGroupedCkfTrajectoryBuilderP5 = cms.PSet( @@ -4743,7 +4743,9 @@ 'EcalPreshower', 'TOWER' ) ) -process.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder" ) +process.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder", + appendToDataLabel = cms.string( "" ) +) process.CaloTowerConstituentsMapBuilder = cms.ESProducer( "CaloTowerConstituentsMapBuilder", MapFile = cms.untracked.string( "Geometry/CaloTopology/data/CaloTowerEEGeometric.map.gz" ), MapAuto = cms.untracked.bool( False ), @@ -4842,67 +4844,81 @@ appendToDataLabel = cms.string( "" ) ) process.MaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterial" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.MaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.MaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMf" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOppositeForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositePropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStepOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) process.ParametrizedMagneticFieldProducer = cms.ESProducer( "AutoParametrizedMagneticFieldProducer", version = cms.string( "Parabolic" ), @@ -4910,22 +4926,26 @@ valueOverride = cms.int32( -1 ) ) process.PropagatorWithMaterialForLoopers = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 4.0 ), ComponentName = cms.string( "PropagatorWithMaterialForLoopers" ), Mass = cms.double( 0.1396 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 4.0 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.PropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStep" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) process.RPCGeometryESModule = cms.ESProducer( "RPCGeometryESModule", fromDDD = cms.untracked.bool( False ), @@ -5135,7 +5155,9 @@ ), timeThresh = cms.double( 2.0 ) ) -process.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP" ) +process.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP", + appendToDataLabel = cms.string( "" ) +) process.hcalDDDRecConstants = cms.ESProducer( "HcalDDDRecConstantsESModule", appendToDataLabel = cms.string( "" ) ) @@ -5437,13 +5459,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPBwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPBwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPChi2ChargeLooseMeasurementEstimator16 = cms.ESProducer( "Chi2ChargeMeasurementEstimatorESProducer", MaxChi2 = cms.double( 16.0 ), @@ -5822,13 +5846,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPFwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPFwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPGlobalDetLayerGeometry = cms.ESProducer( "GlobalDetLayerGeometryESProducer", ComponentName = cms.string( "hltESPGlobalDetLayerGeometry" ), @@ -6404,13 +6430,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPRungeKuttaTrackerPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPRungeKuttaTrackerPropagator" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( True ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPSiPixelCablingSoA = cms.ESProducer( "SiPixelCablingSoAESProducer@alpaka", CablingMapLabel = cms.string( "" ), @@ -6509,7 +6537,8 @@ mTIB_P0 = cms.double( -0.742 ), mTID_P1 = cms.double( 0.433 ), mTID_P0 = cms.double( -1.427 ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.hltESPTTRHBWithTrackAngle = cms.ESProducer( "TkTransientTrackingRecHitBuilderESProducer", ComponentName = cms.string( "hltESPTTRHBWithTrackAngle" ), @@ -6784,7 +6813,9 @@ UseQualityInfo = cms.bool( False ), appendToDataLabel = cms.string( "" ) ) -process.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer" ) +process.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer", + appendToDataLabel = cms.string( "" ) +) process.siStripBackPlaneCorrectionDepESProducer = cms.ESProducer( "SiStripBackPlaneCorrectionDepESProducer", LatencyRecord = cms.PSet( label = cms.untracked.string( "" ), @@ -6797,7 +6828,8 @@ BackPlaneCorrectionDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripBackPlaneCorrectionRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.siStripLorentzAngleDepESProducer = cms.ESProducer( "SiStripLorentzAngleDepESProducer", LatencyRecord = cms.PSet( @@ -6811,7 +6843,8 @@ LorentzAngleDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripLorentzAngleRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.sistripconn = cms.ESProducer( "SiStripConnectivity" ) process.trackerTopology = cms.ESProducer( "TrackerTopologyEP", @@ -7060,9 +7093,9 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -7663,14 +7696,22 @@ process.hltSiPixelClustersSoA = cms.EDProducer( "SiPixelRawToClusterPhase1@alpaka", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) @@ -7696,36 +7737,38 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltSiPixelRecHits = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), src = cms.InputTag( "hltSiPixelClusters" ) ) process.hltPixelTracksSoA = cms.EDProducer( "CAHitNtupletAlpakaPhase1@alpaka", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -7737,9 +7780,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltPixelTracks = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", @@ -10584,74 +10634,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -12093,9 +12143,9 @@ shouldRunTimingComputation = cms.bool( True ) ) process.hltEcalUncalibRecHitSerialSync = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -12207,74 +12257,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbherecoSerialSync" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHitSerialSync:EcalRecHitsEB','hltEcalRecHitSerialSync:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbherecoSerialSync" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHitSerialSync:EcalRecHitsEB','hltEcalRecHitSerialSync:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -12510,14 +12560,22 @@ process.hltSiPixelClustersSoASerialSync = cms.EDProducer( "alpaka_serial_sync::SiPixelRawToClusterPhase1", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ) ) process.hltSiPixelClustersSerialSync = cms.EDProducer( "SiPixelDigisClustersFromSoAAlpakaPhase1", @@ -12541,6 +12599,7 @@ CPE = cms.string( "PixelCPEFastParams" ) ) process.hltSiPixelRecHitsSerialSync = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), src = cms.InputTag( "hltSiPixelClustersSerialSync" ) ) @@ -12809,31 +12868,32 @@ ) process.hltPixelTracksSoASerialSync = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -12845,9 +12905,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ) + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) process.hltPixelTracksSerialSync = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -20103,7 +20170,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 4096 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( False ) ) process.hltL1sHcalNZS = cms.EDFilter( "HLTL1TSeed", @@ -20148,7 +20215,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 107 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( True ) ) process.hltPrePhysics = cms.EDFilter( "HLTPrescaler", @@ -33286,74 +33353,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( True ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "" ), + ecalInputs = cms.VInputTag( ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -40171,74 +40238,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltCaloRecHitsBeamHaloCleaned" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEB','hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltCaloRecHitsBeamHaloCleaned" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEB','hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -40735,22 +40802,23 @@ TriggerTypes = cms.vint32( 86 ) ) process.hltDeepBLifetimeTagInfosPF = cms.EDProducer( "CandIPProducer", - primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), - computeProbabilities = cms.bool( True ), - computeGhostTrack = cms.bool( True ), - ghostTrackPriorDeltaR = cms.double( 0.03 ), - minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 3 ), maximumTransverseImpactParameter = cms.double( 0.2 ), + minimumNumberOfHits = cms.int32( 3 ), minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), + primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), maximumLongitudinalImpactParameter = cms.double( 17.0 ), - jetDirectionUsingTracks = cms.bool( False ), + computeGhostTrack = cms.bool( True ), + maxDeltaR = cms.double( 0.4 ), + candidates = cms.InputTag( "hltParticleFlow" ), jetDirectionUsingGhostTrack = cms.bool( False ), + minimumNumberOfPixelHits = cms.int32( 2 ), + jetDirectionUsingTracks = cms.bool( False ), + computeProbabilities = cms.bool( True ), useTrackQuality = cms.bool( False ), jets = cms.InputTag( "hltPFJetForBtag" ), - candidates = cms.InputTag( "hltParticleFlow" ), - maxDeltaR = cms.double( 0.4 ) + ghostTrackPriorDeltaR = cms.double( 0.03 ), + maximumChiSquared = cms.double( 5.0 ), + explicitJTA = cms.bool( False ) ) process.hltDeepInclusiveVertexFinderPF = cms.EDProducer( "InclusiveCandidateVertexFinder", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -42946,15 +43014,15 @@ etMin = cms.double( 20.0 ) ) process.hltBSoftMuonDiJet20L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet20L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -42995,15 +43063,15 @@ invertRapidityCut = cms.bool( False ) ) process.hltBSoftMuonDiJet20L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet20L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43065,15 +43133,15 @@ etMin = cms.double( 40.0 ) ) process.hltBSoftMuonDiJet40L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet40L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43091,15 +43159,15 @@ TriggerType = cms.int32( 86 ) ) process.hltBSoftMuonDiJet40L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet40L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43161,15 +43229,15 @@ etMin = cms.double( 70.0 ) ) process.hltBSoftMuonDiJet70L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet70L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43187,15 +43255,15 @@ TriggerType = cms.int32( 86 ) ) process.hltBSoftMuonDiJet70L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet70L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43257,15 +43325,15 @@ etMin = cms.double( 110.0 ) ) process.hltBSoftMuonDiJet110L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet110L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43283,15 +43351,15 @@ TriggerType = cms.int32( 86 ) ) process.hltBSoftMuonDiJet110L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet110L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43353,15 +43421,15 @@ etMin = cms.double( 110.0 ) ) process.hltBSoftMuonDiJet200L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet200L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43379,15 +43447,15 @@ TriggerType = cms.int32( 86 ) ) process.hltBSoftMuonDiJet200L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet200L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43449,15 +43517,15 @@ etMin = cms.double( 300.0 ) ) process.hltBSoftMuonJet300L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonJet300L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43475,15 +43543,15 @@ TriggerType = cms.int32( 86 ) ) process.hltBSoftMuonJet300L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonJet300L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43532,15 +43600,15 @@ etMin = cms.double( 110.0 ) ) process.hltBSoftMuonAK8DiJet170L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonAK8DiJet170L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43558,15 +43626,15 @@ TriggerType = cms.int32( 85 ) ) process.hltBSoftMuonAK8DiJet170L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonAK8DiJet170L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43660,15 +43728,15 @@ etMin = cms.double( 170.0 ) ) process.hltBSoftMuonAK8Jet170L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonAK8Jet170L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43736,15 +43804,15 @@ invertRapidityCut = cms.bool( False ) ) process.hltBSoftMuonAK8Jet170L1FastJetDoubleMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonDoubleMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonAK8Jet170L1FastJetDoubleMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43793,15 +43861,15 @@ etMin = cms.double( 300.0 ) ) process.hltBSoftMuonJet300L1AK8FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonJet300L1AK8FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43819,15 +43887,15 @@ TriggerType = cms.int32( 85 ) ) process.hltBSoftMuonJet300L1AK8FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonJet300L1AK8FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -60339,74 +60407,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( True ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "" ), + hbheInput = cms.InputTag( "" ), + hoInput = cms.InputTag( "" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -66674,22 +66742,23 @@ TriggerTypes = cms.vint32( 86 ) ) process.hltDeepBLifetimeTagInfosPFMinPt20 = cms.EDProducer( "CandIPProducer", - primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), - computeProbabilities = cms.bool( True ), - computeGhostTrack = cms.bool( True ), - ghostTrackPriorDeltaR = cms.double( 0.03 ), - minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 3 ), maximumTransverseImpactParameter = cms.double( 0.2 ), + minimumNumberOfHits = cms.int32( 3 ), minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), + primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), maximumLongitudinalImpactParameter = cms.double( 17.0 ), - jetDirectionUsingTracks = cms.bool( False ), + computeGhostTrack = cms.bool( True ), + maxDeltaR = cms.double( 0.4 ), + candidates = cms.InputTag( "hltParticleFlow" ), jetDirectionUsingGhostTrack = cms.bool( False ), + minimumNumberOfPixelHits = cms.int32( 2 ), + jetDirectionUsingTracks = cms.bool( False ), + computeProbabilities = cms.bool( True ), useTrackQuality = cms.bool( False ), jets = cms.InputTag( "hltPFJetForBtagMinPt20" ), - candidates = cms.InputTag( "hltParticleFlow" ), - maxDeltaR = cms.double( 0.4 ) + ghostTrackPriorDeltaR = cms.double( 0.03 ), + maximumChiSquared = cms.double( 5.0 ), + explicitJTA = cms.bool( False ) ) process.hltPrimaryVertexAssociationMinPt20 = cms.EDProducer( "PFCandidatePrimaryVertexSorter", sorting = cms.PSet( ), @@ -73233,20 +73302,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerLowPtSingle = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPtSingle" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPtSingle" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLowPtSingle = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -73815,20 +73884,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPtSingle = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPtSingle" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPtSingle" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPtSingle = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -73977,20 +74046,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerLowPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLowPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -74019,20 +74088,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -74387,20 +74456,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerLow30Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow30PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74429,20 +74498,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow30Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow30Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74740,20 +74809,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLow30Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) process.hltL4DisplacedDijetFullTracksJetTagProducerLooseFromIPLow30Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1stLoose" ), @@ -74798,20 +74867,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerLow35Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow35PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74840,20 +74909,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow35Pt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow35Pt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74897,20 +74966,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow35Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow35Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74939,20 +75008,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLow35Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) process.hltL4DisplacedDijetFullTracksJetTagProducerLooseFromIPLow35Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1stLoose" ), @@ -75000,20 +75069,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75057,20 +75126,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75099,20 +75168,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLowPt1PtrkPt0p5ShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) process.hltL4DisplacedDijetFullTracksJetTagProducerLooseFromIPLowPt1PtrkPt0p5ShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1stLoose" ), @@ -75157,20 +75226,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerLow45Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow45Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow45Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow45PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75199,20 +75268,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow45Pt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow45Pt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow45Pt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow45Pt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75257,20 +75326,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerLow50Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow50Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow50Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow50PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75299,20 +75368,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow50Pt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow50Pt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow50Pt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow50Pt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75375,20 +75444,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducer45Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertex45Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertex45Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIP45PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75417,20 +75486,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducer45Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertex45Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertex45Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIP45Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75518,20 +75587,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLowPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) process.hltL4DisplacedDijetFullTracksJetTagProducerFromIPLowPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1st" ), @@ -75589,20 +75658,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerMidPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPMidPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -75631,20 +75700,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerMidPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexMidPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexMidPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPMidPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -76168,22 +76237,23 @@ TriggerTypes = cms.vint32( 86 ) ) process.hltDeepBLifetimeTagInfosPFMinPt10 = cms.EDProducer( "CandIPProducer", - primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), - computeProbabilities = cms.bool( True ), - computeGhostTrack = cms.bool( True ), - ghostTrackPriorDeltaR = cms.double( 0.03 ), - minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 3 ), maximumTransverseImpactParameter = cms.double( 0.2 ), + minimumNumberOfHits = cms.int32( 3 ), minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), + primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), maximumLongitudinalImpactParameter = cms.double( 17.0 ), - jetDirectionUsingTracks = cms.bool( False ), + computeGhostTrack = cms.bool( True ), + maxDeltaR = cms.double( 0.4 ), + candidates = cms.InputTag( "hltParticleFlow" ), jetDirectionUsingGhostTrack = cms.bool( False ), + minimumNumberOfPixelHits = cms.int32( 2 ), + jetDirectionUsingTracks = cms.bool( False ), + computeProbabilities = cms.bool( True ), useTrackQuality = cms.bool( False ), jets = cms.InputTag( "hltPFJetForBtagMinPt10" ), - candidates = cms.InputTag( "hltParticleFlow" ), - maxDeltaR = cms.double( 0.4 ) + ghostTrackPriorDeltaR = cms.double( 0.03 ), + maximumChiSquared = cms.double( 5.0 ), + explicitJTA = cms.bool( False ) ) process.hltPrimaryVertexAssociationMinPt10 = cms.EDProducer( "PFCandidatePrimaryVertexSorter", sorting = cms.PSet( ), @@ -76344,20 +76414,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedSingleJet100FullTracksTrackIPProducer30Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex30Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex30Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedSingleJetFullTracksJetTagProducerFromIP30PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76386,20 +76456,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedSingleJetFullTracksTrackIPProducer30Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex30Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex30Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedSingleJetFullTracksJetTagProducerFromIP30Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76468,20 +76538,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedSingleJet100FullTracksTrackIPProducer35Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex35Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex35Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedSingleJetFullTracksJetTagProducerFromIP35PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76510,20 +76580,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedSingleJetFullTracksTrackIPProducer35Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex35Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex35Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedSingleJetFullTracksJetTagProducerFromIP35Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76556,20 +76626,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedSingleJet100FullTracksTrackIPProducer40Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex40Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex40Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedSingleJetFullTracksJetTagProducerFromIP40PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76598,20 +76668,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedSingleJetFullTracksTrackIPProducer40Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex40Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex40Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedSingleJetFullTracksJetTagProducerFromIP40Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76894,20 +76964,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerMidPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) process.hltL4DisplacedDijetFullTracksJetTagProducerFromIPMidPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1st" ), diff --git a/HLTrigger/Configuration/test/OnLine_HLT_FULL.py b/HLTrigger/Configuration/test/OnLine_HLT_FULL.py index 30ab98dc815f4..77bd16d575878 100644 --- a/HLTrigger/Configuration/test/OnLine_HLT_FULL.py +++ b/HLTrigger/Configuration/test/OnLine_HLT_FULL.py @@ -1,6 +1,6 @@ -# hltGetConfiguration /dev/CMSSW_15_0_0/HLT --full --data --type FULL --unprescale --process HLTFULL --globaltag auto:run3_hlt_FULL --input file:RelVal_Raw_FULL_DATA.root +# hltGetConfiguration /dev/CMSSW_15_1_0/HLT --full --data --type FULL --unprescale --process HLTFULL --globaltag auto:run3_hlt_FULL --input file:RelVal_Raw_FULL_DATA.root -# /dev/CMSSW_15_0_0/HLT/V132 (CMSSW_15_0_11) +# /dev/CMSSW_15_1_0/HLT/V21 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms @@ -9,7 +9,7 @@ process.load("Configuration.StandardSequences.Accelerators_cff") process.HLTConfigVersion = cms.PSet( - tableName = cms.string("/dev/CMSSW_15_0_0/HLT/V132") + tableName = cms.string("/dev/CMSSW_15_1_0/HLT/V21") ) process.HLTGroupedCkfTrajectoryBuilderP5 = cms.PSet( @@ -11057,6 +11057,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -11192,8 +11193,8 @@ 'HLT_Ele8_CaloIdM_TrackIdM_PFJet30_v34', 'HLT_HIL1NotBptxORForPPRef_v10', 'HLT_HIL1UnpairedBunchBptxMinusForPPRef_v10', - 'HLT_HIL1UnpairedBunchBptxPlusForPPRef_v10', - 'HLT_HT170_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14')+cms.vstring( 'HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay0p5nsTrackless_v14', + 'HLT_HIL1UnpairedBunchBptxPlusForPPRef_v10')+cms.vstring( 'HLT_HT170_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14', + 'HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay0p5nsTrackless_v14', 'HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay1nsInclusive_v14', 'HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay1nsTrackless_v14', 'HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay2nsInclusive_v14', @@ -11446,8 +11447,8 @@ 'HLT_PFJet400_v36', 'HLT_PFJet40_v37', 'HLT_PFJet450_v37', - 'HLT_PFJet500_v37', - 'HLT_PFJet550_v27')+cms.vstring( 'HLT_PFJet60_v37', + 'HLT_PFJet500_v37')+cms.vstring( 'HLT_PFJet550_v27', + 'HLT_PFJet60_v37', 'HLT_PFJet80_v37', 'HLT_PFJetFwd140_v34', 'HLT_PFJetFwd200_v34', @@ -12348,6 +12349,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -12407,6 +12409,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -12466,6 +12469,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -12525,6 +12529,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -12584,6 +12589,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -12643,6 +12649,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -12702,6 +12709,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -12761,6 +12769,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -14114,7 +14123,9 @@ 'EcalPreshower', 'TOWER' ) ) -process.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder" ) +process.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder", + appendToDataLabel = cms.string( "" ) +) process.CaloTowerConstituentsMapBuilder = cms.ESProducer( "CaloTowerConstituentsMapBuilder", MapFile = cms.untracked.string( "Geometry/CaloTopology/data/CaloTowerEEGeometric.map.gz" ), MapAuto = cms.untracked.bool( False ), @@ -14213,67 +14224,81 @@ appendToDataLabel = cms.string( "" ) ) process.MaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterial" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.MaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.MaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMf" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOppositeForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositePropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStepOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) process.ParametrizedMagneticFieldProducer = cms.ESProducer( "AutoParametrizedMagneticFieldProducer", version = cms.string( "Parabolic" ), @@ -14281,22 +14306,26 @@ valueOverride = cms.int32( -1 ) ) process.PropagatorWithMaterialForLoopers = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 4.0 ), ComponentName = cms.string( "PropagatorWithMaterialForLoopers" ), Mass = cms.double( 0.1396 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 4.0 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.PropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStep" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) process.RPCGeometryESModule = cms.ESProducer( "RPCGeometryESModule", fromDDD = cms.untracked.bool( False ), @@ -14506,7 +14535,9 @@ ), timeThresh = cms.double( 2.0 ) ) -process.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP" ) +process.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP", + appendToDataLabel = cms.string( "" ) +) process.hcalDDDRecConstants = cms.ESProducer( "HcalDDDRecConstantsESModule", appendToDataLabel = cms.string( "" ) ) @@ -14808,13 +14839,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPBwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPBwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPChi2ChargeLooseMeasurementEstimator16 = cms.ESProducer( "Chi2ChargeMeasurementEstimatorESProducer", MaxChi2 = cms.double( 16.0 ), @@ -15193,13 +15226,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPFwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPFwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPGlobalDetLayerGeometry = cms.ESProducer( "GlobalDetLayerGeometryESProducer", ComponentName = cms.string( "hltESPGlobalDetLayerGeometry" ), @@ -15775,13 +15810,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPRungeKuttaTrackerPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPRungeKuttaTrackerPropagator" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( True ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPSiPixelCablingSoA = cms.ESProducer( "SiPixelCablingSoAESProducer@alpaka", CablingMapLabel = cms.string( "" ), @@ -15880,7 +15917,8 @@ mTIB_P0 = cms.double( -0.742 ), mTID_P1 = cms.double( 0.433 ), mTID_P0 = cms.double( -1.427 ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.hltESPTTRHBWithTrackAngle = cms.ESProducer( "TkTransientTrackingRecHitBuilderESProducer", ComponentName = cms.string( "hltESPTTRHBWithTrackAngle" ), @@ -16155,7 +16193,9 @@ UseQualityInfo = cms.bool( False ), appendToDataLabel = cms.string( "" ) ) -process.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer" ) +process.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer", + appendToDataLabel = cms.string( "" ) +) process.siStripBackPlaneCorrectionDepESProducer = cms.ESProducer( "SiStripBackPlaneCorrectionDepESProducer", LatencyRecord = cms.PSet( label = cms.untracked.string( "" ), @@ -16168,7 +16208,8 @@ BackPlaneCorrectionDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripBackPlaneCorrectionRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.siStripLorentzAngleDepESProducer = cms.ESProducer( "SiStripLorentzAngleDepESProducer", LatencyRecord = cms.PSet( @@ -16182,7 +16223,8 @@ LorentzAngleDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripLorentzAngleRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.sistripconn = cms.ESProducer( "SiStripConnectivity" ) process.trackerTopology = cms.ESProducer( "TrackerTopologyEP", @@ -16431,9 +16473,9 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -17080,14 +17122,22 @@ process.hltSiPixelClustersSoA = cms.EDProducer( "SiPixelRawToClusterPhase1@alpaka", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) @@ -17113,36 +17163,38 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltSiPixelRecHits = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), src = cms.InputTag( "hltSiPixelClusters" ) ) process.hltPixelTracksSoA = cms.EDProducer( "CAHitNtupletAlpakaPhase1@alpaka", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -17154,9 +17206,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltPixelTracks = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", @@ -20086,74 +20145,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -21595,9 +21654,9 @@ shouldRunTimingComputation = cms.bool( True ) ) process.hltEcalUncalibRecHitSerialSync = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -21709,74 +21768,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbherecoSerialSync" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHitSerialSync:EcalRecHitsEB','hltEcalRecHitSerialSync:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbherecoSerialSync" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHitSerialSync:EcalRecHitsEB','hltEcalRecHitSerialSync:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -22012,14 +22071,22 @@ process.hltSiPixelClustersSoASerialSync = cms.EDProducer( "alpaka_serial_sync::SiPixelRawToClusterPhase1", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ) ) process.hltSiPixelClustersSerialSync = cms.EDProducer( "SiPixelDigisClustersFromSoAAlpakaPhase1", @@ -22043,6 +22110,7 @@ CPE = cms.string( "PixelCPEFastParams" ) ) process.hltSiPixelRecHitsSerialSync = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), src = cms.InputTag( "hltSiPixelClustersSerialSync" ) ) @@ -22311,31 +22379,32 @@ ) process.hltPixelTracksSoASerialSync = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -22347,9 +22416,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ) + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) process.hltPixelTracksSerialSync = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -25391,14 +25467,22 @@ process.hltSiPixelClustersPPOnAASoA = cms.EDProducer( "SiPixelRawToClusterHIonPhase1@alpaka", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 1000 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) @@ -25428,20 +25512,29 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltSiPixelRecHitsPPOnAA = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaHIonPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsPPOnAASoA" ), src = cms.InputTag( "hltSiPixelClustersPPOnAA" ) ) process.hltSiPixelClustersPPOnAASoASerialSync = cms.EDProducer( "alpaka_serial_sync::SiPixelRawToClusterHIonPhase1", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 1000 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ) ) process.hltSiPixelClustersPPOnAASerialSync = cms.EDProducer( "SiPixelDigisClustersFromSoAAlpakaHIonPhase1", @@ -25469,50 +25562,59 @@ CPE = cms.string( "PixelCPEFastParamsHIonPhase1" ) ) process.hltSiPixelRecHitsPPOnAASerialSync = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaHIonPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsPPOnAASoASerialSync" ), src = cms.InputTag( "hltSiPixelClustersPPOnAASerialSync" ) ) process.hltPixelTracksPPOnAASoA = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaHIonPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsPPOnAASoA" ), - CPE = cms.string( "PixelCPEFastParamsHIonPhase1" ), - ptmin = cms.double( 0.8999999761581421 ), - CAThetaCutBarrel = cms.double( 0.0010000000949949026 ), - CAThetaCutForward = cms.double( 0.002000000026077032 ), - hardCurvCut = cms.double( 0.03284072249589491 ), - dcaCutInnerTriplet = cms.double( 0.05000000596046448 ), - dcaCutOuterTriplet = cms.double( 0.1 ), + cellZ0Cut = cms.double( 8.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 36 ), + minYsizeB2 = cms.int32( 28 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "3145728" ), + maxNumberOfTuples = cms.string( "262144" ), + avgHitsPerTrack = cms.double( 5.0 ), + avgCellsPerHit = cms.double( 40.0 ), + avgCellsPerCell = cms.double( 0.5 ), + avgTracksPerCell = cms.double( 0.5 ), + ptmin = cms.double( 0.899999976158 ), + hardCurvCut = cms.double( 0.0328407224959 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 4 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 3145728 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 8.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), - chi2Coeff = cms.vdouble( 0.9, 1.8 ), - chi2Scale = cms.double( 1.8 ), - tripletMinPt = cms.double( 0.1 ), tripletMaxTip = cms.double( 0.3 ), - tripletMaxZip = cms.double( 12.0 ), - quadrupletMinPt = cms.double( 0.1 ), + chi2Scale = cms.double( 1.8 ), quadrupletMaxTip = cms.double( 0.5 ), - quadrupletMaxZip = cms.double( 12.0 ) + quadrupletMinPt = cms.double( 0.1 ), + quadrupletMaxZip = cms.double( 12.0 ), + tripletMaxZip = cms.double( 12.0 ), + tripletMinPt = cms.double( 0.1 ), + chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 36 ), - minYsizeB2 = cms.int32( 28 ), - phiCuts = cms.vint32( 522, 730, 730, 522, 626, 626, 522, 522, 626, 626, 626, 522, 522, 522, 522, 522, 522, 522, 522 ) + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.001, 0.001, 0.001, 0.001, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.05, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 522, 730, 730, 522, 626, 626, 522, 522, 626, 626, 626, 522, 522, 522, 522, 522, 522, 522, 522 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) process.hltPixelTracksPPOnAA = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaHIonPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -25550,45 +25652,53 @@ ) process.hltPixelTracksPPOnAASoASerialSync = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaHIonPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsPPOnAASoASerialSync" ), - CPE = cms.string( "PixelCPEFastParamsHIonPhase1" ), - ptmin = cms.double( 0.8999999761581421 ), - CAThetaCutBarrel = cms.double( 0.0010000000949949026 ), - CAThetaCutForward = cms.double( 0.002000000026077032 ), - hardCurvCut = cms.double( 0.03284072249589491 ), - dcaCutInnerTriplet = cms.double( 0.05000000596046448 ), - dcaCutOuterTriplet = cms.double( 0.1 ), + cellZ0Cut = cms.double( 8.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 36 ), + minYsizeB2 = cms.int32( 28 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "3145728" ), + maxNumberOfTuples = cms.string( "262144" ), + avgHitsPerTrack = cms.double( 5.0 ), + avgCellsPerHit = cms.double( 40.0 ), + avgCellsPerCell = cms.double( 0.5 ), + avgTracksPerCell = cms.double( 0.5 ), + ptmin = cms.double( 0.899999976158 ), + hardCurvCut = cms.double( 0.0328407224959 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 4 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 3145728 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 8.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), - chi2Coeff = cms.vdouble( 0.9, 1.8 ), - chi2Scale = cms.double( 1.8 ), - tripletMinPt = cms.double( 0.1 ), tripletMaxTip = cms.double( 0.3 ), - tripletMaxZip = cms.double( 12.0 ), - quadrupletMinPt = cms.double( 0.1 ), + chi2Scale = cms.double( 1.8 ), quadrupletMaxTip = cms.double( 0.5 ), - quadrupletMaxZip = cms.double( 12.0 ) + quadrupletMinPt = cms.double( 0.1 ), + quadrupletMaxZip = cms.double( 12.0 ), + tripletMaxZip = cms.double( 12.0 ), + tripletMinPt = cms.double( 0.1 ), + chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 36 ), - minYsizeB2 = cms.int32( 28 ), - phiCuts = cms.vint32( 522, 730, 730, 522, 626, 626, 522, 522, 626, 626, 626, 522, 522, 522, 522, 522, 522, 522, 522 ) + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.001, 0.001, 0.001, 0.001, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.05, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 522, 730, 730, 522, 626, 626, 522, 522, 626, 626, 626, 522, 522, 522, 522, 522, 522, 522, 522 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) process.hltPixelTracksPPOnAASerialSync = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaHIonPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -29988,7 +30098,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 4096 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( False ) ) process.hltL1sHcalNZS = cms.EDFilter( "HLTL1TSeed", @@ -30033,7 +30143,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 107 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( True ) ) process.hltPrePhysics = cms.EDFilter( "HLTPrescaler", @@ -43171,74 +43281,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( True ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "" ), + ecalInputs = cms.VInputTag( ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -50056,74 +50166,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltCaloRecHitsBeamHaloCleaned" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEB','hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltCaloRecHitsBeamHaloCleaned" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEB','hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -50620,22 +50730,23 @@ TriggerTypes = cms.vint32( 86 ) ) process.hltDeepBLifetimeTagInfosPF = cms.EDProducer( "CandIPProducer", - primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), - computeProbabilities = cms.bool( True ), - computeGhostTrack = cms.bool( True ), - ghostTrackPriorDeltaR = cms.double( 0.03 ), - minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 3 ), maximumTransverseImpactParameter = cms.double( 0.2 ), + minimumNumberOfHits = cms.int32( 3 ), minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), + primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), maximumLongitudinalImpactParameter = cms.double( 17.0 ), - jetDirectionUsingTracks = cms.bool( False ), + computeGhostTrack = cms.bool( True ), + maxDeltaR = cms.double( 0.4 ), + candidates = cms.InputTag( "hltParticleFlow" ), jetDirectionUsingGhostTrack = cms.bool( False ), + minimumNumberOfPixelHits = cms.int32( 2 ), + jetDirectionUsingTracks = cms.bool( False ), + computeProbabilities = cms.bool( True ), useTrackQuality = cms.bool( False ), jets = cms.InputTag( "hltPFJetForBtag" ), - candidates = cms.InputTag( "hltParticleFlow" ), - maxDeltaR = cms.double( 0.4 ) + ghostTrackPriorDeltaR = cms.double( 0.03 ), + maximumChiSquared = cms.double( 5.0 ), + explicitJTA = cms.bool( False ) ) process.hltDeepInclusiveVertexFinderPF = cms.EDProducer( "InclusiveCandidateVertexFinder", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -52831,15 +52942,15 @@ etMin = cms.double( 20.0 ) ) process.hltBSoftMuonDiJet20L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet20L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -52880,15 +52991,15 @@ invertRapidityCut = cms.bool( False ) ) process.hltBSoftMuonDiJet20L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet20L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -52950,15 +53061,15 @@ etMin = cms.double( 40.0 ) ) process.hltBSoftMuonDiJet40L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet40L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -52976,15 +53087,15 @@ TriggerType = cms.int32( 86 ) ) process.hltBSoftMuonDiJet40L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet40L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53046,15 +53157,15 @@ etMin = cms.double( 70.0 ) ) process.hltBSoftMuonDiJet70L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet70L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53072,15 +53183,15 @@ TriggerType = cms.int32( 86 ) ) process.hltBSoftMuonDiJet70L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet70L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53142,15 +53253,15 @@ etMin = cms.double( 110.0 ) ) process.hltBSoftMuonDiJet110L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet110L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53168,15 +53279,15 @@ TriggerType = cms.int32( 86 ) ) process.hltBSoftMuonDiJet110L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet110L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53238,15 +53349,15 @@ etMin = cms.double( 110.0 ) ) process.hltBSoftMuonDiJet200L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet200L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53264,15 +53375,15 @@ TriggerType = cms.int32( 86 ) ) process.hltBSoftMuonDiJet200L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet200L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53334,15 +53445,15 @@ etMin = cms.double( 300.0 ) ) process.hltBSoftMuonJet300L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonJet300L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53360,15 +53471,15 @@ TriggerType = cms.int32( 86 ) ) process.hltBSoftMuonJet300L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonJet300L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53417,15 +53528,15 @@ etMin = cms.double( 110.0 ) ) process.hltBSoftMuonAK8DiJet170L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonAK8DiJet170L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53443,15 +53554,15 @@ TriggerType = cms.int32( 85 ) ) process.hltBSoftMuonAK8DiJet170L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonAK8DiJet170L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53545,15 +53656,15 @@ etMin = cms.double( 170.0 ) ) process.hltBSoftMuonAK8Jet170L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonAK8Jet170L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53621,15 +53732,15 @@ invertRapidityCut = cms.bool( False ) ) process.hltBSoftMuonAK8Jet170L1FastJetDoubleMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonDoubleMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonAK8Jet170L1FastJetDoubleMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53678,15 +53789,15 @@ etMin = cms.double( 300.0 ) ) process.hltBSoftMuonJet300L1AK8FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonJet300L1AK8FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -53704,15 +53815,15 @@ TriggerType = cms.int32( 85 ) ) process.hltBSoftMuonJet300L1AK8FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonJet300L1AK8FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -60067,6 +60178,98 @@ BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), MuonTag = cms.InputTag( "hltIterL3MuonCandidates" ) ) +process.hltPreDimuon0LowMassInclusive = cms.EDFilter( "HLTPrescaler", + offset = cms.uint32( 0 ), + L1GtReadoutRecordTag = cms.InputTag( "hltGtStage2Digis" ) +) +process.hltL1fL1DoubleMu0SQInclusiveL1Filtered0 = cms.EDFilter( "HLTMuonL1TFilter", + saveTags = cms.bool( True ), + CandTag = cms.InputTag( 'hltGtStage2Digis','Muon' ), + PreviousCandTag = cms.InputTag( "hltL1sDoubleMu0SQOS" ), + MaxEta = cms.double( 2.5 ), + MinPt = cms.double( 0.0 ), + MaxDeltaR = cms.double( 0.3 ), + MinN = cms.int32( 2 ), + CentralBxOnly = cms.bool( True ), + SelectQualities = cms.vint32( ) +) +process.hltL2fL1sL1DoubleMu0SQInclusiveL2PreFiltered0 = cms.EDFilter( "HLTMuonL2FromL1TPreFilter", + saveTags = cms.bool( True ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltL1fL1DoubleMu0SQInclusiveL1Filtered0" ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MinN = cms.int32( 0 ), + MaxEta = cms.double( 2.5 ), + AbsEtaBins = cms.vdouble( 0.0 ), + MinNstations = cms.vint32( 0 ), + MinNhits = cms.vint32( 0 ), + CutOnChambers = cms.bool( False ), + MinNchambers = cms.vint32( 0 ), + MaxDr = cms.double( 9999.0 ), + MinDr = cms.double( -1.0 ), + MaxDz = cms.double( 9999.0 ), + MinDxySig = cms.double( -1.0 ), + MinPt = cms.double( 0.0 ), + NSigmaPt = cms.double( 0.0 ), + MatchToPreviousCand = cms.bool( True ) +) +process.hltL1fForIterL3L1fL1DoubleMu0SQInclusiveL1Filtered0 = cms.EDFilter( "HLTMuonL1TFilter", + saveTags = cms.bool( True ), + CandTag = cms.InputTag( "hltL1MuonsPt0" ), + PreviousCandTag = cms.InputTag( "hltL1fL1DoubleMu0SQInclusiveL1Filtered0" ), + MaxEta = cms.double( 2.5 ), + MinPt = cms.double( 0.0 ), + MaxDeltaR = cms.double( 0.3 ), + MinN = cms.int32( 1 ), + CentralBxOnly = cms.bool( True ), + SelectQualities = cms.vint32( ) +) +process.hltDimuon0LowMassInclusiveL3Filtered = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + CandTag = cms.InputTag( "hltIterL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltL2fL1sL1DoubleMu0SQInclusiveL2PreFiltered0" ), + L1CandTag = cms.InputTag( "hltL1fForIterL3L1fL1DoubleMu0SQInclusiveL1Filtered0" ), + inputMuonCollection = cms.InputTag( "hltIterL3Muons" ), + PreviousCandIsL2 = cms.bool( True ), + FastAccept = cms.bool( False ), + MinN = cms.int32( 1 ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.int32( 0 ), + MaxDr = cms.double( 2.0 ), + MaxDz = cms.double( 9999.0 ), + ChargeOpt = cms.int32( 0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MinPtMax = cms.vdouble( 0.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + MinInvMass = cms.vdouble( 0.2 ), + MaxInvMass = cms.vdouble( 12.0 ), + MinDiMuonDeltaR = cms.double( -1.0 ), + MinAcop = cms.double( -999.0 ), + MaxAcop = cms.double( 999.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxPtBalance = cms.double( 999999.0 ), + NSigmaPt = cms.double( 0.0 ), + MaxDCAMuMu = cms.double( 0.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + InputLinks = cms.InputTag( "hltL3MuonsIterL3Links" ), + L1MatchingdR = cms.double( 0.3 ), + MatchToPreviousCand = cms.bool( True ), + useSimpleGeometry = cms.bool( True ), + useStation2 = cms.bool( True ), + fallbackToME1 = cms.bool( False ), + cosmicPropagationHypothesis = cms.bool( False ), + useMB2InOverlap = cms.bool( False ), + useTrack = cms.string( "tracker" ), + useState = cms.string( "atVertex" ), + propagatorAlong = cms.ESInputTag( "","hltESPSteppingHelixPropagatorAlong" ), + propagatorAny = cms.ESInputTag( "","SteppingHelixPropagatorAny" ), + propagatorOpposite = cms.ESInputTag( "","hltESPSteppingHelixPropagatorOpposite" ) +) process.hltL1sTripleMu530NoMass = cms.EDFilter( "HLTL1TSeed", saveTags = cms.bool( True ), L1SeedsLogicalExpression = cms.string( "L1_TripleMu_5SQ_3SQ_0OQ" ), @@ -70224,74 +70427,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( True ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "" ), + hbheInput = cms.InputTag( "" ), + hoInput = cms.InputTag( "" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -76559,22 +76762,23 @@ TriggerTypes = cms.vint32( 86 ) ) process.hltDeepBLifetimeTagInfosPFMinPt20 = cms.EDProducer( "CandIPProducer", - primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), - computeProbabilities = cms.bool( True ), - computeGhostTrack = cms.bool( True ), - ghostTrackPriorDeltaR = cms.double( 0.03 ), - minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 3 ), maximumTransverseImpactParameter = cms.double( 0.2 ), + minimumNumberOfHits = cms.int32( 3 ), minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), + primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), maximumLongitudinalImpactParameter = cms.double( 17.0 ), - jetDirectionUsingTracks = cms.bool( False ), + computeGhostTrack = cms.bool( True ), + maxDeltaR = cms.double( 0.4 ), + candidates = cms.InputTag( "hltParticleFlow" ), jetDirectionUsingGhostTrack = cms.bool( False ), + minimumNumberOfPixelHits = cms.int32( 2 ), + jetDirectionUsingTracks = cms.bool( False ), + computeProbabilities = cms.bool( True ), useTrackQuality = cms.bool( False ), jets = cms.InputTag( "hltPFJetForBtagMinPt20" ), - candidates = cms.InputTag( "hltParticleFlow" ), - maxDeltaR = cms.double( 0.4 ) + ghostTrackPriorDeltaR = cms.double( 0.03 ), + maximumChiSquared = cms.double( 5.0 ), + explicitJTA = cms.bool( False ) ) process.hltPrimaryVertexAssociationMinPt20 = cms.EDProducer( "PFCandidatePrimaryVertexSorter", sorting = cms.PSet( ), @@ -83118,20 +83322,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerLowPtSingle = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPtSingle" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPtSingle" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLowPtSingle = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -83700,20 +83904,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPtSingle = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPtSingle" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPtSingle" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPtSingle = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -83862,20 +84066,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerLowPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLowPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -83904,20 +84108,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -84272,20 +84476,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerLow30Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow30PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -84314,20 +84518,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow30Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow30Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -84625,20 +84829,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLow30Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) process.hltL4DisplacedDijetFullTracksJetTagProducerLooseFromIPLow30Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1stLoose" ), @@ -84683,20 +84887,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerLow35Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow35PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -84725,20 +84929,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow35Pt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow35Pt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -84782,20 +84986,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow35Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow35Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -84824,20 +85028,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLow35Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) process.hltL4DisplacedDijetFullTracksJetTagProducerLooseFromIPLow35Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1stLoose" ), @@ -84885,20 +85089,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -84942,20 +85146,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -84984,20 +85188,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLowPt1PtrkPt0p5ShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) process.hltL4DisplacedDijetFullTracksJetTagProducerLooseFromIPLowPt1PtrkPt0p5ShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1stLoose" ), @@ -85042,20 +85246,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerLow45Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow45Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow45Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow45PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -85084,20 +85288,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow45Pt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow45Pt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow45Pt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow45Pt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -85142,20 +85346,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerLow50Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow50Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow50Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow50PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -85184,20 +85388,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow50Pt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow50Pt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow50Pt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow50Pt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -85260,20 +85464,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducer45Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertex45Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertex45Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIP45PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -85302,20 +85506,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducer45Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertex45Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertex45Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIP45Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -85403,20 +85607,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLowPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) process.hltL4DisplacedDijetFullTracksJetTagProducerFromIPLowPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1st" ), @@ -85474,20 +85678,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerMidPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPMidPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -85516,20 +85720,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerMidPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexMidPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexMidPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPMidPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -86053,22 +86257,23 @@ TriggerTypes = cms.vint32( 86 ) ) process.hltDeepBLifetimeTagInfosPFMinPt10 = cms.EDProducer( "CandIPProducer", - primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), - computeProbabilities = cms.bool( True ), - computeGhostTrack = cms.bool( True ), - ghostTrackPriorDeltaR = cms.double( 0.03 ), - minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 3 ), maximumTransverseImpactParameter = cms.double( 0.2 ), + minimumNumberOfHits = cms.int32( 3 ), minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), + primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), maximumLongitudinalImpactParameter = cms.double( 17.0 ), - jetDirectionUsingTracks = cms.bool( False ), + computeGhostTrack = cms.bool( True ), + maxDeltaR = cms.double( 0.4 ), + candidates = cms.InputTag( "hltParticleFlow" ), jetDirectionUsingGhostTrack = cms.bool( False ), + minimumNumberOfPixelHits = cms.int32( 2 ), + jetDirectionUsingTracks = cms.bool( False ), + computeProbabilities = cms.bool( True ), useTrackQuality = cms.bool( False ), jets = cms.InputTag( "hltPFJetForBtagMinPt10" ), - candidates = cms.InputTag( "hltParticleFlow" ), - maxDeltaR = cms.double( 0.4 ) + ghostTrackPriorDeltaR = cms.double( 0.03 ), + maximumChiSquared = cms.double( 5.0 ), + explicitJTA = cms.bool( False ) ) process.hltPrimaryVertexAssociationMinPt10 = cms.EDProducer( "PFCandidatePrimaryVertexSorter", sorting = cms.PSet( ), @@ -86229,20 +86434,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedSingleJet100FullTracksTrackIPProducer30Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex30Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex30Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedSingleJetFullTracksJetTagProducerFromIP30PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -86271,20 +86476,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedSingleJetFullTracksTrackIPProducer30Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex30Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex30Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedSingleJetFullTracksJetTagProducerFromIP30Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -86353,20 +86558,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedSingleJet100FullTracksTrackIPProducer35Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex35Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex35Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedSingleJetFullTracksJetTagProducerFromIP35PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -86395,20 +86600,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedSingleJetFullTracksTrackIPProducer35Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex35Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex35Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedSingleJetFullTracksJetTagProducerFromIP35Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -86441,20 +86646,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedSingleJet100FullTracksTrackIPProducer40Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex40Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex40Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedSingleJetFullTracksJetTagProducerFromIP40PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -86483,20 +86688,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedSingleJetFullTracksTrackIPProducer40Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex40Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex40Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedSingleJetFullTracksJetTagProducerFromIP40Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -86779,20 +86984,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerMidPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) process.hltL4DisplacedDijetFullTracksJetTagProducerFromIPMidPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1st" ), @@ -97883,74 +98088,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0E-99 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.1 ), HBThreshold2 = cms.double( 0.2 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0E-99 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 11 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( True ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "" ), + hoInput = cms.InputTag( "" ), + ecalInputs = cms.VInputTag( ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 11 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -99473,7 +99678,7 @@ trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "" ), produceSeedingHitSets = cms.bool( True ), - produceIntermediateHitDoublets = cms.bool( True ), + produceIntermediateHitDoublets = cms.bool( False ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), putEmptyIfMaxElementReached = cms.bool( False ), @@ -99495,7 +99700,7 @@ trackingRegions = cms.InputTag( "hltEleSeedsTrackingRegionsPPOnAA" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -105406,7 +105611,7 @@ trackingRegions = cms.InputTag( "hltFullIter2PixelTrackingRegionsPPOnAAForDmeson" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter2PixelClusterCheckPPOnAAForDmeson" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -105610,7 +105815,7 @@ trackingRegions = cms.InputTag( "hltFullIter3PixelTrackingRegionsPPOnAA" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter3PixelClusterCheckPPOnAA" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -105809,7 +106014,7 @@ trackingRegions = cms.InputTag( "hltFullIter7MixedTrackingRegionsAPPOnAA" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter7MixedClusterCheckPPOnAA" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -105906,7 +106111,7 @@ trackingRegions = cms.InputTag( "hltFullIter7MixedTrackingRegionsBPPOnAA" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter7MixedClusterCheckPPOnAA" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -106504,7 +106709,7 @@ trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter9TobTecClusterCheckPPOnAA" ), produceSeedingHitSets = cms.bool( True ), - produceIntermediateHitDoublets = cms.bool( True ), + produceIntermediateHitDoublets = cms.bool( False ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), putEmptyIfMaxElementReached = cms.bool( False ), @@ -117845,6 +118050,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -117980,8 +118186,8 @@ 'HLT_Ele8_CaloIdM_TrackIdM_PFJet30_v34', 'HLT_HIL1NotBptxORForPPRef_v10', 'HLT_HIL1UnpairedBunchBptxMinusForPPRef_v10', - 'HLT_HIL1UnpairedBunchBptxPlusForPPRef_v10', - 'HLT_HT170_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14')+cms.vstring( 'HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay0p5nsTrackless_v14', + 'HLT_HIL1UnpairedBunchBptxPlusForPPRef_v10')+cms.vstring( 'HLT_HT170_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14', + 'HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay0p5nsTrackless_v14', 'HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay1nsInclusive_v14', 'HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay1nsTrackless_v14', 'HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay2nsInclusive_v14', @@ -118234,8 +118440,8 @@ 'HLT_PFJet400_v36', 'HLT_PFJet40_v37', 'HLT_PFJet450_v37', - 'HLT_PFJet500_v37', - 'HLT_PFJet550_v27')+cms.vstring( 'HLT_PFJet60_v37', + 'HLT_PFJet500_v37')+cms.vstring( 'HLT_PFJet550_v27', + 'HLT_PFJet60_v37', 'HLT_PFJet80_v37', 'HLT_PFJetFwd140_v34', 'HLT_PFJetFwd200_v34', @@ -118521,6 +118727,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -126008,6 +126215,7 @@ process.HLT_Dimuon0_LowMass_L1_0er1p5_v24 = cms.Path( process.HLTBeginSequence + process.hltL1sDoubleMu0er1p5 + process.hltPreDimuon0LowMassL10er1p5 + process.hltL1sEmuDoubleMu0er1p5 + process.hltL1fL1sL1DoubleMu0er1p5L1Filtered0 + process.HLTL2muonrecoSequence + cms.ignore(process.hltL2fL1sL1DoubleMu0er1p5L1f0L2PreFiltered0) + process.HLTL3muonrecoSequence + cms.ignore(process.hltL1fForIterL3L1fL1sL1DoubleMu0er1p5L1Filtered0) + process.hltDimuon0LowMassL1s0er1p5L3Filtered + process.hltDisplacedmumuVtxProducerDimuon0LowMassL1s0er1p5 + process.hltDisplacedmumuFilterDimuon0LowMassL1s0er1p5 + process.HLTEndSequence ) process.HLT_Dimuon0_LowMass_v24 = cms.Path( process.HLTBeginSequence + process.hltL1sDoubleMu0SQOS + process.hltPreDimuon0LowMass + process.hltL1sEmuDoubleMu0SQOS + process.hltL1fL1DoubleMu0SQOSL1Filtered0 + process.HLTL2muonrecoSequence + cms.ignore(process.hltL2fL1sL1DoubleMu0SQOSL2PreFiltered0) + process.HLTL3muonrecoSequence + cms.ignore(process.hltL1fForIterL3L1fL1DoubleMu0SQOSL1Filtered0) + process.hltDimuon0LowMassL3Filtered + process.hltDisplacedmumuVtxProducerDimuon0LowMass + process.hltDisplacedmumuFilterDimuon0LowMass + process.HLTEndSequence ) process.HLT_Dimuon0_LowMass_L1_4_v24 = cms.Path( process.HLTBeginSequence + process.hltL1sDoubleMu4SQOS + process.hltPreDimuon0LowMassL14 + process.hltL1sEmuDoubleMu4SQOS + process.hltL1fL1sL1DoubleMu4SQOSL1Filtered0 + process.HLTL2muonrecoSequence + cms.ignore(process.hltL2fL1sL1DoubleMu4SQOSL1f0L2PreFiltered0) + process.HLTL3muonrecoSequence + cms.ignore(process.hltL1fForIterL3L1fL1sL1DoubleMu4SQOSL1Filtered0) + process.hltDimuon0LowMassL1s4L3Filtered + process.hltDisplacedmumuVtxProducerDimuon0LowMassL1s4 + process.hltDisplacedmumuFilterDimuon0LowMassL1s4 + process.HLTEndSequence ) +process.HLT_Dimuon0_LowMass_Inclusive_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sDoubleMu0SQOS + process.hltPreDimuon0LowMassInclusive + process.hltL1fL1DoubleMu0SQInclusiveL1Filtered0 + process.HLTL2muonrecoSequence + cms.ignore(process.hltL2fL1sL1DoubleMu0SQInclusiveL2PreFiltered0) + process.HLTL3muonrecoSequence + cms.ignore(process.hltL1fForIterL3L1fL1DoubleMu0SQInclusiveL1Filtered0) + process.hltDimuon0LowMassInclusiveL3Filtered + process.HLTEndSequence ) process.HLT_Dimuon0_LowMass_L1_TM530_v22 = cms.Path( process.HLTBeginSequence + process.hltL1sTripleMu530NoMass + process.hltPreDimuon0LowMassL1TM530 + process.hltL1fL1sL1TripleMuNoMassL1Filtered0 + process.HLTL2muonrecoSequence + cms.ignore(process.hltL2fL1sL1TripleMuNoMassL1f0L2PreFiltered0) + process.HLTL3muonrecoSequence + cms.ignore(process.hltL1fForIterL3L1fL1sL1TripleMuNoMassL1Filtered0) + process.hltDimuon0LowMassL1sTM530L3Filtered + process.hltDisplacedmumuVtxProducerDimuon0LowMassL1sTM530 + process.hltDisplacedmumuFilterDimuon0LowMassL1sTM530 + process.HLTEndSequence ) process.HLT_Dimuon0_Upsilon_Muon_NoL1Mass_v22 = cms.Path( process.HLTBeginSequence + process.hltL1sTripleMu53p52p5 + process.hltPreDimuon0UpsilonMuonNoL1Mass + process.hltTripleMuon53p52p5L1Filtered0 + process.HLTL2muonrecoSequence + cms.ignore(process.hltTripleMuon53p52p5L2PreFiltered0) + process.HLTL3muonrecoSequence + cms.ignore(process.hltL1fForIterL3TripleMuon53p52p5L1Filtered0) + process.hltTripleMu0NoL1MassL3PreFiltered0 + process.hltUpsilon0MuonL3FilteredNoL1Mass + process.hltDisplacedmumuVtxProducerUpsilon0MuonNoL1Mass + process.hltVertexmumuFilterUpsilon0MuonNoL1Mass + process.HLTEndSequence ) process.HLT_Dimuon0_Upsilon_v2 = cms.Path( process.HLTBeginSequence + process.hltL1s12ForUpsilonDimuon0Mass8to12 + process.hltPreDimuon0Upsilon + process.hltL1fL1sL1s12DoubleMu0er2p0SQOSMass8to12L1v2Filtered0 + process.HLTL2muonrecoSequence + cms.ignore(process.hltL2fL1sL1s12DoubleMu0er2p0SQOSMass8to12L1f0L2v2PreFiltered0) + process.HLTL3muonrecoSequence + cms.ignore(process.hltL1fForIterL3L1fL1sL1s12DoubleMu0er2p0SQOSMass8to12L1v2Filtered0) + process.hltDimuon0UpsilonyL3fL3Filtered + process.hltDisplacedmumuVtxProducerDimuon0Upsilonsv3 + process.hltDisplacedmumuFilterDimuon0Upsilonsv3 + process.HLTEndSequence ) @@ -127553,7 +127761,7 @@ process.LocalTestDataScoutingOutput = cms.EndPath( process.hltOutputLocalTestDataScouting ) -process.schedule = cms.Schedule( *(process.HLTriggerFirstPath, process.Status_OnCPU, process.Status_OnGPU, process.AlCa_EcalPhiSym_v22, process.AlCa_EcalPhiSymForHI_v13, process.AlCa_EcalEtaEBonly_v27, process.AlCa_EcalEtaEEonly_v27, process.AlCa_EcalPi0EBonly_v27, process.AlCa_EcalPi0EEonly_v27, process.AlCa_EcalEtaEBonlyForHI_v14, process.AlCa_EcalEtaEEonlyForHI_v14, process.AlCa_EcalPi0EBonlyForHI_v14, process.AlCa_EcalPi0EEonlyForHI_v14, process.AlCa_IsoTrackHBHE_v3, process.AlCa_HIEcalEtaEBonly_v13, process.AlCa_HIEcalEtaEEonly_v13, process.AlCa_HIEcalPi0EBonly_v13, process.AlCa_HIEcalPi0EEonly_v13, process.AlCa_RPCMuonNormalisation_v25, process.AlCa_RPCMuonNormalisationForHI_v13, process.AlCa_HIRPCMuonNormalisation_v13, process.AlCa_LumiPixelsCounts_Random_v12, process.AlCa_LumiPixelsCounts_ZeroBias_v15, process.AlCa_PFJet40_v36, process.AlCa_PFJet40_CPUOnly_v15, process.AlCa_AK8PFJet40_v31, process.DQM_PixelReconstruction_v14, process.DQM_EcalReconstruction_v13, process.DQM_HcalReconstruction_v11, process.DQM_HIPixelReconstruction_v14, process.DQM_HIEcalReconstruction_v11, process.DQM_HIHcalReconstruction_v9, process.DQM_Random_v1, process.DQM_ZeroBias_v4, process.DST_ZeroBias_v12, process.DST_Physics_v17, process.DST_PFScouting_DoubleMuonNoVtx_v4, process.DST_PFScouting_DoubleMuonVtx_v4, process.DST_PFScouting_DoubleMuonVtxMonitorJPsi_v4, process.DST_PFScouting_DoubleMuonVtxMonitorZ_v4, process.DST_PFScouting_DoubleEG_v10, process.DST_PFScouting_DoubleEGMonitorJPsi_v1, process.DST_PFScouting_DoubleEGMonitorZ_v1, process.DST_PFScouting_SinglePhotonEBMonitorJPsi_v1, process.DST_PFScouting_SinglePhotonEBMonitorZ_v1, process.DST_PFScouting_JetHT_v10, process.DST_PFScouting_AXOVLoose_v8, process.DST_PFScouting_AXOLoose_v8, process.DST_PFScouting_AXOMedium_v4, process.DST_PFScouting_AXOTight_v10, process.DST_PFScouting_AXOVTight_v8, process.HLT_MonitorL1TPureRate_AXO_v1, process.DST_PFScouting_CICADAVLoose_v6, process.DST_PFScouting_CICADALoose_v6, process.DST_PFScouting_CICADAMedium_v6, process.DST_PFScouting_CICADATight_v6, process.DST_PFScouting_CICADAVTight_v6, process.HLT_MonitorL1TPureRate_CICADA_v1, process.DST_PFScouting_SingleMuon_v10, process.DST_PFScouting_SinglePhotonEB_v7, process.DST_PFScouting_ZeroBias_v8, process.DST_PFScouting_ZeroBiasVdM_v2, process.HLT_TriggersForScoutingPFMonitor_PS125_v1, process.HLT_TriggersForScoutingPFMonitor_PS250_v1, process.HLT_TriggersForScoutingPFMonitor_PS500_v1, process.HLT_TriggersForScoutingPFMonitor_PS1000_v1, process.HLT_TriggersForScoutingPFMonitor_SingleMuon_v1, process.HLT_EphemeralPhysics_v10, process.HLT_EphemeralZeroBias_v10, process.HLT_HIEphemeralPhysics_v6, process.HLT_HIEphemeralZeroBias_v6, process.HLT_EcalCalibration_v4, process.HLT_HcalCalibration_v6, process.HLT_HcalNZS_v22, process.HLT_HcalPhiSym_v24, process.HLT_Random_v3, process.HLT_Physics_v15, process.HLT_ZeroBias_v14, process.HLT_ZeroBias_Alignment_v9, process.HLT_ZeroBias_Beamspot_v20, process.HLT_ZeroBias_IsolatedBunches_v13, process.HLT_ZeroBias_FirstBXAfterTrain_v11, process.HLT_ZeroBias_FirstCollisionAfterAbortGap_v13, process.HLT_ZeroBias_FirstCollisionInTrain_v12, process.HLT_ZeroBias_LastCollisionInTrain_v11, process.HLT_HT300_Beamspot_v27, process.HLT_PFJet40_GPUvsCPU_v8, process.HLT_AK8PFJet380_SoftDropMass30_v10, process.HLT_AK8PFJet400_SoftDropMass30_v10, process.HLT_AK8PFJet425_SoftDropMass30_v10, process.HLT_AK8PFJet450_SoftDropMass30_v10, process.HLT_AK8DiPFJet250_250_SoftDropMass40_v10, process.HLT_AK8DiPFJet250_250_SoftDropMass50_v10, process.HLT_AK8DiPFJet260_260_SoftDropMass30_v10, process.HLT_AK8DiPFJet260_260_SoftDropMass40_v10, process.HLT_AK8DiPFJet270_270_SoftDropMass30_v10, process.HLT_AK8DiPFJet280_280_SoftDropMass30_v16, process.HLT_AK8DiPFJet290_290_SoftDropMass30_v10, process.HLT_CaloJet500_NoJetID_v24, process.HLT_CaloJet550_NoJetID_v19, process.HLT_DoubleMu5_Upsilon_DoubleEle3_CaloIdL_TrackIdL_v20, process.HLT_DoubleMu3_DoubleEle7p5_CaloIdL_TrackIdL_Upsilon_v20, process.HLT_Trimuon5_3p5_2_Upsilon_Muon_v21, process.HLT_TrimuonOpen_5_3p5_2_Upsilon_Muon_v18, process.HLT_DoubleEle25_CaloIdL_MW_v18, process.HLT_DoubleEle27_CaloIdL_MW_v18, process.HLT_DoubleEle33_CaloIdL_MW_v31, process.HLT_DoubleEle24_eta2p1_WPTight_Gsf_v22, process.HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_DZ_PFHT350_v36, process.HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_PFHT350_v36, process.HLT_Mu27_Ele37_CaloIdL_MW_v21, process.HLT_Mu37_Ele27_CaloIdL_MW_v21, process.HLT_Mu37_TkMu27_v21, process.HLT_DoubleMu4_3_Bs_v31, process.HLT_DoubleMu4_3_Jpsi_v31, process.HLT_DoubleMu4_3_LowMass_v17, process.HLT_DoubleMu4_LowMass_Displaced_v17, process.HLT_Mu0_L1DoubleMu_v17, process.HLT_Mu4_L1DoubleMu_v17, process.HLT_DoubleMu2_Jpsi_LowPt_v10, process.HLT_DoubleMu4_3_Photon4_BsToMMG_v16, process.HLT_DoubleMu4_3_Displaced_Photon4_BsToMMG_v16, process.HLT_DoubleMu3_Trk_Tau3mu_v28, process.HLT_DoubleMu3_TkMu_DsTau3Mu_v20, process.HLT_DoubleMu4_Mass3p8_DZ_PFHT350_v24, process.HLT_DoubleMu4_MuMuTrk_Displaced_v31, process.HLT_Mu3_PFJet40_v32, process.HLT_Mu7p5_L2Mu2_Jpsi_v26, process.HLT_Mu7p5_L2Mu2_Upsilon_v26, process.HLT_Mu3_L1SingleMu5orSingleMu7_v17, process.HLT_Mu0_Barrel_v10, process.HLT_Mu0_Barrel_L1HP6_v7, process.HLT_Mu0_Barrel_L1HP7_v7, process.HLT_Mu0_Barrel_L1HP8_v8, process.HLT_Mu0_Barrel_L1HP9_v8, process.HLT_Mu0_Barrel_L1HP10_v10, process.HLT_Mu0_Barrel_L1HP11_v10, process.HLT_Mu0_Barrel_L1HP13_v4, process.HLT_Mu0_Barrel_L1HP6_IP6_v7, process.HLT_Mu4_Barrel_IP4_v4, process.HLT_Mu4_Barrel_IP6_v4, process.HLT_Mu6_Barrel_L1HP7_IP6_v7, process.HLT_Mu7_Barrel_L1HP8_IP6_v8, process.HLT_Mu8_Barrel_L1HP9_IP6_v8, process.HLT_Mu9_Barrel_L1HP10_IP6_v10, process.HLT_Mu10_Barrel_L1HP11_IP4_v4, process.HLT_Mu10_Barrel_L1HP11_IP6_v10, process.HLT_Mu12_Barrel_L1HP13_IP4_v4, process.HLT_Mu12_Barrel_L1HP13_IP6_v4, process.HLT_DoublePhoton33_CaloIdL_v18, process.HLT_DoublePhoton70_v18, process.HLT_DoublePhoton85_v26, process.HLT_DiEle27_WPTightCaloOnly_L1DoubleEG_v16, process.HLT_Ele30_WPTight_Gsf_v16, process.HLT_Ele32_WPTight_Gsf_v30, process.HLT_Ele35_WPTight_Gsf_v24, process.HLT_Ele38_WPTight_Gsf_v24, process.HLT_Ele40_WPTight_Gsf_v24, process.HLT_Ele32_WPTight_Gsf_L1DoubleEG_v24, process.HLT_IsoMu20_v31, process.HLT_IsoMu24_v29, process.HLT_IsoMu24_HLTTracking_v4, process.HLT_IsoMu24_eta2p1_v31, process.HLT_IsoMu27_v32, process.HLT_UncorrectedJetE30_NoBPTX_v16, process.HLT_UncorrectedJetE30_NoBPTX3BX_v16, process.HLT_UncorrectedJetE60_NoBPTX3BX_v16, process.HLT_UncorrectedJetE70_NoBPTX3BX_v16, process.HLT_L1SingleMuCosmics_v9, process.HLT_L2Mu10_NoVertex_NoBPTX3BX_v15, process.HLT_L2Mu10_NoVertex_NoBPTX_v16, process.HLT_L2Mu45_NoVertex_3Sta_NoBPTX3BX_v14, process.HLT_L2Mu40_NoVertex_3Sta_NoBPTX3BX_v15, process.HLT_L2Mu23NoVtx_2Cha_v11, process.HLT_L2Mu23NoVtx_2Cha_CosmicSeed_v11, process.HLT_DoubleL2Mu30NoVtx_2Cha_CosmicSeed_Eta2p4_v12, process.HLT_DoubleL2Mu30NoVtx_2Cha_Eta2p4_v12, process.HLT_DoubleL2Mu50_v12, process.HLT_DoubleL2Mu23NoVtx_2Cha_CosmicSeed_v12, process.HLT_DoubleL2Mu25NoVtx_2Cha_CosmicSeed_v12, process.HLT_DoubleL2Mu25NoVtx_2Cha_CosmicSeed_Eta2p4_v12, process.HLT_DoubleL2Mu23NoVtx_2Cha_v12, process.HLT_DoubleL2Mu25NoVtx_2Cha_v12, process.HLT_DoubleL2Mu25NoVtx_2Cha_Eta2p4_v12, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v30, process.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_v19, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v31, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_HLTTracking_v4, process.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_v19, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_v21, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_PFJet30_v10, process.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_Mass8_v19, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass3p8_v21, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass3p8_HLTTracking_v4, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_CaloJet30_v9, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_AK8PFJet30_v9, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_AK8CaloJet30_v9, process.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_Mass3p8_v19, process.HLT_Mu30_TkMu0_Psi_v17, process.HLT_Mu30_TkMu0_Upsilon_v17, process.HLT_Mu25_TkMu0_Phi_v24, process.HLT_Mu15_v19, process.HLT_Mu20_v28, process.HLT_Mu27_v29, process.HLT_Mu50_v29, process.HLT_Mu55_v19, process.HLT_CascadeMu100_v16, process.HLT_HighPtTkMu100_v16, process.HLT_DiPFJetAve40_v30, process.HLT_DiPFJetAve60_v30, process.HLT_DiPFJetAve80_v30, process.HLT_DiPFJetAve140_v29, process.HLT_DiPFJetAve200_v29, process.HLT_DiPFJetAve260_v30, process.HLT_DiPFJetAve320_v30, process.HLT_DiPFJetAve400_v30, process.HLT_DiPFJetAve500_v30, process.HLT_DiPFJetAve60_HFJEC_v31, process.HLT_DiPFJetAve80_HFJEC_v33, process.HLT_DiPFJetAve100_HFJEC_v33, process.HLT_DiPFJetAve160_HFJEC_v32, process.HLT_DiPFJetAve220_HFJEC_v32, process.HLT_DiPFJetAve260_HFJEC_v15, process.HLT_DiPFJetAve300_HFJEC_v32, process.HLT_DiPFJetAve180_PPSMatch_Xi0p3_QuadJet_Max2ProtPerRP_v10, process.HLT_AK8PFJet40_v32, process.HLT_AK8PFJet60_v31, process.HLT_AK8PFJet80_v32, process.HLT_AK8PFJet140_v31, process.HLT_AK8PFJet200_v31, process.HLT_AK8PFJet260_v32, process.HLT_AK8PFJet320_v32, process.HLT_AK8PFJet400_v32, process.HLT_AK8PFJet450_v32, process.HLT_AK8PFJet500_v32, process.HLT_AK8PFJet550_v27, process.HLT_PFJet40_v37, process.HLT_PFJet60_v37, process.HLT_PFJet80_v37, process.HLT_PFJet110_v16, process.HLT_PFJet140_v35, process.HLT_PFJet200_v35, process.HLT_PFJet260_v36, process.HLT_PFJet320_v36, process.HLT_PFJet400_v36, process.HLT_PFJet450_v37, process.HLT_PFJet500_v37, process.HLT_PFJet550_v27, process.HLT_PFJetFwd40_v35, process.HLT_PFJetFwd60_v35, process.HLT_PFJetFwd80_v34, process.HLT_PFJetFwd140_v34, process.HLT_PFJetFwd200_v34, process.HLT_PFJetFwd260_v35, process.HLT_PFJetFwd320_v35, process.HLT_PFJetFwd400_v35, process.HLT_PFJetFwd450_v35, process.HLT_PFJetFwd500_v35, process.HLT_AK8PFJetFwd40_v31, process.HLT_AK8PFJetFwd60_v30, process.HLT_AK8PFJetFwd80_v30, process.HLT_AK8PFJetFwd140_v30, process.HLT_AK8PFJetFwd200_v30, process.HLT_AK8PFJetFwd260_v31, process.HLT_AK8PFJetFwd320_v31, process.HLT_AK8PFJetFwd400_v31, process.HLT_AK8PFJetFwd450_v31, process.HLT_AK8PFJetFwd500_v31, process.HLT_PFHT180_v33, process.HLT_PFHT250_v33, process.HLT_PFHT370_v33, process.HLT_PFHT430_v33, process.HLT_PFHT510_v33, process.HLT_PFHT590_v33, process.HLT_PFHT680_v33, process.HLT_PFHT780_v33, process.HLT_PFHT890_v33, process.HLT_PFHT1050_v34, process.HLT_PFHT500_PFMET100_PFMHT100_IDTight_v28, process.HLT_PFHT500_PFMET110_PFMHT110_IDTight_v28, process.HLT_PFHT700_PFMET85_PFMHT85_IDTight_v28, process.HLT_PFHT800_PFMET75_PFMHT75_IDTight_v28, process.HLT_PFMET120_PFMHT120_IDTight_v36, process.HLT_PFMET130_PFMHT130_IDTight_v36, process.HLT_PFMET140_PFMHT140_IDTight_v36, process.HLT_PFMET120_PFMHT120_IDTight_PFHT60_v25, process.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_PFHT60_v25, process.HLT_PFMETTypeOne140_PFMHT140_IDTight_v27, process.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_v36, process.HLT_PFMETNoMu130_PFMHTNoMu130_IDTight_v35, process.HLT_PFMETNoMu140_PFMHTNoMu140_IDTight_v35, process.HLT_PFMETNoMu110_PFMHTNoMu110_IDTight_FilterHF_v16, process.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_FilterHF_v16, process.HLT_PFMETNoMu130_PFMHTNoMu130_IDTight_FilterHF_v16, process.HLT_PFMETNoMu140_PFMHTNoMu140_IDTight_FilterHF_v16, process.HLT_L1ETMHadSeeds_v11, process.HLT_CaloMHT90_v16, process.HLT_CaloMET90_NotCleaned_v16, process.HLT_CaloMET350_NotCleaned_v16, process.HLT_PFMET200_NotCleaned_v25, process.HLT_PFMET250_NotCleaned_v25, process.HLT_PFMET300_NotCleaned_v25, process.HLT_PFMET200_BeamHaloCleaned_v25, process.HLT_PFMETTypeOne200_BeamHaloCleaned_v25, process.HLT_MET105_IsoTrk50_v23, process.HLT_MET120_IsoTrk50_v23, process.HLT_Mu12eta2p3_v17, process.HLT_Mu12eta2p3_PFJet40_v17, process.HLT_Mu12_DoublePFJets40_PNetBTag_0p11_v10, process.HLT_Mu12_DoublePFJets100_PNetBTag_0p11_v10, process.HLT_Mu12_DoublePFJets200_PNetBTag_0p11_v10, process.HLT_Mu12_DoublePFJets350_PNetBTag_0p11_v10, process.HLT_Mu12_DoublePFJets40MaxDeta1p6_PNet2BTag_0p11_v10, process.HLT_Mu12_DoublePFJets54MaxDeta1p6_PNet2BTag_0p11_v10, process.HLT_DoublePFJets40_PNetBTag_0p11_v10, process.HLT_DoublePFJets100_PNetBTag_0p11_v10, process.HLT_DoublePFJets200_PNetBTag_0p11_v10, process.HLT_DoublePFJets350_PNetBTag_0p11_v10, process.HLT_DoublePFJets116MaxDeta1p6_PNet2BTag_0p11_v10, process.HLT_DoublePFJets128MaxDeta1p6_PNet2BTag_0p11_v10, process.HLT_Photon300_NoHE_v24, process.HLT_Mu8_TrkIsoVVL_v28, process.HLT_Mu8_DiEle12_CaloIdL_TrackIdL_DZ_v34, process.HLT_Mu8_DiEle12_CaloIdL_TrackIdL_v34, process.HLT_Mu8_Ele8_CaloIdM_TrackIdM_Mass8_PFHT350_DZ_v35, process.HLT_Mu8_Ele8_CaloIdM_TrackIdM_Mass8_PFHT350_v35, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_v29, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_v17, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v27, process.HLT_Mu17_TrkIsoVVL_v29, process.HLT_Mu19_TrkIsoVVL_v20, process.HLT_BTagMu_AK4DiJet20_Mu5_v29, process.HLT_BTagMu_AK4DiJet40_Mu5_v29, process.HLT_BTagMu_AK4DiJet70_Mu5_v29, process.HLT_BTagMu_AK4DiJet110_Mu5_v29, process.HLT_BTagMu_AK4DiJet170_Mu5_v28, process.HLT_BTagMu_AK4Jet300_Mu5_v28, process.HLT_BTagMu_AK8DiJet170_Mu5_v25, process.HLT_BTagMu_AK8Jet170_DoubleMu5_v18, process.HLT_BTagMu_AK8Jet300_Mu5_v28, process.HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v33, process.HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_v33, process.HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v31, process.HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v23, process.HLT_Mu12_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v23, process.HLT_Mu12_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_v31, process.HLT_Mu12_IsoVVL_PFHT150_PNetBTag0p53_v9, process.HLT_Photon33_v16, process.HLT_Photon50_v24, process.HLT_Photon75_v24, process.HLT_Photon90_v24, process.HLT_Photon120_v24, process.HLT_Photon150_v18, process.HLT_Photon175_v26, process.HLT_Photon200_v25, process.HLT_Photon45EB_v4, process.HLT_Photon40EB_v4, process.HLT_Photon50EB_v5, process.HLT_Photon30EB_TightID_TightIso_v15, process.HLT_Photon40EB_TightID_TightIso_v6, process.HLT_Photon45EB_TightID_TightIso_v6, process.HLT_Photon50EB_TightID_TightIso_PFJet30_v10, process.HLT_Photon50EB_TightID_TightIso_CaloJet30_v6, process.HLT_Photon50EB_TightID_TightIso_AK8PFJet30_v9, process.HLT_Photon50EB_TightID_TightIso_AK8CaloJet30_v6, process.HLT_Photon50EB_TightID_TightIso_v11, process.HLT_Photon55EB_TightID_TightIso_v7, process.HLT_Photon75EB_TightID_TightIso_v11, process.HLT_Photon90EB_TightID_TightIso_v11, process.HLT_Photon110EB_TightID_TightIso_v15, process.HLT_Photon110EB_TightID_TightIso_PFJet30_v10, process.HLT_Photon110EB_TightID_TightIso_CaloJet30_v6, process.HLT_Photon110EB_TightID_TightIso_AK8PFJet30_v9, process.HLT_Photon110EB_TightID_TightIso_AK8CaloJet30_v6, process.HLT_Photon100EBHE10_v13, process.HLT_Photon50_R9Id90_HE10_IsoM_v27, process.HLT_Photon75_R9Id90_HE10_IsoM_v27, process.HLT_Photon90_R9Id90_HE10_IsoM_v27, process.HLT_Photon120_R9Id90_HE10_IsoM_v27, process.HLT_Photon165_R9Id90_HE10_IsoM_v28, process.HLT_Diphoton30_22_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass90_v26, process.HLT_Diphoton30_22_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass95_v26, process.HLT_Photon35_TwoProngs35_v17, process.HLT_IsoMu24_TwoProngs35_v17, process.HLT_Dimuon0_Jpsi_L1_NoOS_v23, process.HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23, process.HLT_Dimuon0_Jpsi_v24, process.HLT_Dimuon0_Jpsi_NoVertexing_v24, process.HLT_Dimuon0_Jpsi_L1_4R_0er1p5R_v23, process.HLT_Dimuon0_Jpsi_NoVertexing_L1_4R_0er1p5R_v23, process.HLT_Dimuon0_Jpsi3p5_Muon2_v21, process.HLT_Dimuon0_Upsilon_L1_4p5_v25, process.HLT_Dimuon0_Upsilon_L1_4p5er2p0_v25, process.HLT_Dimuon0_Upsilon_L1_4p5er2p0M_v23, process.HLT_Dimuon0_Upsilon_NoVertexing_v23, process.HLT_Dimuon0_LowMass_L1_0er1p5_v24, process.HLT_Dimuon0_LowMass_v24, process.HLT_Dimuon0_LowMass_L1_4_v24, process.HLT_Dimuon0_LowMass_L1_TM530_v22, process.HLT_Dimuon0_Upsilon_Muon_NoL1Mass_v22, process.HLT_Dimuon0_Upsilon_v2, process.HLT_TripleMu_5_3_3_Mass3p8_DZ_v24, process.HLT_TripleMu_10_5_5_DZ_v26, process.HLT_TripleMu_12_10_5_v26, process.HLT_Tau3Mu_Mu7_Mu1_TkMu1_Tau15_v20, process.HLT_Tau3Mu_Mu7_Mu1_TkMu1_Tau15_Charge1_v20, process.HLT_Tau3Mu_Mu7_Mu1_TkMu1_IsoTau15_v20, process.HLT_Tau3Mu_Mu7_Mu1_TkMu1_IsoTau15_Charge1_v20, process.HLT_DoubleMu3_DZ_PFMET50_PFMHT60_v26, process.HLT_DoubleMu3_DZ_PFMET70_PFMHT70_v26, process.HLT_DoubleMu3_DZ_PFMET90_PFMHT90_v26, process.HLT_DoubleMu3_Trk_Tau3mu_NoL1Mass_v22, process.HLT_DoubleMu4_3_LowMass_SS_v10, process.HLT_DoubleMu4_Jpsi_Displaced_v23, process.HLT_DoubleMu4_Jpsi_NoVertexing_v23, process.HLT_DoubleMu4_JpsiTrkTrk_Displaced_v23, process.HLT_DoubleMu4_JpsiTrk_Bc_v16, process.HLT_DoubleMu43NoFiltersNoVtx_v17, process.HLT_DoubleMu48NoFiltersNoVtx_v17, process.HLT_Mu43NoFiltersNoVtx_Photon43_CaloIdL_v18, process.HLT_Mu48NoFiltersNoVtx_Photon48_CaloIdL_v18, process.HLT_Mu38NoFiltersNoVtxDisplaced_Photon38_CaloIdL_v14, process.HLT_Mu43NoFiltersNoVtxDisplaced_Photon43_CaloIdL_v14, process.HLT_Ele28_HighEta_SC20_Mass55_v27, process.HLT_Ele15_IsoVVVL_PFHT450_PFMET50_v32, process.HLT_Ele15_IsoVVVL_PFHT450_v32, process.HLT_Ele50_IsoVVVL_PFHT450_v32, process.HLT_Ele15_IsoVVVL_PFHT600_v36, process.HLT_Mu15_IsoVVVL_PFHT450_PFMET50_v31, process.HLT_Mu15_IsoVVVL_PFHT450_v31, process.HLT_Mu50_IsoVVVL_PFHT450_v31, process.HLT_Mu15_IsoVVVL_PFHT600_v35, process.HLT_Mu3er1p5_PFJet100er2p5_PFMET80_PFMHT80_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMET90_PFMHT90_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMET100_PFMHT100_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu80_PFMHTNoMu80_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu90_PFMHTNoMu90_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu100_PFMHTNoMu100_IDTight_v18, process.HLT_Dimuon10_Upsilon_y1p4_v17, process.HLT_Dimuon12_Upsilon_y1p4_v18, process.HLT_Dimuon14_Phi_Barrel_Seagulls_v23, process.HLT_Dimuon25_Jpsi_v30, process.HLT_Dimuon14_PsiPrime_v29, process.HLT_Dimuon14_PsiPrime_noCorrL1_v21, process.HLT_Dimuon18_PsiPrime_v30, process.HLT_Dimuon18_PsiPrime_noCorrL1_v22, process.HLT_Dimuon24_Upsilon_noCorrL1_v22, process.HLT_Dimuon24_Phi_noCorrL1_v22, process.HLT_Dimuon25_Jpsi_noCorrL1_v22, process.HLT_DiMu4_Ele9_CaloIdL_TrackIdL_DZ_Mass3p8_v33, process.HLT_DiMu9_Ele9_CaloIdL_TrackIdL_DZ_v33, process.HLT_DiMu9_Ele9_CaloIdL_TrackIdL_v33, process.HLT_DoubleIsoMu20_eta2p1_v23, process.HLT_TrkMu12_DoubleTrkMu5NoFiltersNoVtx_v21, process.HLT_Mu8_v28, process.HLT_Mu17_v29, process.HLT_Mu19_v20, process.HLT_Mu17_Photon30_IsoCaloId_v22, process.HLT_Ele8_CaloIdL_TrackIdL_IsoVL_PFJet30_v32, process.HLT_Ele12_CaloIdL_TrackIdL_IsoVL_PFJet30_v34, process.HLT_Ele14_eta2p5_IsoVVVL_Gsf_PFHT200_PNetBTag0p53_v9, process.HLT_Ele23_CaloIdL_TrackIdL_IsoVL_PFJet30_v34, process.HLT_Ele8_CaloIdM_TrackIdM_PFJet30_v34, process.HLT_Ele17_CaloIdM_TrackIdM_PFJet30_v32, process.HLT_Ele23_CaloIdM_TrackIdM_PFJet30_v34, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_PFJet165_v34, process.HLT_Ele115_CaloIdVT_GsfTrkIdT_v28, process.HLT_Ele135_CaloIdVT_GsfTrkIdT_v21, process.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_v25, process.HLT_PFHT400_SixPFJet32_v25, process.HLT_PFHT400_SixPFJet32_PNet2BTagMean0p50_v13, process.HLT_PFHT450_SixPFJet36_v24, process.HLT_PFHT450_SixPFJet36_PNetBTag0p35_v13, process.HLT_PFHT400_FivePFJet_120_120_60_30_30_v10, process.HLT_PFHT350_v35, process.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT350_v14, process.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT380_v14, process.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT400_v14, process.HLT_ECALHT800_v22, process.HLT_DiSC30_18_EIso_AND_HE_Mass70_v25, process.HLT_Photon20_HoverELoose_v21, process.HLT_Photon30_HoverELoose_v21, process.HLT_L1_CDC_SingleMu_3_er1p2_TOP120_DPHI2p618_3p142_v10, process.HLT_CDC_L2cosmic_10_er1p0_v11, process.HLT_CDC_L2cosmic_5p5_er1p0_v11, process.HLT_Photon60_R9Id90_HE10_IsoM_EBOnly_PFJetsMJJ300DEta3_v13, process.HLT_Photon75_R9Id90_HE10_IsoM_EBOnly_PFJetsMJJ300DEta3_v21, process.HLT_Mu18_Mu9_SameSign_v20, process.HLT_DoubleMu2_Jpsi_DoubleTrk1_Phi1p05_v22, process.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_v26, process.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_Mass2p0_v10, process.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_Mass2p0_noDCA_v10, process.HLT_TripleMu_5_3_3_Mass3p8_DCA_v19, process.HLT_QuadPFJet103_88_75_15_v21, process.HLT_QuadPFJet105_88_76_15_v21, process.HLT_QuadPFJet111_90_80_15_v21, process.HLT_Diphoton30_18_R9IdL_AND_HE_AND_IsoCaloId_v14, process.HLT_Diphoton30_18_R9IdL_AND_HE_AND_IsoCaloId_Mass55_v14, process.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Tight_eta2p3_CrossL1_v11, process.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Medium_eta2p3_CrossL1_v11, process.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Loose_eta2p3_CrossL1_v11, process.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_PNet3BTag_4p3_v9, process.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_PNet3BTag_2p0_v9, process.HLT_PFHT400_FivePFJet_120_120_60_30_30_PNet2BTag_5p6_v10, process.HLT_PFHT400_FivePFJet_120_120_60_30_30_PNet2BTag_4p3_v10, process.HLT_QuadPFJet103_88_75_15_PNetBTag_0p4_VBF2_v10, process.HLT_QuadPFJet103_88_75_15_PNet2BTag_0p4_0p12_VBF1_v10, process.HLT_QuadPFJet105_88_76_15_PNetBTag_0p4_VBF2_v10, process.HLT_QuadPFJet105_88_76_15_PNet2BTag_0p4_0p12_VBF1_v10, process.HLT_QuadPFJet111_90_80_15_PNetBTag_0p4_VBF2_v10, process.HLT_QuadPFJet111_90_80_15_PNet2BTag_0p4_0p12_VBF1_v10, process.HLT_PFHT250_QuadPFJet25_v10, process.HLT_PFHT250_QuadPFJet25_PNet2BTagMean0p55_v10, process.HLT_PFHT250_QuadPFJet25_PNet1BTag0p20_PNet1Tauh0p50_v10, process.HLT_PFHT250_QuadPFJet30_PNet2BTagMean0p55_v10, process.HLT_PFHT250_QuadPFJet30_PNet1BTag0p20_PNet1Tauh0p50_v10, process.HLT_PFHT280_QuadPFJet30_PNet1BTag0p20_PNet1Tauh0p50_v10, process.HLT_PFHT280_QuadPFJet30_v13, process.HLT_PFHT280_QuadPFJet30_PNet2BTagMean0p55_v13, process.HLT_PFHT280_QuadPFJet30_PNet2BTagMean0p60_v13, process.HLT_PFHT280_QuadPFJet35_PNet2BTagMean0p60_v13, process.HLT_PFHT340_QuadPFJet70_50_40_40_PNet2BTagMean0p70_v14, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_v13, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_QuadPFJet30_v13, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_QuadPFJet30_PNet2BTagMean0p55_v13, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PNet2BTagMean0p50_v13, process.HLT_QuadPFJet100_88_70_30_v14, process.HLT_QuadPFJet105_88_75_30_v13, process.HLT_QuadPFJet111_90_80_30_v13, process.HLT_QuadPFJet100_88_70_30_PNet1CvsAll0p5_VBF3Tight_v14, process.HLT_QuadPFJet105_88_75_30_PNet1CvsAll0p5_VBF3Tight_v14, process.HLT_QuadPFJet111_90_80_30_PNet1CvsAll0p6_VBF3Tight_v14, process.HLT_AK8PFJet220_SoftDropMass40_v17, process.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p50_v13, process.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p53_v13, process.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p55_v13, process.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p60_v13, process.HLT_AK8PFJet230_SoftDropMass40_v17, process.HLT_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, process.HLT_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, process.HLT_AK8PFJet230_SoftDropMass40_PNetTauTau0p03_v13, process.HLT_AK8PFJet230_SoftDropMass40_PNetTauTau0p05_v13, process.HLT_AK8PFJet250_SoftDropMass40_PNetBB0p06_v13, process.HLT_AK8PFJet250_SoftDropMass40_PNetBB0p10_v13, process.HLT_AK8PFJet250_SoftDropMass40_PNetTauTau0p03_v13, process.HLT_AK8PFJet250_SoftDropMass40_PNetTauTau0p05_v13, process.HLT_AK8PFJet275_SoftDropMass40_PNetBB0p06_v13, process.HLT_AK8PFJet275_SoftDropMass40_PNetBB0p10_v13, process.HLT_AK8PFJet275_SoftDropMass40_PNetTauTau0p03_v13, process.HLT_AK8PFJet275_SoftDropMass40_PNetTauTau0p05_v13, process.HLT_AK8PFJet275_Nch45_v10, process.HLT_AK8PFJet275_Nch40_v10, process.HLT_IsoMu50_AK8PFJet220_SoftDropMass40_v16, process.HLT_IsoMu50_AK8PFJet220_SoftDropMass40_PNetBB0p06_v13, process.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_v16, process.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, process.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet220_SoftDropMass40_v16, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet220_SoftDropMass40_PNetBB0p06_v13, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_v16, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_DoubleAK4PFJet60_30_v14, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_DoubleAK4PFJet60_30_PNet2BTagMean0p50_v14, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_v10, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_v10, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_PNet2BTagMean0p55_v10, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_PNet1BTag0p20_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Medium_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Tight_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_PFJet60_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_PFJet75_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Tight_eta2p3_CrossL1_ETau_Monitoring_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Medium_eta2p3_CrossL1_ETau_Monitoring_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Loose_eta2p3_CrossL1_ETau_Monitoring_v10, process.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Tight_eta2p3_CrossL1_v10, process.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Medium_eta2p3_CrossL1_v10, process.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Loose_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet20_eta2p2_SingleL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet45_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PFHT250_v10, process.HLT_IsoMu24_eta2p1_PFHT250_QuadPFJet25_v10, process.HLT_IsoMu24_eta2p1_PFHT250_QuadPFJet25_PNet1Tauh0p50_v10, process.HLT_IsoMu24_eta2p1_SinglePFJet25_PNet1Tauh0p50_v10, process.HLT_DoublePNetTauhPFJet30_Medium_L2NN_eta2p3_v10, process.HLT_DoublePNetTauhPFJet30_Tight_L2NN_eta2p3_v10, process.HLT_DoublePNetTauhPFJet26_L2NN_eta2p3_PFJet60_v10, process.HLT_DoublePNetTauhPFJet26_L2NN_eta2p3_PFJet75_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Loose_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Medium_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Tight_L2NN_eta2p3_CrossL1_v10, process.HLT_SinglePNetTauhPFJet130_Loose_L2NN_eta2p3_v10, process.HLT_SinglePNetTauhPFJet130_Medium_L2NN_eta2p3_v10, process.HLT_SinglePNetTauhPFJet130_Tight_L2NN_eta2p3_v10, process.HLT_DoubleL2Mu10NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v16, process.HLT_DoubleL2Mu12NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, process.HLT_DoubleL2Mu14NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, process.HLT_DoubleL3Mu16_10NoVtx_DxyMin0p01cm_v14, process.HLT_DoubleL3Mu18_10NoVtx_DxyMin0p01cm_v13, process.HLT_DoubleL3Mu20_10NoVtx_DxyMin0p01cm_v13, process.HLT_L2Mu10NoVtx_2Cha_v10, process.HLT_L2Mu10NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, process.HLT_L3Mu10NoVtx_v13, process.HLT_L3Mu10NoVtx_DxyMin0p01cm_v13, process.HLT_DoubleL2Mu_L3Mu16NoVtx_VetoL3Mu0DxyMax0p1cm_v13, process.HLT_DoubleL2Mu_L3Mu18NoVtx_VetoL3Mu0DxyMax0p1cm_v13, process.HLT_DoubleL2Mu10NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, process.HLT_DoubleL2Mu12NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, process.HLT_L2Mu10NoVtx_2Cha_CosmicSeed_v10, process.HLT_L2Mu10NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, process.HLT_DoubleL3dTksMu16_10NoVtx_DxyMin0p01cm_v14, process.HLT_L2Mu50NoVtx_3Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v8, process.HLT_L2Mu50NoVtx_3Cha_VetoL3Mu0DxyMax1cm_v8, process.HLT_L3Mu30NoVtx_DxyMin0p01cm_v6, process.HLT_L3Mu50NoVtx_DxyMin0p01cm_v6, process.HLT_L3dTksMu10_NoVtx_DxyMin0p01cm_v14, process.HLT_Mu20NoFiltersNoVtxDisplaced_Photon20_CaloCustomId_v14, process.HLT_DisplacedMu24_MediumChargedIsoDisplacedPFTauHPS24_v12, process.HLT_Photon34_R9Id90_CaloIdL_IsoL_DisplacedIdL_MediumChargedIsoDisplacedPFTauHPS34_v12, process.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS32_Trk1_eta2p1_v17, process.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS36_Trk1_eta2p1_v12, process.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS32_Trk1_eta2p1_noDxy_v12, process.HLT_IsoMu27_MediumChargedIsoDisplacedPFTauHPS24_eta2p1_SingleL1_v12, process.HLT_HT350_DelayedJet40_SingleDelay1p5To3p5nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay1p6To3p5nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay1p75To3p5nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay3nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay3p25nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay3p5nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay0p5nsInclusive_v11, process.HLT_HT430_DelayedJet40_SingleDelay1nsInclusive_v11, process.HLT_HT430_DelayedJet40_SingleDelay1To1p5nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay1p1To1p6nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay1p25To1p75nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay1p5nsInclusive_v11, process.HLT_HT430_DelayedJet40_SingleDelay2nsInclusive_v13, process.HLT_HT430_DelayedJet40_SingleDelay2p25nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay2p5nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay0p5nsTrackless_v12, process.HLT_HT430_DelayedJet40_SingleDelay1nsTrackless_v14, process.HLT_HT430_DelayedJet40_SingleDelay1p25nsTrackless_v10, process.HLT_HT430_DelayedJet40_SingleDelay1p5nsTrackless_v10, process.HLT_HT430_DelayedJet40_DoubleDelay0p5nsInclusive_v12, process.HLT_HT430_DelayedJet40_DoubleDelay1nsInclusive_v13, process.HLT_HT430_DelayedJet40_DoubleDelay1p25nsInclusive_v9, process.HLT_HT430_DelayedJet40_DoubleDelay1p5nsInclusive_v9, process.HLT_HT430_DelayedJet40_DoubleDelay0p5nsTrackless_v14, process.HLT_HT430_DelayedJet40_DoubleDelay0p75nsTrackless_v10, process.HLT_HT430_DelayedJet40_DoubleDelay1nsTrackless_v10, process.HLT_L1Tau_DelayedJet40_SingleDelay2p5To4nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay2p6To4nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay2p75To4nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay3p5nsInclusive_v11, process.HLT_L1Tau_DelayedJet40_SingleDelay3p75nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay4nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay2p5nsTrackless_v12, process.HLT_L1Tau_DelayedJet40_SingleDelay2p75nsTrackless_v10, process.HLT_L1Tau_DelayedJet40_SingleDelay3nsTrackless_v10, process.HLT_L1Tau_DelayedJet40_DoubleDelay0p75nsInclusive_v11, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p25nsInclusive_v11, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p5nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p75nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_DoubleDelay0p5nsTrackless_v12, process.HLT_L1Tau_DelayedJet40_DoubleDelay1nsTrackless_v12, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p25nsTrackless_v10, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p5nsTrackless_v10, process.HLT_L1Mu6HT240_v10, process.HLT_Mu6HT240_DisplacedDijet30_Inclusive1PtrkShortSig5_DisplacedLoose_v14, process.HLT_Mu6HT240_DisplacedDijet35_Inclusive0PtrkShortSig5_v14, process.HLT_Mu6HT240_DisplacedDijet35_Inclusive1PtrkShortSig5_DisplacedLoose_v14, process.HLT_Mu6HT240_DisplacedDijet40_Inclusive0PtrkShortSig5_v14, process.HLT_Mu6HT240_DisplacedDijet40_Inclusive1PtrkShortSig5_DisplacedLoose_v14, process.HLT_Mu6HT240_DisplacedDijet45_Inclusive0PtrkShortSig5_v14, process.HLT_Mu6HT240_DisplacedDijet50_Inclusive0PtrkShortSig5_v14, process.HLT_HT350_v9, process.HLT_HT425_v21, process.HLT_HT360_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, process.HLT_HT360_DisplacedDijet45_Inclusive1PtrkShortSig5_v10, process.HLT_HT390_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, process.HLT_HT390_DisplacedDijet45_Inclusive1PtrkShortSig5_v10, process.HLT_HT390eta2p0_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, process.HLT_HT430_DisplacedDijet40_Inclusive1PtrkShortSig5_v14, process.HLT_HT400_DisplacedDijet40_DisplacedTrack_v26, process.HLT_HT430_DisplacedDijet40_DisplacedTrack_v26, process.HLT_HT550_DisplacedDijet60_Inclusive_v26, process.HLT_HT650_DisplacedDijet60_Inclusive_v26, process.HLT_CaloMET60_DTCluster50_v13, process.HLT_CaloMET60_DTClusterNoMB1S50_v13, process.HLT_L1MET_DTCluster50_v13, process.HLT_L1MET_DTClusterNoMB1S50_v13, process.HLT_CscCluster_Loose_v11, process.HLT_CscCluster_Medium_v11, process.HLT_CscCluster_Tight_v11, process.HLT_CscCluster50_Photon20Unseeded_v5, process.HLT_CscCluster50_Photon30Unseeded_v5, process.HLT_CscCluster100_Ele5_v7, process.HLT_CscCluster100_Mu5_v10, process.HLT_CscCluster100_PNetTauhPFJet10_Loose_v10, process.HLT_CscCluster150_DisplacedSingleJet30_Inclusive1PtrkShortSig5_v3, process.HLT_CscCluster150_DisplacedSingleJet35_Inclusive1PtrkShortSig5_v3, process.HLT_CscCluster150_DisplacedSingleJet40_Inclusive1PtrkShortSig5_v3, process.HLT_DoubleCscCluster75_v8, process.HLT_IsoTrk200_L1SingleMuShower_v8, process.HLT_IsoTrk400_L1SingleMuShower_v8, process.HLT_DoubleCscCluster100_v8, process.HLT_L1CSCShower_DTCluster50_v11, process.HLT_L1CSCShower_DTCluster75_v11, process.HLT_PFMET105_IsoTrk50_v17, process.HLT_L1SingleLLPJet_v8, process.HLT_L1SingleMuShower_v1, process.HLT_HT170_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, process.HLT_HT200_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, process.HLT_HT200_L1SingleLLPJet_DisplacedDijet60_DisplacedTrack_v14, process.HLT_HT270_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, process.HLT_HT200_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v14, process.HLT_HT240_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11, process.HLT_HT280_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11, process.HLT_HT320_L1SingleLLPJet_DisplacedDijet60_Inclusive_v14, process.HLT_HT420_L1SingleLLPJet_DisplacedDijet60_Inclusive_v14, process.HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay1nsTrackless_v14, process.HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay2nsInclusive_v14, process.HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay0p5nsTrackless_v14, process.HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay1nsInclusive_v14, process.HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p7_v10, process.HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p8_v10, process.HLT_DiPhoton10Time1ns_v11, process.HLT_DiPhoton10Time1p2ns_v11, process.HLT_DiPhoton10Time1p4ns_v11, process.HLT_DiPhoton10Time1p6ns_v11, process.HLT_DiPhoton10Time1p8ns_v11, process.HLT_DiPhoton10Time2ns_v11, process.HLT_DiPhoton10_CaloIdL_v11, process.HLT_DiphotonMVA14p25_Low_Mass60_v1, process.HLT_DiphotonMVA14p25_Medium_Mass60_v1, process.HLT_DiphotonMVA14p25_High_Mass60_v1, process.HLT_DiphotonMVA14p25_TightLow_Mass60_v1, process.HLT_DiphotonMVA14p25_TightMedium_Mass60_v1, process.HLT_DiphotonMVA14p25_TightHigh_Mass60_v1, process.HLT_Diphoton15_10_EBEB_TightID_ECALTrackIsoDr0p2_v3, process.HLT_Diphoton15_12_EBEB_TightID_ECALTrackIsoDr0p2_v3, process.HLT_Diphoton15_10_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v3, process.HLT_Diphoton15_12_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v3, process.HLT_Dielectron12_5_EBEB_TightID_ECALTrackIsoDr0p2_v4, process.HLT_Dielectron12_5_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v4, process.HLT_DoubleEle6p5_eta1p22_mMax6_v13, process.HLT_DoubleEle8_eta1p22_mMax6_v13, process.HLT_DoubleEle10_eta1p22_mMax6_v13, process.HLT_SingleEle8_v12, process.HLT_SingleEle8_SingleEGL1_v12, process.HLT_Diphoton20_14_eta1p5_R9IdL_AND_HE_AND_IsoTCaloIdT_v13, process.HLT_Diphoton20_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, process.HLT_Diphoton22_14_eta1p5_R9IdL_AND_HE_AND_IsoTCaloIdT_v13, process.HLT_Diphoton22_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, process.HLT_Diphoton24_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, process.HLT_Diphoton24_16_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, process.HLT_Mu50_L1SingleMuShower_v15, process.HLT_IsoMu24_OneProng32_v13, process.HLT_Photon32_OneProng32_M50To105_v14, process.HLT_VBF_DiPFJet125_45_Mjj1050_v12, process.HLT_VBF_DiPFJet125_45_Mjj1150_v4, process.HLT_VBF_DiPFJet125_45_Mjj1250_v4, process.HLT_VBF_DiPFJet75_45_Mjj800_DiPFJet60_v10, process.HLT_VBF_DiPFJet75_45_Mjj900_DiPFJet60_v4, process.HLT_VBF_DiPFJet75_45_Mjj1000_DiPFJet60_v4, process.HLT_VBF_DiPFJet80_45_Mjj650_PFMETNoMu85_v10, process.HLT_VBF_DiPFJet80_45_Mjj750_PFMETNoMu85_v10, process.HLT_VBF_DiPFJet80_45_Mjj850_PFMETNoMu85_v4, process.HLT_VBF_DiPFJet95_45_Mjj750_Mu3_TrkIsoVVL_v10, process.HLT_VBF_DiPFJet95_45_Mjj850_Mu3_TrkIsoVVL_v10, process.HLT_VBF_DiPFJet95_45_Mjj950_Mu3_TrkIsoVVL_v4, process.HLT_VBF_DiPFJet50_Mjj650_Photon22_v10, process.HLT_VBF_DiPFJet50_Mjj750_Photon22_v10, process.HLT_VBF_DiPFJet50_Mjj850_Photon22_v4, process.HLT_VBF_DiPFJet50_Mjj600_Ele22_eta2p1_WPTight_Gsf_v11, process.HLT_VBF_DiPFJet50_Mjj700_Ele22_eta2p1_WPTight_Gsf_v5, process.HLT_VBF_DiPFJet50_Mjj800_Ele22_eta2p1_WPTight_Gsf_v5, process.HLT_VBF_DiPFJet115_40_Mjj850_DoublePNetTauhPFJet20_eta2p3_v4, process.HLT_VBF_DiPFJet115_40_Mjj1000_DoublePNetTauhPFJet20_eta2p3_v4, process.HLT_VBF_DiPFJet115_40_Mjj1100_DoublePNetTauhPFJet20_eta2p3_v4, process.HLT_VBF_DiPFJet115_40_Mjj1200_DoublePNetTauhPFJet20_eta2p3_v4, process.HLT_VBF_DiPFJet45_Mjj650_PNetTauhPFJet45_L2NN_eta2p3_v10, process.HLT_VBF_DiPFJet45_Mjj750_PNetTauhPFJet45_L2NN_eta2p3_v10, process.HLT_VBF_DiPFJet45_Mjj850_PNetTauhPFJet45_L2NN_eta2p3_v4, process.HLT_L1HT200_QuadPFJet20_PNet1BTag0p50_PNet1Tauh0p50_v4, process.HLT_L1HT200_QuadPFJet25_PNet1BTag0p50_PNet1Tauh0p50_v4, process.HLT_IsoMu24_eta2p1_L1HT200_v4, process.HLT_IsoMu24_eta2p1_L1HT200_QuadPFJet25_v4, process.HLT_IsoMu24_eta2p1_L1HT200_QuadPFJet25_PNet1Tauh0p50_v4, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_v4, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet20_v4, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet25_v4, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet25_PNet1BTag0p50_v4, process.HLT_PFJet200_TimeLtNeg2p5ns_v14, process.HLT_PFJet200_TimeGt2p5ns_v14, process.HLT_Photon50_TimeLtNeg2p5ns_v8, process.HLT_Photon50_TimeGt2p5ns_v8, process.HLT_PPSMaxTracksPerArm1_v10, process.HLT_PPSMaxTracksPerRP4_v10, process.HLT_PPSRandom_v1, process.HLT_HIL1NotBptxOR_v15, process.HLT_HIL1UnpairedBunchBptxPlus_v15, process.HLT_HIL1UnpairedBunchBptxMinus_v15, process.HLT_HIPhysics_v15, process.HLT_HIPhysicsForZS_v15, process.HLT_HIRandom_v8, process.HLT_HIRandom_HighRate_v4, process.HLT_HIHcalNZS_v15, process.HLT_HIHcalPhiSym_v15, process.HLT_HIZeroBias_v15, process.HLT_HIZeroBias_HighRate_v8, process.HLT_HIZeroBias_FirstCollisionAfterAbortGap_v15, process.HLT_HIZeroBias_HighRateRAW_v5, process.HLT_HIMinimumBiasHF1AND_v8, process.HLT_HIMinimumBiasHF1AND_copy_v7, process.HLT_HIMinimumBiasHF1ANDZDC1nOR_v5, process.HLT_HIMinimumBiasHF1ANDZDC2nOR_v8, process.HLT_HIMinimumBiasHF1ANDZDC1nOR_copy_v5, process.HLT_HIMinimumBiasHF1ANDZDC2nOR_copy_v7, process.HLT_HICentrality30100_FirstCollisionAfterAbortGap_v15, process.HLT_HICentrality50100MinimumBiasHF1AND_Beamspot_v2, process.HLT_HIL1Centrality30_50_v8, process.HLT_HIL1_UCC_0_0p5_v9, process.HLT_HIL1_UCC_0_1_v9, process.HLT_HIPuAK4CaloJet40Eta5p1_MinBiasHF1AND_v8, process.HLT_HIPuAK4CaloJet40Eta5p1_MinBiasHF1AND_ZDC1nOR_v6, process.HLT_HIPuAK4CaloJet40Eta5p1_MinBiasHF1AND_ZDC2nOR_v8, process.HLT_HIPuAK4CaloJet60Eta5p1_MinBiasHF1AND_v8, process.HLT_HIPuAK4CaloJet60Eta5p1_MinBiasHF1AND_ZDC1nOR_v6, process.HLT_HIPuAK4CaloJet60Eta5p1_MinBiasHF1AND_ZDC2nOR_v8, process.HLT_HIPuAK4CaloJet80Eta5p1_v16, process.HLT_HIPuAK4CaloJet100Eta5p1_v16, process.HLT_HIPuAK4CaloJet120Eta2p1_v9, process.HLT_HIPuAK4CaloJet120Eta5p1_v16, process.HLT_HIPuAK4CaloJet40Fwd_v9, process.HLT_HIPuAK4CaloJet60Fwd_v9, process.HLT_HIPuAK4CaloJet80Fwd_v9, process.HLT_HIPuAK4CaloJet100Fwd_v9, process.HLT_HIPuAK4CaloJet120Fwd_v9, process.HLT_HIGEDPhoton10_v16, process.HLT_HIGEDPhoton10_EB_v16, process.HLT_HIGEDPhoton20_v16, process.HLT_HIGEDPhoton20_EB_v16, process.HLT_HIGEDPhoton30_v16, process.HLT_HIGEDPhoton30_EB_v16, process.HLT_HIGEDPhoton40_v16, process.HLT_HIGEDPhoton40_EB_v16, process.HLT_HIGEDPhoton50_v16, process.HLT_HIGEDPhoton50_EB_v16, process.HLT_HIGEDPhoton60_v16, process.HLT_HIGEDPhoton60_EB_v16, process.HLT_HIDoubleGEDPhoton20_v9, process.HLT_HIEle10Gsf_v16, process.HLT_HIEle15Gsf_v16, process.HLT_HIEle20Gsf_v16, process.HLT_HIEle30Gsf_v16, process.HLT_HIEle40Gsf_v16, process.HLT_HIEle50Gsf_v16, process.HLT_HIEle15Ele10Gsf_v16, process.HLT_HIEle15Ele10GsfMass50_v16, process.HLT_HIDoubleEle10Gsf_v16, process.HLT_HIDoubleEle10GsfMass50_v16, process.HLT_HIDoubleEle15Gsf_v16, process.HLT_HIDoubleEle15GsfMass50_v16, process.HLT_HIUPC_ZeroBias_MinPixelCluster400_MaxPixelCluster10000_v15, process.HLT_HIUPC_ZeroBias_SinglePixelTrackLowPt_MaxPixelCluster400_v14, process.HLT_HIUPC_ZeroBias_SinglePixelTrack_MaxPixelTrack_v15, process.HLT_HIUPC_NotMBHF2_v6, process.HLT_HIUPC_ZDC1nOR_MinPixelCluster400_MaxPixelCluster10000_v15, process.HLT_HIUPC_ZDC1nOR_SinglePixelTrackLowPt_MaxPixelCluster400_v14, process.HLT_HIUPC_ZDC1nOR_SinglePixelTrack_MaxPixelTrack_v15, process.HLT_HIUPC_ZDC1nXOR_MBHF1AND_PixelTrackMultiplicity20_v15, process.HLT_HIUPC_ZDC1nXOR_MBHF1AND_PixelTrackMultiplicity30_v15, process.HLT_HIUPC_ZDC1nXOR_MBHF1AND_PixelTrackMultiplicity40_v15, process.HLT_HIUPC_ZDC1nXOR_MBHF2AND_PixelTrackMultiplicity20_v15, process.HLT_HIUPC_ZDC1nXOR_MBHF2AND_PixelTrackMultiplicity30_v15, process.HLT_HIUPC_ZDC1nXOR_MBHF2AND_PixelTrackMultiplicity40_v15, process.HLT_HIUPC_ZDC1nAsymXOR_MBHF1AND_PixelTrackMultiplicity20_v7, process.HLT_HIUPC_ZDC1nAsymXOR_MBHF1AND_PixelTrackMultiplicity30_v7, process.HLT_HIUPC_ZDC1nAsymXOR_MBHF1AND_PixelTrackMultiplicity40_v7, process.HLT_HIUPC_ZDC1nAsymXOR_MBHF2AND_PixelTrackMultiplicity20_v7, process.HLT_HIUPC_ZDC1nAsymXOR_MBHF2AND_PixelTrackMultiplicity30_v7, process.HLT_HIUPC_ZDC1nAsymXOR_MBHF2AND_PixelTrackMultiplicity40_v7, process.HLT_HIUPC_SingleMuCosmic_BptxAND_MaxPixelCluster1000_v8, process.HLT_HIUPC_SingleMuCosmic_NotMBHF2AND_v11, process.HLT_HIUPC_SingleMuCosmic_NotMBHF2AND_MaxPixelCluster1000_v8, process.HLT_HIUPC_SingleMuCosmic_NotMBHF2OR_v11, process.HLT_HIUPC_SingleMuCosmic_NotMBHF2OR_MaxPixelCluster1000_v8, process.HLT_HIUPC_SingleMuOpen_BptxAND_MaxPixelCluster1000_v8, process.HLT_HIUPC_SingleMuOpen_NotMBHF2AND_v13, process.HLT_HIUPC_SingleMuOpen_NotMBHF2AND_MaxPixelCluster1000_v8, process.HLT_HIUPC_SingleMuOpen_NotMBHF2OR_v13, process.HLT_HIUPC_SingleMuOpen_NotMBHF2OR_MaxPixelCluster1000_v8, process.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_BptxAND_MaxPixelCluster1000_v8, process.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2AND_v11, process.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2AND_MaxPixelCluster1000_v8, process.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2OR_v11, process.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2OR_MaxPixelCluster1000_v8, process.HLT_HIUPC_DoubleMuCosmic_BptxAND_MaxPixelCluster1000_v8, process.HLT_HIUPC_DoubleMuCosmic_NotMBHF2AND_MaxPixelCluster1000_v8, process.HLT_HIUPC_DoubleMuCosmic_NotMBHF2AND_v11, process.HLT_HIUPC_DoubleMuOpen_BptxAND_MaxPixelCluster1000_v8, process.HLT_HIUPC_DoubleMuOpen_NotMBHF2AND_v11, process.HLT_HIUPC_DoubleMuOpen_NotMBHF2AND_MaxPixelCluster1000_v8, process.HLT_HIUPC_SingleEG2_NotMBHF2AND_ZDC1nOR_SinglePixelTrack_MaxPixelTrack_v14, process.HLT_HIUPC_SingleEG3_BptxAND_SinglePixelTrack_MaxPixelTrack_v17, process.HLT_HIUPC_SingleEG3_NotMBHF2AND_v13, process.HLT_HIUPC_SingleEG3_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v16, process.HLT_HIUPC_SingleEG3_NotMBHF2OR_v13, process.HLT_HIUPC_SingleEG3_NotMBHF2OR_SinglePixelTrack_MaxPixelTrack_v16, process.HLT_HIUPC_SingleEG5_BptxAND_SinglePixelTrack_MaxPixelTrack_v17, process.HLT_HIUPC_SingleEG4_NotMBHF2AND_v2, process.HLT_HIUPC_SingleEG5_NotMBHF2AND_v13, process.HLT_HIUPC_SingleEG5_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v16, process.HLT_HIUPC_DoubleEG2_BptxAND_SinglePixelTrack_MaxPixelTrack_v17, process.HLT_HIUPC_DoubleEG2_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v16, process.HLT_HIUPC_DoubleEG2_NotMBHF2AND_v13, process.HLT_HIUPC_DoubleEG3_NotMBHF2AND_v1, process.HLT_HIUPC_DoubleEG3_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v2, process.HLT_HIUPC_DoubleEG5_BptxAND_SinglePixelTrack_MaxPixelTrack_v17, process.HLT_HIUPC_DoubleEG5_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v16, process.HLT_HIUPC_DoubleEG5_NotMBHF2AND_v13, process.HLT_HIUPC_SingleJet8_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet12_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet16_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet20_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet24_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet28_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet8_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet12_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet16_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet20_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet24_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet28_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet8_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet12_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet16_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet20_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet24_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet28_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_ZeroBias_MaxPixelCluster10000_v4, process.HLT_HIUPC_ZDC1nOR_MaxPixelCluster10000_v4, process.HLT_HIUPC_ZDC1nOR_MBHF1AND_PixelTrackMultiplicity20400_v4, process.HLT_HIUPC_ZDC1nOR_MBHF1AND_PixelTrackMultiplicity30400_v4, process.HLT_HIUPC_ZDC1nOR_MBHF1AND_PixelTrackMultiplicity40400_v4, process.HLT_HIUPC_ZDC1nAND_NotMBHF2_MaxPixelCluster10000_v4, process.HLT_HIUPC_MinPixelThrust0p8_MaxPixelCluster10000_v4, process.HLT_HIUPC_SingleUncorrJet8_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet12_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet16_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet20_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet24_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet28_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet8_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet12_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet16_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet20_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet24_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet28_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet8_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet12_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet16_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet20_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet24_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet28_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleUncorrJet8_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleUncorrJet12_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleUncorrJet16_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleUncorrJet8_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleUncorrJet12_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleUncorrJet16_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleUncorrJet8_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleUncorrJet12_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleUncorrJet16_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, process.HLT_HIUPC_ZDC1nOR_RapGap_MaxPixelCluster10000_v4, process.HLT_HIUPC_SingleJet8_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet12_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet16_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet20_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet24_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet28_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet8_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet12_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet16_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet20_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet24_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet28_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet8_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet12_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet16_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet20_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet24_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet28_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleJet8_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleJet12_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleJet16_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleJet8_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleJet12_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleJet16_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleJet8_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleJet12_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleJet16_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_Random_HighRate_v2, process.HLT_HIUPC_HFafterglowCombined_v2, process.HLT_HIL1SingleMuOpen_Centrality30to100_v2, process.HLT_HIL1SingleMu0_Centrality30to100_v2, process.HLT_HIL1SingleMu0_Centrality40to100_v2, process.HLT_HIL1SingleMu0_v8, process.HLT_HIL1SingleMu0_Open_v8, process.HLT_HIL1SingleMu0_Cosmic_v8, process.HLT_HIL1SingleMu5_SingleEG20Gsf_v9, process.HLT_HIL1SingleMu5_SingleGEDPhoton20_v9, process.HLT_HIL1SingleMu7_SingleEG20Gsf_v9, process.HLT_HIL1SingleMu7_SingleGEDPhoton20_v3, process.HLT_HIL2DoubleMuOpen_Centrality40to100_v2, process.HLT_HIL2DoubleMuOpen_SS_v2, process.HLT_HIL2DoubleMuOpen_OS_v2, process.HLT_HIL1DoubleMu0_v8, process.HLT_HIL2DoubleMu0_SQ_v2, process.HLT_HIL1DoubleMu0_MaxDr3p5_Open_v8, process.HLT_HIL1DoubleMu0_SQ_v8, process.HLT_HIL2SingleMuOpen_Centrality30to100_v2, process.HLT_HIL2SingleMu0_Centrality30to100_v2, process.HLT_HIL2SingleMu0_Centrality40to100_v2, process.HLT_HIL2SingleMu3_Open_v8, process.HLT_HIL2SingleMu5_v8, process.HLT_HIL2SingleMu7_v8, process.HLT_HIL2SingleMu12_v2, process.HLT_HIL2DoubleMu0_Open_v8, process.HLT_HIL2DoubleMu0_M1p5to6_Open_v8, process.HLT_HIL2DoubleMu0_M7to15_Open_v8, process.HLT_HIL2DoubleMu2p8_M1p5to6_Open_v8, process.HLT_HIL2DoubleMu3_M7to15_Open_v8, process.HLT_HIDmesonPPOnAATrackingGlobal_Dpt30_v10, process.HLT_HIDmesonPPOnAATrackingGlobal_Dpt45_v10, process.HLT_HIDmesonPPOnAATrackingGlobal_Dpt60_v10, process.HLT_HICscCluster_Loose_v8, process.HLT_HICscCluster_Medium_v8, process.HLT_HICscCluster_Tight_v8, process.HLT_HIL1UnpairedBunchBptxMinusForPPRef_v10, process.HLT_HIL1UnpairedBunchBptxPlusForPPRef_v10, process.HLT_HIL1NotBptxORForPPRef_v10, process.HLT_HIHT80_Beamspot_ppRef5TeV_v19, process.HLT_PPRefZeroBias_v7, process.HLT_AK4CaloJet40_v8, process.HLT_AK4CaloJet60_v8, process.HLT_AK4CaloJet70_v8, process.HLT_AK4CaloJet80_v8, process.HLT_AK4CaloJet100_v8, process.HLT_AK4CaloJet120_v8, process.HLT_AK4CaloJetFwd40_v8, process.HLT_AK4CaloJetFwd60_v8, process.HLT_AK4CaloJetFwd70_v8, process.HLT_AK4CaloJetFwd80_v8, process.HLT_AK4CaloJetFwd100_v8, process.HLT_AK4CaloJetFwd120_v8, process.HLT_AK4PFJet40_v12, process.HLT_AK4PFJet60_v12, process.HLT_AK4PFJet80_v12, process.HLT_AK4PFJet100_v12, process.HLT_AK4PFJet120_v12, process.HLT_AK4PFJetFwd40_v12, process.HLT_AK4PFJetFwd60_v12, process.HLT_AK4PFJetFwd80_v12, process.HLT_AK4PFJetFwd100_v12, process.HLT_AK4PFJetFwd120_v12, process.HLT_PPRefDoubleEle10Gsf_v10, process.HLT_PPRefDoubleEle10GsfMass50_v10, process.HLT_PPRefDoubleEle15Gsf_v10, process.HLT_PPRefDoubleEle15GsfMass50_v10, process.HLT_PPRefEle15Ele10Gsf_v10, process.HLT_PPRefEle15Ele10GsfMass50_v10, process.HLT_PPRefEle10Gsf_v10, process.HLT_PPRefEle15Gsf_v10, process.HLT_PPRefEle20Gsf_v11, process.HLT_PPRefEle30Gsf_v11, process.HLT_PPRefEle40Gsf_v10, process.HLT_PPRefEle50Gsf_v10, process.HLT_PPRefGEDPhoton10_v8, process.HLT_PPRefGEDPhoton10_EB_v8, process.HLT_PPRefGEDPhoton20_v8, process.HLT_PPRefGEDPhoton20_EB_v8, process.HLT_PPRefGEDPhoton30_v8, process.HLT_PPRefGEDPhoton30_EB_v8, process.HLT_PPRefGEDPhoton40_v8, process.HLT_PPRefGEDPhoton40_EB_v8, process.HLT_PPRefGEDPhoton50_v8, process.HLT_PPRefGEDPhoton50_EB_v8, process.HLT_PPRefGEDPhoton60_v8, process.HLT_PPRefGEDPhoton60_EB_v8, process.HLT_PPRefDoubleGEDPhoton20_v3, process.HLT_PPRefL1DoubleMu0_v7, process.HLT_PPRefL1DoubleMu0_SQ_v2, process.HLT_PPRefL1DoubleMu0_Open_v7, process.HLT_PPRefL1DoubleMu2_v2, process.HLT_PPRefL1DoubleMu2_SQ_v2, process.HLT_PPRefL1SingleMu0_Cosmics_v7, process.HLT_PPRefL1SingleMu7_v7, process.HLT_PPRefL1SingleMu12_v7, process.HLT_PPRefL1SingleMu5_Ele20Gsf_v5, process.HLT_PPRefL1SingleMu5_GEDPhoton20_v3, process.HLT_PPRefL1SingleMu7_Ele20Gsf_v5, process.HLT_PPRefL1SingleMu7_GEDPhoton10_v3, process.HLT_PPRefL2DoubleMu0_v7, process.HLT_PPRefL2DoubleMu0_Open_v7, process.HLT_PPRefL2SingleMu7_v7, process.HLT_PPRefL2SingleMu12_v7, process.HLT_PPRefL2SingleMu15_v7, process.HLT_PPRefL2SingleMu20_v7, process.HLT_PPRefL3DoubleMu0_v12, process.HLT_PPRefL3DoubleMu0_Open_v12, process.HLT_PPRefL3SingleMu3_v12, process.HLT_PPRefL3SingleMu5_v12, process.HLT_PPRefL3SingleMu7_v12, process.HLT_PPRefL3SingleMu12_v12, process.HLT_PPRefL3SingleMu15_v12, process.HLT_PPRefL3SingleMu20_v12, process.HLT_PPRefL3SingleMu3_SingleAK4CaloJet40_v5, process.HLT_PPRefL3SingleMu3_SingleAK4CaloJet60_v5, process.HLT_PPRefL3SingleMu3_SingleAK4CaloJet80_v5, process.HLT_PPRefL3SingleMu5_SingleAK4CaloJet40_v5, process.HLT_PPRefL3SingleMu5_SingleAK4CaloJet60_v5, process.HLT_PPRefL3SingleMu5_SingleAK4CaloJet80_v5, process.HLT_PPRefCscCluster_Loose_v7, process.HLT_PPRefCscCluster_Medium_v7, process.HLT_PPRefCscCluster_Tight_v7, process.HLT_PPRefUPC_SingleJet8_ZDC1nAsymXOR_v2, process.HLT_PPRefUPC_SingleJet12_ZDC1nAsymXOR_v2, process.HLT_PPRefUPC_SingleJet16_ZDC1nAsymXOR_v2, process.HLT_PPRefUPC_SingleJet20_ZDC1nAsymXOR_v2, process.HLT_PPRefUPC_SingleJet24_ZDC1nAsymXOR_v2, process.HLT_PPRefUPC_SingleJet28_ZDC1nAsymXOR_v2, process.HLT_PPRefUPC_SingleJet8_ZDC1nOR_v2, process.HLT_PPRefUPC_SingleJet12_ZDC1nOR_v2, process.HLT_PPRefUPC_SingleJet16_ZDC1nOR_v2, process.HLT_PPRefUPC_SingleJet20_ZDC1nOR_v2, process.HLT_PPRefUPC_SingleJet24_ZDC1nOR_v2, process.HLT_PPRefUPC_SingleJet28_ZDC1nOR_v2, process.HLT_PPRefUPC_ZDC1nAsymXOR_v2, process.HLT_PPRefUPC_ZDC1nOR_v2, process.HLT_PPRefZeroBias_FirstCollisionInTrain_v1, process.HLT_TestData_v1, process.MC_ReducedIterativeTracking_v26, process.MC_AK4CaloJets_v21, process.MC_AK4CaloJetsFromPV_v21, process.MC_CaloHT_v20, process.MC_AK8CaloHT_v20, process.MC_CaloMHT_v20, process.MC_AK4PFJets_v33, process.MC_PFHT_v32, process.MC_AK8PFJets_v33, process.MC_AK8PFHT_v32, process.MC_CaloMET_v20, process.MC_CaloMET_JetIdCleaned_v21, process.MC_PFMET_v33, process.MC_PFMHT_v32, process.MC_AK4PFJetPNet_v9, process.MC_AK8PFJetPNet_v9, process.MC_Egamma_Open_v12, process.MC_Egamma_Open_Unseeded_v12, process.MC_Ele5_WPTight_Gsf_v23, process.MC_Ele15_Ele10_CaloIdL_TrackIdL_IsoVL_DZ_v29, process.MC_Diphoton10_10_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass10_v26, process.MC_DoubleEle5_CaloIdL_MW_v29, process.MC_IsoMu_v31, process.MC_DoubleMu_TrkIsoVVL_DZ_v27, process.MC_DoubleMuNoFiltersNoVtx_v20, process.MC_PFScouting_v10, process.HLT_SpecialHLTPhysics_v8, process.AlCa_LumiPixelsCounts_RandomHighRate_v6, process.AlCa_LumiPixelsCounts_ZeroBiasVdM_v6, process.AlCa_LumiPixelsCounts_ZeroBiasGated_v7, process.HLT_L1AlwaysTrue_v1, process.HLT_L1SingleMuOpen_v7, process.HLT_L1SingleMuOpen_DT_v7, process.HLT_L1SingleMu3_v6, process.HLT_L1SingleMu5_v6, process.HLT_L1SingleMu7_v6, process.HLT_L1DoubleMu0_v6, process.HLT_L1SingleJet8erHE_v6, process.HLT_L1SingleJet10erHE_v6, process.HLT_L1SingleJet12erHE_v6, process.HLT_L1SingleJet35_v6, process.HLT_L1SingleJet200_v6, process.HLT_L1SingleEG8er2p5_v5, process.HLT_L1SingleEG10er2p5_v5, process.HLT_L1SingleEG15er2p5_v5, process.HLT_L1SingleEG26er2p5_v5, process.HLT_L1SingleEG28er2p5_v5, process.HLT_L1SingleEG28er2p1_v5, process.HLT_L1SingleEG28er1p5_v5, process.HLT_L1SingleEG34er2p5_v5, process.HLT_L1SingleEG36er2p5_v5, process.HLT_L1SingleEG38er2p5_v5, process.HLT_L1SingleEG40er2p5_v5, process.HLT_L1SingleEG42er2p5_v5, process.HLT_L1SingleEG45er2p5_v5, process.HLT_L1SingleEG50_v5, process.HLT_L1SingleJet60_v5, process.HLT_L1SingleJet90_v5, process.HLT_L1SingleJet120_v5, process.HLT_L1SingleJet180_v5, process.HLT_L1HTT120er_v5, process.HLT_L1HTT160er_v5, process.HLT_L1HTT200er_v5, process.HLT_L1HTT255er_v5, process.HLT_L1HTT280er_v5, process.HLT_L1HTT320er_v5, process.HLT_L1HTT360er_v5, process.HLT_L1HTT400er_v5, process.HLT_L1HTT450er_v5, process.HLT_L1ETM120_v5, process.HLT_L1ETM150_v5, process.HLT_L1EXT_HCAL_LaserMon1_v6, process.HLT_L1EXT_HCAL_LaserMon4_v6, process.HLT_L1MinimumBiasHF0ANDBptxAND_v1, process.HLT_L1AXOVVTight_v1, process.HLT_L1AXOVVVTight_v1, process.HLT_L1CICADA_VVTight_v1, process.HLT_L1CICADA_VVVTight_v1, process.HLT_L1CICADA_VVVVTight_v1, process.HLT_CscCluster_Cosmic_v5, process.HLT_HT60_Beamspot_v26, process.HLT_Beamspot_PixelClusters_WP2_v10, process.HLT_PixelClusters_WP2_v5, process.HLT_PixelClusters_WP2_HighRate_v1, process.HLT_PixelClusters_WP1_v5, process.HLT_BptxOR_v7, process.HLT_L1SingleMuCosmics_EMTF_v5, process.HLT_L1SingleMuCosmics_CosmicTracking_v2, process.HLT_L1SingleMuCosmics_PointingCosmicTracking_v2, process.HLT_L1FatEvents_v6, process.HLT_Random_HighRate_v1, process.HLT_ZeroBias_HighRate_v5, process.HLT_ZeroBias_Gated_v6, process.HLT_SpecialZeroBias_v7, process.HLT_HIHT80_Beamspot_Oxy5TeV_v3, process.HLT_MinimumBiasHF_AND_BptxAND_v1, process.HLT_MinimumBiasHF_OR_BptxAND_v1, process.HLT_MinimumBiasZDC1n_OR_BptxAND_v1, process.HLT_MinimumBiasZDC1n_OR_MinimumBiasHF_AND_BptxAND_v1, process.HLT_MinimumBiasZDC1n_OR_MinimumBiasHF_OR_BptxAND_v1, process.HLT_MinimumBiasZDC1n_OR_OR_MinimumBiasHF_OR_BptxAND_v1, process.HLT_MinimumBiasZDC_Asym_MinimumBiasHF_OR_BptxAND_v1, process.HLT_OxyDoubleEG2_NotMBHF2AND_v1, process.HLT_OxyDoubleEG5_NotMBHF2AND_v1, process.HLT_OxyL1CentralityGate_v1, process.HLT_OxyL1DoubleMu0_v1, process.HLT_OxyL1DoubleMuOpen_v1, process.HLT_OxyL1SingleEG10_v1, process.HLT_OxyL1SingleEG15_v1, process.HLT_OxyL1SingleEG15er2p1_v1, process.HLT_OxyL1SingleEG15er2p5_v1, process.HLT_OxyL1SingleEG21_v1, process.HLT_OxyL1SingleJet20_v1, process.HLT_OxyL1SingleJet28_v1, process.HLT_OxyL1SingleJet35_v1, process.HLT_OxyL1SingleJet44_v1, process.HLT_OxyL1SingleJet60_v1, process.HLT_OxyL1SingleMu0_v1, process.HLT_OxyL1SingleMu3_v1, process.HLT_OxyL1SingleMu5_v1, process.HLT_OxyL1SingleMu7_v1, process.HLT_OxyL1SingleMuOpen_v1, process.HLT_OxyNotMBHF2_v1, process.HLT_OxySingleEG2_NotMBHF2AND_ZDC1nOR_v1, process.HLT_OxySingleEG3_NotMBHF2AND_v1, process.HLT_OxySingleEG3_NotMBHF2OR_v1, process.HLT_OxySingleEG5_NotMBHF2AND_v1, process.HLT_OxySingleJet16_ZDC1nAsymXOR_NotPreBptx_v1, process.HLT_OxySingleJet16_ZDC1nAsymXOR_v1, process.HLT_OxySingleJet16_ZDC1nXOR_v1, process.HLT_OxySingleJet24_ZDC1nAsymXOR_NotPreBptx_v1, process.HLT_OxySingleJet24_ZDC1nAsymXOR_v1, process.HLT_OxySingleJet24_ZDC1nXOR_v1, process.HLT_OxySingleJet8_ZDC1nAsymXOR_NotPreBptx_v1, process.HLT_OxySingleJet8_ZDC1nAsymXOR_v1, process.HLT_OxySingleJet8_ZDC1nXOR_v1, process.HLT_OxySingleMuCosmic_NotMBHF2AND_v1, process.HLT_OxySingleMuOpen_NotMBHF2AND_v1, process.HLT_OxySingleMuOpen_NotMBHF2OR_v1, process.HLT_OxySingleMuOpen_OR_SingleMuCosmic_EMTF_BptxAND_v1, process.HLT_OxySingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2AND_v1, process.HLT_OxyZDC1nOR_v1, process.HLT_OxyZeroBias_v1, process.HLT_OxyZeroBias_SinglePixelTrackLowPt_MaxPixelCluster400_v1, process.HLT_OxyZeroBias_MinPixelCluster400_v1, process.HLTriggerFinalPath, process.HLTAnalyzerEndpath, process.DQMHistograms, process.RatesMonitoring, process.Dataset_AlCaHcalIsoTrk, process.Dataset_AlCaLowPtJet, process.Dataset_AlCaLumiPixelsCountsExpress, process.Dataset_AlCaLumiPixelsCountsPrompt, process.Dataset_AlCaLumiPixelsCountsPromptHighRate0, process.Dataset_AlCaLumiPixelsCountsPromptHighRate1, process.Dataset_AlCaLumiPixelsCountsPromptHighRate2, process.Dataset_AlCaLumiPixelsCountsPromptHighRate3, process.Dataset_AlCaLumiPixelsCountsPromptHighRate4, process.Dataset_AlCaLumiPixelsCountsPromptHighRate5, process.Dataset_AlCaLumiPixelsCountsGated, process.Dataset_AlCaP0, process.Dataset_AlCaPPSExpress, process.Dataset_AlCaPPSPrompt, process.Dataset_AlCaPhiSym, process.Dataset_BTagMu, process.Dataset_Commissioning, process.Dataset_Cosmics, process.Dataset_DQMGPUvsCPU, process.Dataset_DQMOnlineBeamspot, process.Dataset_DQMPPSRandom, process.Dataset_EGamma0, process.Dataset_EGamma1, process.Dataset_EGamma2, process.Dataset_EGamma3, process.Dataset_EcalLaser, process.Dataset_EmptyBX, process.Dataset_EphemeralHLTPhysics0, process.Dataset_EphemeralHLTPhysics1, process.Dataset_EphemeralHLTPhysics2, process.Dataset_EphemeralHLTPhysics3, process.Dataset_EphemeralHLTPhysics4, process.Dataset_EphemeralHLTPhysics5, process.Dataset_EphemeralHLTPhysics6, process.Dataset_EphemeralHLTPhysics7, process.Dataset_EphemeralZeroBias0, process.Dataset_EphemeralZeroBias1, process.Dataset_EphemeralZeroBias2, process.Dataset_EphemeralZeroBias3, process.Dataset_EphemeralZeroBias4, process.Dataset_EphemeralZeroBias5, process.Dataset_EphemeralZeroBias6, process.Dataset_EphemeralZeroBias7, process.Dataset_EventDisplay, process.Dataset_ExpressAlignment, process.Dataset_ExpressCosmics, process.Dataset_ExpressPhysics, process.Dataset_HIDQMGPUvsCPU, process.Dataset_HIDQMOnlineBeamspot, process.Dataset_HIEmptyBX, process.Dataset_HIEphemeralHLTPhysics, process.Dataset_HIEphemeralZeroBias0, process.Dataset_HIEphemeralZeroBias1, process.Dataset_HIEventDisplay, process.Dataset_HIExpressAlignment, process.Dataset_HIExpressPhysics, process.Dataset_HIExpressPhysicsRawPrime, process.Dataset_HIForward0, process.Dataset_HIForward1, process.Dataset_HIForward2, process.Dataset_HIForward3, process.Dataset_HIForward4, process.Dataset_HIForward5, process.Dataset_HIForward6, process.Dataset_HIForward7, process.Dataset_HIForward8, process.Dataset_HIForward9, process.Dataset_HIForward10, process.Dataset_HIForward11, process.Dataset_HIForward12, process.Dataset_HIForward13, process.Dataset_HIForward14, process.Dataset_HIForward15, process.Dataset_HIForward16, process.Dataset_HIForward17, process.Dataset_HIForward18, process.Dataset_HIForward19, process.Dataset_HIHLTPhysics, process.Dataset_HIHcalNZS, process.Dataset_HIOnlineMonitor, process.Dataset_HIMinimumBias0, process.Dataset_HIMinimumBias1, process.Dataset_HIMinimumBias2, process.Dataset_HIMinimumBias3, process.Dataset_HIPhysicsRawPrime0, process.Dataset_HITrackerNZS, process.Dataset_HIZeroBias0, process.Dataset_HIZeroBias1, process.Dataset_HIZeroBias2, process.Dataset_HLTMonitor, process.Dataset_HLTPhysics, process.Dataset_HcalNZS, process.Dataset_JetMET0, process.Dataset_JetMET1, process.Dataset_L1Accept, process.Dataset_MinimumBias, process.Dataset_MonteCarlo, process.Dataset_Muon0, process.Dataset_Muon1, process.Dataset_MuonEG, process.Dataset_MuonShower, process.Dataset_NoBPTX, process.Dataset_OnlineMonitor, process.Dataset_PPRefDoubleMuon0, process.Dataset_PPRefDoubleMuon1, process.Dataset_PPRefDoubleMuon2, process.Dataset_PPRefDoubleMuon3, process.Dataset_PPRefHardProbes0, process.Dataset_PPRefSingleMuon0, process.Dataset_PPRefZeroBiasPlusForward0, process.Dataset_ParkingDoubleMuonLowMass0, process.Dataset_ParkingDoubleMuonLowMass1, process.Dataset_ParkingDoubleMuonLowMass2, process.Dataset_ParkingDoubleMuonLowMass3, process.Dataset_ParkingDoubleMuonLowMass4, process.Dataset_ParkingDoubleMuonLowMass5, process.Dataset_ParkingDoubleMuonLowMass6, process.Dataset_ParkingDoubleMuonLowMass7, process.Dataset_ParkingHH0, process.Dataset_ParkingHH1, process.Dataset_ParkingLLP0, process.Dataset_ParkingLLP1, process.Dataset_ParkingSingleMuon0, process.Dataset_ParkingSingleMuon1, process.Dataset_ParkingSingleMuon2, process.Dataset_ParkingSingleMuon3, process.Dataset_ParkingSingleMuon4, process.Dataset_ParkingSingleMuon5, process.Dataset_ParkingSingleMuon6, process.Dataset_ParkingSingleMuon7, process.Dataset_ParkingSingleMuon8, process.Dataset_ParkingSingleMuon9, process.Dataset_ParkingSingleMuon10, process.Dataset_ParkingSingleMuon11, process.Dataset_ParkingSingleMuon12, process.Dataset_ParkingSingleMuon13, process.Dataset_ParkingSingleMuon14, process.Dataset_ParkingSingleMuon15, process.Dataset_ParkingVBF0, process.Dataset_ParkingVBF1, process.Dataset_ParkingVBF2, process.Dataset_ParkingVBF3, process.Dataset_ParkingVBF4, process.Dataset_ParkingVBF5, process.Dataset_ParkingVBF6, process.Dataset_ParkingVBF7, process.Dataset_ParkingAnomalyDetection, process.Dataset_RPCMonitor, process.Dataset_ScoutingPFMonitor, process.Dataset_ScoutingPF0, process.Dataset_ScoutingPF1, process.Dataset_Tau, process.Dataset_TestEnablesEcalHcal, process.Dataset_TestEnablesEcalHcalDQM, process.Dataset_VRRandom0, process.Dataset_VRRandom1, process.Dataset_VRRandom2, process.Dataset_VRRandom3, process.Dataset_VRRandom4, process.Dataset_VRRandom5, process.Dataset_VRRandom6, process.Dataset_VRRandom7, process.Dataset_VRRandom8, process.Dataset_VRRandom9, process.Dataset_VRRandom10, process.Dataset_VRRandom11, process.Dataset_VRRandom12, process.Dataset_VRRandom13, process.Dataset_VRRandom14, process.Dataset_VRRandom15, process.Dataset_ZeroBias, process.Dataset_SpecialRandom0, process.Dataset_SpecialRandom1, process.Dataset_SpecialRandom2, process.Dataset_SpecialRandom3, process.Dataset_SpecialRandom4, process.Dataset_SpecialRandom5, process.Dataset_SpecialRandom6, process.Dataset_SpecialRandom7, process.Dataset_SpecialRandom8, process.Dataset_SpecialRandom9, process.Dataset_SpecialRandom10, process.Dataset_SpecialRandom11, process.Dataset_SpecialRandom12, process.Dataset_SpecialRandom13, process.Dataset_SpecialRandom14, process.Dataset_SpecialRandom15, process.Dataset_SpecialRandom16, process.Dataset_SpecialRandom17, process.Dataset_SpecialRandom18, process.Dataset_SpecialRandom19, process.Dataset_SpecialZeroBias0, process.Dataset_SpecialZeroBias1, process.Dataset_SpecialZeroBias2, process.Dataset_SpecialZeroBias3, process.Dataset_SpecialZeroBias4, process.Dataset_SpecialZeroBias5, process.Dataset_SpecialZeroBias6, process.Dataset_SpecialZeroBias7, process.Dataset_SpecialZeroBias8, process.Dataset_SpecialZeroBias9, process.Dataset_SpecialZeroBias10, process.Dataset_SpecialZeroBias11, process.Dataset_SpecialZeroBias12, process.Dataset_SpecialZeroBias13, process.Dataset_SpecialZeroBias14, process.Dataset_SpecialZeroBias15, process.Dataset_SpecialZeroBias16, process.Dataset_SpecialZeroBias17, process.Dataset_SpecialZeroBias18, process.Dataset_SpecialZeroBias19, process.Dataset_SpecialZeroBias20, process.Dataset_SpecialZeroBias21, process.Dataset_SpecialZeroBias22, process.Dataset_SpecialZeroBias23, process.Dataset_SpecialZeroBias24, process.Dataset_SpecialZeroBias25, process.Dataset_SpecialZeroBias26, process.Dataset_SpecialZeroBias27, process.Dataset_SpecialZeroBias28, process.Dataset_SpecialZeroBias29, process.Dataset_SpecialZeroBias30, process.Dataset_SpecialZeroBias31, process.Dataset_SpecialHLTPhysics0, process.Dataset_SpecialHLTPhysics1, process.Dataset_SpecialHLTPhysics2, process.Dataset_SpecialHLTPhysics3, process.Dataset_SpecialHLTPhysics4, process.Dataset_SpecialHLTPhysics5, process.Dataset_SpecialHLTPhysics6, process.Dataset_SpecialHLTPhysics7, process.Dataset_SpecialHLTPhysics8, process.Dataset_SpecialHLTPhysics9, process.Dataset_SpecialHLTPhysics10, process.Dataset_SpecialHLTPhysics11, process.Dataset_SpecialHLTPhysics12, process.Dataset_SpecialHLTPhysics13, process.Dataset_SpecialHLTPhysics14, process.Dataset_SpecialHLTPhysics15, process.Dataset_SpecialHLTPhysics16, process.Dataset_SpecialHLTPhysics17, process.Dataset_SpecialHLTPhysics18, process.Dataset_SpecialHLTPhysics19, process.Dataset_PPRefZeroBiasPlusForward1, process.Dataset_PPRefZeroBiasPlusForward2, process.Dataset_PPRefZeroBiasPlusForward3, process.Dataset_PPRefZeroBiasPlusForward4, process.Dataset_PPRefZeroBiasPlusForward5, process.Dataset_PPRefZeroBiasPlusForward6, process.Dataset_PPRefZeroBiasPlusForward7, process.Dataset_PPRefZeroBiasPlusForward8, process.Dataset_PPRefZeroBiasPlusForward9, process.Dataset_PPRefZeroBiasPlusForward10, process.Dataset_PPRefZeroBiasPlusForward11, process.Dataset_PPRefZeroBiasPlusForward12, process.Dataset_PPRefZeroBiasPlusForward13, process.Dataset_PPRefZeroBiasPlusForward14, process.Dataset_PPRefZeroBiasPlusForward15, process.Dataset_PPRefZeroBiasPlusForward16, process.Dataset_PPRefZeroBiasPlusForward17, process.Dataset_PPRefZeroBiasPlusForward18, process.Dataset_PPRefZeroBiasPlusForward19, process.Dataset_PPRefZeroBiasPlusForward20, process.Dataset_PPRefZeroBiasPlusForward21, process.Dataset_PPRefZeroBiasPlusForward22, process.Dataset_PPRefZeroBiasPlusForward23, process.Dataset_PPRefZeroBiasPlusForward24, process.Dataset_PPRefSingleMuon1, process.Dataset_PPRefSingleMuon2, process.Dataset_PPRefSingleMuon3, process.Dataset_PPRefHardProbes1, process.Dataset_PPRefHardProbes2, process.Dataset_PPRefHardProbes3, process.Dataset_PPRefHardProbes4, process.Dataset_SpecialMinimumBias0, process.Dataset_SpecialMinimumBias1, process.Dataset_SpecialMinimumBias2, process.Dataset_SpecialMinimumBias3, process.Dataset_HIPhysicsRawPrime1, process.Dataset_HIPhysicsRawPrime2, process.Dataset_HIPhysicsRawPrime3, process.Dataset_HIPhysicsRawPrime4, process.Dataset_HIPhysicsRawPrime5, process.Dataset_HIPhysicsRawPrime6, process.Dataset_HIPhysicsRawPrime7, process.Dataset_HIPhysicsRawPrime8, process.Dataset_HIPhysicsRawPrime9, process.Dataset_HIPhysicsRawPrime10, process.Dataset_HIPhysicsRawPrime11, process.Dataset_HIPhysicsRawPrime12, process.Dataset_HIPhysicsRawPrime13, process.Dataset_HIPhysicsRawPrime14, process.Dataset_HIPhysicsRawPrime15, process.Dataset_HIPhysicsRawPrime16, process.Dataset_HIPhysicsRawPrime17, process.Dataset_HIPhysicsRawPrime18, process.Dataset_HIPhysicsRawPrime19, process.Dataset_HIPhysicsRawPrime20, process.Dataset_HIPhysicsRawPrime21, process.Dataset_HIPhysicsRawPrime22, process.Dataset_HIPhysicsRawPrime23, process.Dataset_HIPhysicsRawPrime24, process.Dataset_HIPhysicsRawPrime25, process.Dataset_HIPhysicsRawPrime26, process.Dataset_HIPhysicsRawPrime27, process.Dataset_HIPhysicsRawPrime28, process.Dataset_HIPhysicsRawPrime29, process.Dataset_HIPhysicsRawPrime30, process.Dataset_HIPhysicsRawPrime31, process.Dataset_HIPhysicsRawPrime32, process.Dataset_HIPhysicsRawPrime33, process.Dataset_HIPhysicsRawPrime34, process.Dataset_HIPhysicsRawPrime35, process.Dataset_HIPhysicsRawPrime36, process.Dataset_HIPhysicsRawPrime37, process.Dataset_HIPhysicsRawPrime38, process.Dataset_HIPhysicsRawPrime39, process.Dataset_HIPhysicsRawPrime40, process.Dataset_HIPhysicsRawPrime41, process.Dataset_HIPhysicsRawPrime42, process.Dataset_HIPhysicsRawPrime43, process.Dataset_HIPhysicsRawPrime44, process.Dataset_HIPhysicsRawPrime45, process.Dataset_HIPhysicsRawPrime46, process.Dataset_HIPhysicsRawPrime47, process.Dataset_HIPhysicsRawPrime48, process.Dataset_HIPhysicsRawPrime49, process.Dataset_HIPhysicsRawPrime50, process.Dataset_HIPhysicsRawPrime51, process.Dataset_HIPhysicsRawPrime52, process.Dataset_HIPhysicsRawPrime53, process.Dataset_HIPhysicsRawPrime54, process.Dataset_HIPhysicsRawPrime55, process.Dataset_HIPhysicsRawPrime56, process.Dataset_HIPhysicsRawPrime57, process.Dataset_HIPhysicsRawPrime58, process.Dataset_HIPhysicsRawPrime59, process.Dataset_CosmicHLTMonitor, process.Dataset_TestDataRaw, process.Dataset_TestDataScouting, process.Dataset_EmittanceScan0, process.Dataset_EmittanceScan1, process.Dataset_EmittanceScan2, process.Dataset_EmittanceScan3, process.Dataset_EmittanceScan4, process.Dataset_EmittanceScan5, process.Dataset_IonPhysics, process.Dataset_DQMOnlineScouting, process.ALCAHcalIsoTrkOutput, process.ALCALowPtJetOutput, process.ALCALumiPixelsCountsExpressOutput, process.ALCALumiPixelsCountsGatedOutput, process.ALCALumiPixelsCountsPromptOutput, process.ALCALumiPixelsCountsPromptHighRate0Output, process.ALCALumiPixelsCountsPromptHighRate1Output, process.ALCALumiPixelsCountsPromptHighRate2Output, process.ALCALumiPixelsCountsPromptHighRate3Output, process.ALCALumiPixelsCountsPromptHighRate4Output, process.ALCALumiPixelsCountsPromptHighRate5Output, process.ALCAP0Output, process.ALCAPHISYMOutput, process.ALCAPPSExpressOutput, process.ALCAPPSPromptOutput, process.CalibrationOutput, process.DQMOutput, process.DQMCalibrationOutput, process.DQMEventDisplayOutput, process.DQMGPUvsCPUOutput, process.DQMOnlineBeamspotOutput, process.DQMOnlineScoutingOutput, process.DQMPPSRandomOutput, process.EcalCalibrationOutput, process.ExpressOutput, process.ExpressAlignmentOutput, process.ExpressCosmicsOutput, process.HIDQMOutput, process.HIDQMEventDisplayOutput, process.HIDQMGPUvsCPUOutput, process.HIDQMOnlineBeamspotOutput, process.HIExpressOutput, process.HIExpressAlignmentOutput, process.HIExpressRawPrimeOutput, process.HLTMonitorOutput, process.NanoDSTOutput, process.ParkingDoubleMuonLowMass0Output, process.ParkingDoubleMuonLowMass1Output, process.ParkingDoubleMuonLowMass2Output, process.ParkingDoubleMuonLowMass3Output, process.ParkingHHOutput, process.ParkingLLPOutput, process.ParkingSingleMuon0Output, process.ParkingSingleMuon1Output, process.ParkingSingleMuon10Output, process.ParkingSingleMuon11Output, process.ParkingSingleMuon12Output, process.ParkingSingleMuon13Output, process.ParkingSingleMuon14Output, process.ParkingSingleMuon15Output, process.ParkingSingleMuon2Output, process.ParkingSingleMuon3Output, process.ParkingSingleMuon4Output, process.ParkingSingleMuon5Output, process.ParkingSingleMuon6Output, process.ParkingSingleMuon7Output, process.ParkingSingleMuon8Output, process.ParkingSingleMuon9Output, process.ParkingVBF0Output, process.ParkingVBF1Output, process.ParkingVBF2Output, process.ParkingVBF3Output, process.ParkingAnomalyDetectionOutput, process.PhysicsCommissioningOutput, process.PhysicsBTagMuEGTauOutput, process.PhysicsEGamma0Output, process.PhysicsEGamma1Output, process.PhysicsEGamma2Output, process.PhysicsEGamma3Output, process.PhysicsHICommissioningOutput, process.PhysicsHIForward0Output, process.PhysicsHIForward1Output, process.PhysicsHIForward10Output, process.PhysicsHIForward11Output, process.PhysicsHIForward12Output, process.PhysicsHIForward13Output, process.PhysicsHIForward14Output, process.PhysicsHIForward15Output, process.PhysicsHIForward16Output, process.PhysicsHIForward17Output, process.PhysicsHIForward18Output, process.PhysicsHIForward19Output, process.PhysicsHIForward2Output, process.PhysicsHIForward3Output, process.PhysicsHIForward4Output, process.PhysicsHIForward5Output, process.PhysicsHIForward6Output, process.PhysicsHIForward7Output, process.PhysicsHIForward8Output, process.PhysicsHIForward9Output, process.PhysicsHIHLTPhysicsOutput, process.PhysicsHIMinimumBias0Output, process.PhysicsHIMinimumBias1Output, process.PhysicsHIMinimumBias2Output, process.PhysicsHIMinimumBias3Output, process.PhysicsHIPhysicsRawPrime0Output, process.PhysicsHIPhysicsRawPrime1Output, process.PhysicsHIPhysicsRawPrime10Output, process.PhysicsHIPhysicsRawPrime11Output, process.PhysicsHIPhysicsRawPrime12Output, process.PhysicsHIPhysicsRawPrime13Output, process.PhysicsHIPhysicsRawPrime14Output, process.PhysicsHIPhysicsRawPrime15Output, process.PhysicsHIPhysicsRawPrime16Output, process.PhysicsHIPhysicsRawPrime17Output, process.PhysicsHIPhysicsRawPrime18Output, process.PhysicsHIPhysicsRawPrime19Output, process.PhysicsHIPhysicsRawPrime2Output, process.PhysicsHIPhysicsRawPrime20Output, process.PhysicsHIPhysicsRawPrime21Output, process.PhysicsHIPhysicsRawPrime22Output, process.PhysicsHIPhysicsRawPrime23Output, process.PhysicsHIPhysicsRawPrime24Output, process.PhysicsHIPhysicsRawPrime25Output, process.PhysicsHIPhysicsRawPrime26Output, process.PhysicsHIPhysicsRawPrime27Output, process.PhysicsHIPhysicsRawPrime28Output, process.PhysicsHIPhysicsRawPrime29Output, process.PhysicsHIPhysicsRawPrime3Output, process.PhysicsHIPhysicsRawPrime30Output, process.PhysicsHIPhysicsRawPrime31Output, process.PhysicsHIPhysicsRawPrime32Output, process.PhysicsHIPhysicsRawPrime33Output, process.PhysicsHIPhysicsRawPrime34Output, process.PhysicsHIPhysicsRawPrime35Output, process.PhysicsHIPhysicsRawPrime36Output, process.PhysicsHIPhysicsRawPrime37Output, process.PhysicsHIPhysicsRawPrime38Output, process.PhysicsHIPhysicsRawPrime39Output, process.PhysicsHIPhysicsRawPrime4Output, process.PhysicsHIPhysicsRawPrime40Output, process.PhysicsHIPhysicsRawPrime41Output, process.PhysicsHIPhysicsRawPrime42Output, process.PhysicsHIPhysicsRawPrime43Output, process.PhysicsHIPhysicsRawPrime44Output, process.PhysicsHIPhysicsRawPrime45Output, process.PhysicsHIPhysicsRawPrime46Output, process.PhysicsHIPhysicsRawPrime47Output, process.PhysicsHIPhysicsRawPrime48Output, process.PhysicsHIPhysicsRawPrime49Output, process.PhysicsHIPhysicsRawPrime5Output, process.PhysicsHIPhysicsRawPrime50Output, process.PhysicsHIPhysicsRawPrime51Output, process.PhysicsHIPhysicsRawPrime52Output, process.PhysicsHIPhysicsRawPrime53Output, process.PhysicsHIPhysicsRawPrime54Output, process.PhysicsHIPhysicsRawPrime55Output, process.PhysicsHIPhysicsRawPrime56Output, process.PhysicsHIPhysicsRawPrime57Output, process.PhysicsHIPhysicsRawPrime58Output, process.PhysicsHIPhysicsRawPrime59Output, process.PhysicsHIPhysicsRawPrime6Output, process.PhysicsHIPhysicsRawPrime7Output, process.PhysicsHIPhysicsRawPrime8Output, process.PhysicsHIPhysicsRawPrime9Output, process.PhysicsHITrackerNZSOutput, process.PhysicsHIZeroBiasOutput, process.PhysicsHIZeroBiasRAW0Output, process.PhysicsHIZeroBiasRAW1Output, process.PhysicsHIZeroBiasRAW2Output, process.PhysicsHLTPhysics0Output, process.PhysicsHLTPhysics1Output, process.PhysicsHLTPhysics2Output, process.PhysicsHLTPhysics3Output, process.PhysicsJetMET0Output, process.PhysicsJetMET1Output, process.PhysicsMuon0Output, process.PhysicsMuon1Output, process.PhysicsPPRefDoubleMuon0Output, process.PhysicsPPRefDoubleMuon1Output, process.PhysicsPPRefDoubleMuon2Output, process.PhysicsPPRefDoubleMuon3Output, process.PhysicsPPRefHardProbes0Output, process.PhysicsPPRefHardProbes1Output, process.PhysicsPPRefHardProbes2Output, process.PhysicsPPRefHardProbes3Output, process.PhysicsPPRefHardProbes4Output, process.PhysicsPPRefSingleMuon0Output, process.PhysicsPPRefSingleMuon1Output, process.PhysicsPPRefSingleMuon2Output, process.PhysicsPPRefSingleMuon3Output, process.PhysicsPPRefZeroBiasPlusForward0Output, process.PhysicsPPRefZeroBiasPlusForward1Output, process.PhysicsPPRefZeroBiasPlusForward10Output, process.PhysicsPPRefZeroBiasPlusForward11Output, process.PhysicsPPRefZeroBiasPlusForward12Output, process.PhysicsPPRefZeroBiasPlusForward13Output, process.PhysicsPPRefZeroBiasPlusForward14Output, process.PhysicsPPRefZeroBiasPlusForward15Output, process.PhysicsPPRefZeroBiasPlusForward16Output, process.PhysicsPPRefZeroBiasPlusForward17Output, process.PhysicsPPRefZeroBiasPlusForward18Output, process.PhysicsPPRefZeroBiasPlusForward19Output, process.PhysicsPPRefZeroBiasPlusForward2Output, process.PhysicsPPRefZeroBiasPlusForward20Output, process.PhysicsPPRefZeroBiasPlusForward21Output, process.PhysicsPPRefZeroBiasPlusForward22Output, process.PhysicsPPRefZeroBiasPlusForward23Output, process.PhysicsPPRefZeroBiasPlusForward24Output, process.PhysicsPPRefZeroBiasPlusForward3Output, process.PhysicsPPRefZeroBiasPlusForward4Output, process.PhysicsPPRefZeroBiasPlusForward5Output, process.PhysicsPPRefZeroBiasPlusForward6Output, process.PhysicsPPRefZeroBiasPlusForward7Output, process.PhysicsPPRefZeroBiasPlusForward8Output, process.PhysicsPPRefZeroBiasPlusForward9Output, process.PhysicsScoutingPFMonitorOutput, process.PhysicsSpecialHLTPhysics0Output, process.PhysicsSpecialHLTPhysics1Output, process.PhysicsSpecialHLTPhysics10Output, process.PhysicsSpecialHLTPhysics11Output, process.PhysicsSpecialHLTPhysics12Output, process.PhysicsSpecialHLTPhysics13Output, process.PhysicsSpecialHLTPhysics14Output, process.PhysicsSpecialHLTPhysics15Output, process.PhysicsSpecialHLTPhysics16Output, process.PhysicsSpecialHLTPhysics17Output, process.PhysicsSpecialHLTPhysics18Output, process.PhysicsSpecialHLTPhysics19Output, process.PhysicsSpecialHLTPhysics2Output, process.PhysicsSpecialHLTPhysics3Output, process.PhysicsSpecialHLTPhysics4Output, process.PhysicsSpecialHLTPhysics5Output, process.PhysicsSpecialHLTPhysics6Output, process.PhysicsSpecialHLTPhysics7Output, process.PhysicsSpecialHLTPhysics8Output, process.PhysicsSpecialHLTPhysics9Output, process.PhysicsSpecialMinimumBias0Output, process.PhysicsSpecialMinimumBias1Output, process.PhysicsSpecialMinimumBias2Output, process.PhysicsSpecialMinimumBias3Output, process.PhysicsSpecialRandom0Output, process.PhysicsSpecialRandom1Output, process.PhysicsSpecialRandom2Output, process.PhysicsSpecialRandom3Output, process.PhysicsSpecialRandom4Output, process.PhysicsSpecialRandom5Output, process.PhysicsSpecialRandom6Output, process.PhysicsSpecialRandom7Output, process.PhysicsSpecialRandom8Output, process.PhysicsSpecialRandom9Output, process.PhysicsSpecialZeroBias0Output, process.PhysicsSpecialZeroBias1Output, process.PhysicsSpecialZeroBias2Output, process.PhysicsSpecialZeroBias3Output, process.PhysicsSpecialZeroBias4Output, process.PhysicsSpecialZeroBias5Output, process.PhysicsSpecialZeroBias6Output, process.PhysicsSpecialZeroBias7Output, process.PhysicsSpecialZeroBias8Output, process.PhysicsSpecialZeroBias10Output, process.PhysicsSpecialZeroBias11Output, process.PhysicsSpecialZeroBias12Output, process.PhysicsSpecialZeroBias13Output, process.PhysicsSpecialZeroBias14Output, process.PhysicsSpecialZeroBias15Output, process.PhysicsSpecialZeroBias16Output, process.PhysicsSpecialZeroBias17Output, process.PhysicsSpecialZeroBias18Output, process.PhysicsSpecialZeroBias19Output, process.PhysicsSpecialZeroBias9Output, process.PhysicsSpecialZeroBias20Output, process.PhysicsSpecialZeroBias21Output, process.PhysicsSpecialZeroBias22Output, process.PhysicsSpecialZeroBias23Output, process.PhysicsSpecialZeroBias24Output, process.PhysicsSpecialZeroBias25Output, process.PhysicsSpecialZeroBias26Output, process.PhysicsSpecialZeroBias27Output, process.PhysicsSpecialZeroBias28Output, process.PhysicsSpecialZeroBias29Output, process.PhysicsSpecialZeroBias30Output, process.PhysicsSpecialZeroBias31Output, process.PhysicsVRRandom0Output, process.PhysicsVRRandom1Output, process.PhysicsVRRandom2Output, process.PhysicsVRRandom3Output, process.PhysicsVRRandom4Output, process.PhysicsVRRandom5Output, process.PhysicsVRRandom6Output, process.PhysicsVRRandom7Output, process.PhysicsZeroBias0Output, process.PhysicsZeroBias1Output, process.PhysicsZeroBias2Output, process.PhysicsZeroBias3Output, process.PhysicsEmittanceScan0Output, process.PhysicsEmittanceScan1Output, process.PhysicsEmittanceScan2Output, process.PhysicsIonPhysicsOutput, process.RPCMONOutput, process.ScoutingPF0Output, process.ScoutingPF1Output, process.CosmicHLTMonitorOutput, process.LocalTestDataRawOutput, process.LocalTestDataScoutingOutput, )) +process.schedule = cms.Schedule( *(process.HLTriggerFirstPath, process.Status_OnCPU, process.Status_OnGPU, process.AlCa_EcalPhiSym_v22, process.AlCa_EcalPhiSymForHI_v13, process.AlCa_EcalEtaEBonly_v27, process.AlCa_EcalEtaEEonly_v27, process.AlCa_EcalPi0EBonly_v27, process.AlCa_EcalPi0EEonly_v27, process.AlCa_EcalEtaEBonlyForHI_v14, process.AlCa_EcalEtaEEonlyForHI_v14, process.AlCa_EcalPi0EBonlyForHI_v14, process.AlCa_EcalPi0EEonlyForHI_v14, process.AlCa_IsoTrackHBHE_v3, process.AlCa_HIEcalEtaEBonly_v13, process.AlCa_HIEcalEtaEEonly_v13, process.AlCa_HIEcalPi0EBonly_v13, process.AlCa_HIEcalPi0EEonly_v13, process.AlCa_RPCMuonNormalisation_v25, process.AlCa_RPCMuonNormalisationForHI_v13, process.AlCa_HIRPCMuonNormalisation_v13, process.AlCa_LumiPixelsCounts_Random_v12, process.AlCa_LumiPixelsCounts_ZeroBias_v15, process.AlCa_PFJet40_v36, process.AlCa_PFJet40_CPUOnly_v15, process.AlCa_AK8PFJet40_v31, process.DQM_PixelReconstruction_v14, process.DQM_EcalReconstruction_v13, process.DQM_HcalReconstruction_v11, process.DQM_HIPixelReconstruction_v14, process.DQM_HIEcalReconstruction_v11, process.DQM_HIHcalReconstruction_v9, process.DQM_Random_v1, process.DQM_ZeroBias_v4, process.DST_ZeroBias_v12, process.DST_Physics_v17, process.DST_PFScouting_DoubleMuonNoVtx_v4, process.DST_PFScouting_DoubleMuonVtx_v4, process.DST_PFScouting_DoubleMuonVtxMonitorJPsi_v4, process.DST_PFScouting_DoubleMuonVtxMonitorZ_v4, process.DST_PFScouting_DoubleEG_v10, process.DST_PFScouting_DoubleEGMonitorJPsi_v1, process.DST_PFScouting_DoubleEGMonitorZ_v1, process.DST_PFScouting_SinglePhotonEBMonitorJPsi_v1, process.DST_PFScouting_SinglePhotonEBMonitorZ_v1, process.DST_PFScouting_JetHT_v10, process.DST_PFScouting_AXOVLoose_v8, process.DST_PFScouting_AXOLoose_v8, process.DST_PFScouting_AXOMedium_v4, process.DST_PFScouting_AXOTight_v10, process.DST_PFScouting_AXOVTight_v8, process.HLT_MonitorL1TPureRate_AXO_v1, process.DST_PFScouting_CICADAVLoose_v6, process.DST_PFScouting_CICADALoose_v6, process.DST_PFScouting_CICADAMedium_v6, process.DST_PFScouting_CICADATight_v6, process.DST_PFScouting_CICADAVTight_v6, process.HLT_MonitorL1TPureRate_CICADA_v1, process.DST_PFScouting_SingleMuon_v10, process.DST_PFScouting_SinglePhotonEB_v7, process.DST_PFScouting_ZeroBias_v8, process.DST_PFScouting_ZeroBiasVdM_v2, process.HLT_TriggersForScoutingPFMonitor_PS125_v1, process.HLT_TriggersForScoutingPFMonitor_PS250_v1, process.HLT_TriggersForScoutingPFMonitor_PS500_v1, process.HLT_TriggersForScoutingPFMonitor_PS1000_v1, process.HLT_TriggersForScoutingPFMonitor_SingleMuon_v1, process.HLT_EphemeralPhysics_v10, process.HLT_EphemeralZeroBias_v10, process.HLT_HIEphemeralPhysics_v6, process.HLT_HIEphemeralZeroBias_v6, process.HLT_EcalCalibration_v4, process.HLT_HcalCalibration_v6, process.HLT_HcalNZS_v22, process.HLT_HcalPhiSym_v24, process.HLT_Random_v3, process.HLT_Physics_v15, process.HLT_ZeroBias_v14, process.HLT_ZeroBias_Alignment_v9, process.HLT_ZeroBias_Beamspot_v20, process.HLT_ZeroBias_IsolatedBunches_v13, process.HLT_ZeroBias_FirstBXAfterTrain_v11, process.HLT_ZeroBias_FirstCollisionAfterAbortGap_v13, process.HLT_ZeroBias_FirstCollisionInTrain_v12, process.HLT_ZeroBias_LastCollisionInTrain_v11, process.HLT_HT300_Beamspot_v27, process.HLT_PFJet40_GPUvsCPU_v8, process.HLT_AK8PFJet380_SoftDropMass30_v10, process.HLT_AK8PFJet400_SoftDropMass30_v10, process.HLT_AK8PFJet425_SoftDropMass30_v10, process.HLT_AK8PFJet450_SoftDropMass30_v10, process.HLT_AK8DiPFJet250_250_SoftDropMass40_v10, process.HLT_AK8DiPFJet250_250_SoftDropMass50_v10, process.HLT_AK8DiPFJet260_260_SoftDropMass30_v10, process.HLT_AK8DiPFJet260_260_SoftDropMass40_v10, process.HLT_AK8DiPFJet270_270_SoftDropMass30_v10, process.HLT_AK8DiPFJet280_280_SoftDropMass30_v16, process.HLT_AK8DiPFJet290_290_SoftDropMass30_v10, process.HLT_CaloJet500_NoJetID_v24, process.HLT_CaloJet550_NoJetID_v19, process.HLT_DoubleMu5_Upsilon_DoubleEle3_CaloIdL_TrackIdL_v20, process.HLT_DoubleMu3_DoubleEle7p5_CaloIdL_TrackIdL_Upsilon_v20, process.HLT_Trimuon5_3p5_2_Upsilon_Muon_v21, process.HLT_TrimuonOpen_5_3p5_2_Upsilon_Muon_v18, process.HLT_DoubleEle25_CaloIdL_MW_v18, process.HLT_DoubleEle27_CaloIdL_MW_v18, process.HLT_DoubleEle33_CaloIdL_MW_v31, process.HLT_DoubleEle24_eta2p1_WPTight_Gsf_v22, process.HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_DZ_PFHT350_v36, process.HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_PFHT350_v36, process.HLT_Mu27_Ele37_CaloIdL_MW_v21, process.HLT_Mu37_Ele27_CaloIdL_MW_v21, process.HLT_Mu37_TkMu27_v21, process.HLT_DoubleMu4_3_Bs_v31, process.HLT_DoubleMu4_3_Jpsi_v31, process.HLT_DoubleMu4_3_LowMass_v17, process.HLT_DoubleMu4_LowMass_Displaced_v17, process.HLT_Mu0_L1DoubleMu_v17, process.HLT_Mu4_L1DoubleMu_v17, process.HLT_DoubleMu2_Jpsi_LowPt_v10, process.HLT_DoubleMu4_3_Photon4_BsToMMG_v16, process.HLT_DoubleMu4_3_Displaced_Photon4_BsToMMG_v16, process.HLT_DoubleMu3_Trk_Tau3mu_v28, process.HLT_DoubleMu3_TkMu_DsTau3Mu_v20, process.HLT_DoubleMu4_Mass3p8_DZ_PFHT350_v24, process.HLT_DoubleMu4_MuMuTrk_Displaced_v31, process.HLT_Mu3_PFJet40_v32, process.HLT_Mu7p5_L2Mu2_Jpsi_v26, process.HLT_Mu7p5_L2Mu2_Upsilon_v26, process.HLT_Mu3_L1SingleMu5orSingleMu7_v17, process.HLT_Mu0_Barrel_v10, process.HLT_Mu0_Barrel_L1HP6_v7, process.HLT_Mu0_Barrel_L1HP7_v7, process.HLT_Mu0_Barrel_L1HP8_v8, process.HLT_Mu0_Barrel_L1HP9_v8, process.HLT_Mu0_Barrel_L1HP10_v10, process.HLT_Mu0_Barrel_L1HP11_v10, process.HLT_Mu0_Barrel_L1HP13_v4, process.HLT_Mu0_Barrel_L1HP6_IP6_v7, process.HLT_Mu4_Barrel_IP4_v4, process.HLT_Mu4_Barrel_IP6_v4, process.HLT_Mu6_Barrel_L1HP7_IP6_v7, process.HLT_Mu7_Barrel_L1HP8_IP6_v8, process.HLT_Mu8_Barrel_L1HP9_IP6_v8, process.HLT_Mu9_Barrel_L1HP10_IP6_v10, process.HLT_Mu10_Barrel_L1HP11_IP4_v4, process.HLT_Mu10_Barrel_L1HP11_IP6_v10, process.HLT_Mu12_Barrel_L1HP13_IP4_v4, process.HLT_Mu12_Barrel_L1HP13_IP6_v4, process.HLT_DoublePhoton33_CaloIdL_v18, process.HLT_DoublePhoton70_v18, process.HLT_DoublePhoton85_v26, process.HLT_DiEle27_WPTightCaloOnly_L1DoubleEG_v16, process.HLT_Ele30_WPTight_Gsf_v16, process.HLT_Ele32_WPTight_Gsf_v30, process.HLT_Ele35_WPTight_Gsf_v24, process.HLT_Ele38_WPTight_Gsf_v24, process.HLT_Ele40_WPTight_Gsf_v24, process.HLT_Ele32_WPTight_Gsf_L1DoubleEG_v24, process.HLT_IsoMu20_v31, process.HLT_IsoMu24_v29, process.HLT_IsoMu24_HLTTracking_v4, process.HLT_IsoMu24_eta2p1_v31, process.HLT_IsoMu27_v32, process.HLT_UncorrectedJetE30_NoBPTX_v16, process.HLT_UncorrectedJetE30_NoBPTX3BX_v16, process.HLT_UncorrectedJetE60_NoBPTX3BX_v16, process.HLT_UncorrectedJetE70_NoBPTX3BX_v16, process.HLT_L1SingleMuCosmics_v9, process.HLT_L2Mu10_NoVertex_NoBPTX3BX_v15, process.HLT_L2Mu10_NoVertex_NoBPTX_v16, process.HLT_L2Mu45_NoVertex_3Sta_NoBPTX3BX_v14, process.HLT_L2Mu40_NoVertex_3Sta_NoBPTX3BX_v15, process.HLT_L2Mu23NoVtx_2Cha_v11, process.HLT_L2Mu23NoVtx_2Cha_CosmicSeed_v11, process.HLT_DoubleL2Mu30NoVtx_2Cha_CosmicSeed_Eta2p4_v12, process.HLT_DoubleL2Mu30NoVtx_2Cha_Eta2p4_v12, process.HLT_DoubleL2Mu50_v12, process.HLT_DoubleL2Mu23NoVtx_2Cha_CosmicSeed_v12, process.HLT_DoubleL2Mu25NoVtx_2Cha_CosmicSeed_v12, process.HLT_DoubleL2Mu25NoVtx_2Cha_CosmicSeed_Eta2p4_v12, process.HLT_DoubleL2Mu23NoVtx_2Cha_v12, process.HLT_DoubleL2Mu25NoVtx_2Cha_v12, process.HLT_DoubleL2Mu25NoVtx_2Cha_Eta2p4_v12, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v30, process.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_v19, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v31, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_HLTTracking_v4, process.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_v19, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_v21, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_PFJet30_v10, process.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_Mass8_v19, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass3p8_v21, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass3p8_HLTTracking_v4, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_CaloJet30_v9, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_AK8PFJet30_v9, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_AK8CaloJet30_v9, process.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_Mass3p8_v19, process.HLT_Mu30_TkMu0_Psi_v17, process.HLT_Mu30_TkMu0_Upsilon_v17, process.HLT_Mu25_TkMu0_Phi_v24, process.HLT_Mu15_v19, process.HLT_Mu20_v28, process.HLT_Mu27_v29, process.HLT_Mu50_v29, process.HLT_Mu55_v19, process.HLT_CascadeMu100_v16, process.HLT_HighPtTkMu100_v16, process.HLT_DiPFJetAve40_v30, process.HLT_DiPFJetAve60_v30, process.HLT_DiPFJetAve80_v30, process.HLT_DiPFJetAve140_v29, process.HLT_DiPFJetAve200_v29, process.HLT_DiPFJetAve260_v30, process.HLT_DiPFJetAve320_v30, process.HLT_DiPFJetAve400_v30, process.HLT_DiPFJetAve500_v30, process.HLT_DiPFJetAve60_HFJEC_v31, process.HLT_DiPFJetAve80_HFJEC_v33, process.HLT_DiPFJetAve100_HFJEC_v33, process.HLT_DiPFJetAve160_HFJEC_v32, process.HLT_DiPFJetAve220_HFJEC_v32, process.HLT_DiPFJetAve260_HFJEC_v15, process.HLT_DiPFJetAve300_HFJEC_v32, process.HLT_DiPFJetAve180_PPSMatch_Xi0p3_QuadJet_Max2ProtPerRP_v10, process.HLT_AK8PFJet40_v32, process.HLT_AK8PFJet60_v31, process.HLT_AK8PFJet80_v32, process.HLT_AK8PFJet140_v31, process.HLT_AK8PFJet200_v31, process.HLT_AK8PFJet260_v32, process.HLT_AK8PFJet320_v32, process.HLT_AK8PFJet400_v32, process.HLT_AK8PFJet450_v32, process.HLT_AK8PFJet500_v32, process.HLT_AK8PFJet550_v27, process.HLT_PFJet40_v37, process.HLT_PFJet60_v37, process.HLT_PFJet80_v37, process.HLT_PFJet110_v16, process.HLT_PFJet140_v35, process.HLT_PFJet200_v35, process.HLT_PFJet260_v36, process.HLT_PFJet320_v36, process.HLT_PFJet400_v36, process.HLT_PFJet450_v37, process.HLT_PFJet500_v37, process.HLT_PFJet550_v27, process.HLT_PFJetFwd40_v35, process.HLT_PFJetFwd60_v35, process.HLT_PFJetFwd80_v34, process.HLT_PFJetFwd140_v34, process.HLT_PFJetFwd200_v34, process.HLT_PFJetFwd260_v35, process.HLT_PFJetFwd320_v35, process.HLT_PFJetFwd400_v35, process.HLT_PFJetFwd450_v35, process.HLT_PFJetFwd500_v35, process.HLT_AK8PFJetFwd40_v31, process.HLT_AK8PFJetFwd60_v30, process.HLT_AK8PFJetFwd80_v30, process.HLT_AK8PFJetFwd140_v30, process.HLT_AK8PFJetFwd200_v30, process.HLT_AK8PFJetFwd260_v31, process.HLT_AK8PFJetFwd320_v31, process.HLT_AK8PFJetFwd400_v31, process.HLT_AK8PFJetFwd450_v31, process.HLT_AK8PFJetFwd500_v31, process.HLT_PFHT180_v33, process.HLT_PFHT250_v33, process.HLT_PFHT370_v33, process.HLT_PFHT430_v33, process.HLT_PFHT510_v33, process.HLT_PFHT590_v33, process.HLT_PFHT680_v33, process.HLT_PFHT780_v33, process.HLT_PFHT890_v33, process.HLT_PFHT1050_v34, process.HLT_PFHT500_PFMET100_PFMHT100_IDTight_v28, process.HLT_PFHT500_PFMET110_PFMHT110_IDTight_v28, process.HLT_PFHT700_PFMET85_PFMHT85_IDTight_v28, process.HLT_PFHT800_PFMET75_PFMHT75_IDTight_v28, process.HLT_PFMET120_PFMHT120_IDTight_v36, process.HLT_PFMET130_PFMHT130_IDTight_v36, process.HLT_PFMET140_PFMHT140_IDTight_v36, process.HLT_PFMET120_PFMHT120_IDTight_PFHT60_v25, process.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_PFHT60_v25, process.HLT_PFMETTypeOne140_PFMHT140_IDTight_v27, process.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_v36, process.HLT_PFMETNoMu130_PFMHTNoMu130_IDTight_v35, process.HLT_PFMETNoMu140_PFMHTNoMu140_IDTight_v35, process.HLT_PFMETNoMu110_PFMHTNoMu110_IDTight_FilterHF_v16, process.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_FilterHF_v16, process.HLT_PFMETNoMu130_PFMHTNoMu130_IDTight_FilterHF_v16, process.HLT_PFMETNoMu140_PFMHTNoMu140_IDTight_FilterHF_v16, process.HLT_L1ETMHadSeeds_v11, process.HLT_CaloMHT90_v16, process.HLT_CaloMET90_NotCleaned_v16, process.HLT_CaloMET350_NotCleaned_v16, process.HLT_PFMET200_NotCleaned_v25, process.HLT_PFMET250_NotCleaned_v25, process.HLT_PFMET300_NotCleaned_v25, process.HLT_PFMET200_BeamHaloCleaned_v25, process.HLT_PFMETTypeOne200_BeamHaloCleaned_v25, process.HLT_MET105_IsoTrk50_v23, process.HLT_MET120_IsoTrk50_v23, process.HLT_Mu12eta2p3_v17, process.HLT_Mu12eta2p3_PFJet40_v17, process.HLT_Mu12_DoublePFJets40_PNetBTag_0p11_v10, process.HLT_Mu12_DoublePFJets100_PNetBTag_0p11_v10, process.HLT_Mu12_DoublePFJets200_PNetBTag_0p11_v10, process.HLT_Mu12_DoublePFJets350_PNetBTag_0p11_v10, process.HLT_Mu12_DoublePFJets40MaxDeta1p6_PNet2BTag_0p11_v10, process.HLT_Mu12_DoublePFJets54MaxDeta1p6_PNet2BTag_0p11_v10, process.HLT_DoublePFJets40_PNetBTag_0p11_v10, process.HLT_DoublePFJets100_PNetBTag_0p11_v10, process.HLT_DoublePFJets200_PNetBTag_0p11_v10, process.HLT_DoublePFJets350_PNetBTag_0p11_v10, process.HLT_DoublePFJets116MaxDeta1p6_PNet2BTag_0p11_v10, process.HLT_DoublePFJets128MaxDeta1p6_PNet2BTag_0p11_v10, process.HLT_Photon300_NoHE_v24, process.HLT_Mu8_TrkIsoVVL_v28, process.HLT_Mu8_DiEle12_CaloIdL_TrackIdL_DZ_v34, process.HLT_Mu8_DiEle12_CaloIdL_TrackIdL_v34, process.HLT_Mu8_Ele8_CaloIdM_TrackIdM_Mass8_PFHT350_DZ_v35, process.HLT_Mu8_Ele8_CaloIdM_TrackIdM_Mass8_PFHT350_v35, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_v29, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_v17, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v27, process.HLT_Mu17_TrkIsoVVL_v29, process.HLT_Mu19_TrkIsoVVL_v20, process.HLT_BTagMu_AK4DiJet20_Mu5_v29, process.HLT_BTagMu_AK4DiJet40_Mu5_v29, process.HLT_BTagMu_AK4DiJet70_Mu5_v29, process.HLT_BTagMu_AK4DiJet110_Mu5_v29, process.HLT_BTagMu_AK4DiJet170_Mu5_v28, process.HLT_BTagMu_AK4Jet300_Mu5_v28, process.HLT_BTagMu_AK8DiJet170_Mu5_v25, process.HLT_BTagMu_AK8Jet170_DoubleMu5_v18, process.HLT_BTagMu_AK8Jet300_Mu5_v28, process.HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v33, process.HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_v33, process.HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v31, process.HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v23, process.HLT_Mu12_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v23, process.HLT_Mu12_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_v31, process.HLT_Mu12_IsoVVL_PFHT150_PNetBTag0p53_v9, process.HLT_Photon33_v16, process.HLT_Photon50_v24, process.HLT_Photon75_v24, process.HLT_Photon90_v24, process.HLT_Photon120_v24, process.HLT_Photon150_v18, process.HLT_Photon175_v26, process.HLT_Photon200_v25, process.HLT_Photon45EB_v4, process.HLT_Photon40EB_v4, process.HLT_Photon50EB_v5, process.HLT_Photon30EB_TightID_TightIso_v15, process.HLT_Photon40EB_TightID_TightIso_v6, process.HLT_Photon45EB_TightID_TightIso_v6, process.HLT_Photon50EB_TightID_TightIso_PFJet30_v10, process.HLT_Photon50EB_TightID_TightIso_CaloJet30_v6, process.HLT_Photon50EB_TightID_TightIso_AK8PFJet30_v9, process.HLT_Photon50EB_TightID_TightIso_AK8CaloJet30_v6, process.HLT_Photon50EB_TightID_TightIso_v11, process.HLT_Photon55EB_TightID_TightIso_v7, process.HLT_Photon75EB_TightID_TightIso_v11, process.HLT_Photon90EB_TightID_TightIso_v11, process.HLT_Photon110EB_TightID_TightIso_v15, process.HLT_Photon110EB_TightID_TightIso_PFJet30_v10, process.HLT_Photon110EB_TightID_TightIso_CaloJet30_v6, process.HLT_Photon110EB_TightID_TightIso_AK8PFJet30_v9, process.HLT_Photon110EB_TightID_TightIso_AK8CaloJet30_v6, process.HLT_Photon100EBHE10_v13, process.HLT_Photon50_R9Id90_HE10_IsoM_v27, process.HLT_Photon75_R9Id90_HE10_IsoM_v27, process.HLT_Photon90_R9Id90_HE10_IsoM_v27, process.HLT_Photon120_R9Id90_HE10_IsoM_v27, process.HLT_Photon165_R9Id90_HE10_IsoM_v28, process.HLT_Diphoton30_22_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass90_v26, process.HLT_Diphoton30_22_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass95_v26, process.HLT_Photon35_TwoProngs35_v17, process.HLT_IsoMu24_TwoProngs35_v17, process.HLT_Dimuon0_Jpsi_L1_NoOS_v23, process.HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23, process.HLT_Dimuon0_Jpsi_v24, process.HLT_Dimuon0_Jpsi_NoVertexing_v24, process.HLT_Dimuon0_Jpsi_L1_4R_0er1p5R_v23, process.HLT_Dimuon0_Jpsi_NoVertexing_L1_4R_0er1p5R_v23, process.HLT_Dimuon0_Jpsi3p5_Muon2_v21, process.HLT_Dimuon0_Upsilon_L1_4p5_v25, process.HLT_Dimuon0_Upsilon_L1_4p5er2p0_v25, process.HLT_Dimuon0_Upsilon_L1_4p5er2p0M_v23, process.HLT_Dimuon0_Upsilon_NoVertexing_v23, process.HLT_Dimuon0_LowMass_L1_0er1p5_v24, process.HLT_Dimuon0_LowMass_v24, process.HLT_Dimuon0_LowMass_L1_4_v24, process.HLT_Dimuon0_LowMass_Inclusive_v1, process.HLT_Dimuon0_LowMass_L1_TM530_v22, process.HLT_Dimuon0_Upsilon_Muon_NoL1Mass_v22, process.HLT_Dimuon0_Upsilon_v2, process.HLT_TripleMu_5_3_3_Mass3p8_DZ_v24, process.HLT_TripleMu_10_5_5_DZ_v26, process.HLT_TripleMu_12_10_5_v26, process.HLT_Tau3Mu_Mu7_Mu1_TkMu1_Tau15_v20, process.HLT_Tau3Mu_Mu7_Mu1_TkMu1_Tau15_Charge1_v20, process.HLT_Tau3Mu_Mu7_Mu1_TkMu1_IsoTau15_v20, process.HLT_Tau3Mu_Mu7_Mu1_TkMu1_IsoTau15_Charge1_v20, process.HLT_DoubleMu3_DZ_PFMET50_PFMHT60_v26, process.HLT_DoubleMu3_DZ_PFMET70_PFMHT70_v26, process.HLT_DoubleMu3_DZ_PFMET90_PFMHT90_v26, process.HLT_DoubleMu3_Trk_Tau3mu_NoL1Mass_v22, process.HLT_DoubleMu4_3_LowMass_SS_v10, process.HLT_DoubleMu4_Jpsi_Displaced_v23, process.HLT_DoubleMu4_Jpsi_NoVertexing_v23, process.HLT_DoubleMu4_JpsiTrkTrk_Displaced_v23, process.HLT_DoubleMu4_JpsiTrk_Bc_v16, process.HLT_DoubleMu43NoFiltersNoVtx_v17, process.HLT_DoubleMu48NoFiltersNoVtx_v17, process.HLT_Mu43NoFiltersNoVtx_Photon43_CaloIdL_v18, process.HLT_Mu48NoFiltersNoVtx_Photon48_CaloIdL_v18, process.HLT_Mu38NoFiltersNoVtxDisplaced_Photon38_CaloIdL_v14, process.HLT_Mu43NoFiltersNoVtxDisplaced_Photon43_CaloIdL_v14, process.HLT_Ele28_HighEta_SC20_Mass55_v27, process.HLT_Ele15_IsoVVVL_PFHT450_PFMET50_v32, process.HLT_Ele15_IsoVVVL_PFHT450_v32, process.HLT_Ele50_IsoVVVL_PFHT450_v32, process.HLT_Ele15_IsoVVVL_PFHT600_v36, process.HLT_Mu15_IsoVVVL_PFHT450_PFMET50_v31, process.HLT_Mu15_IsoVVVL_PFHT450_v31, process.HLT_Mu50_IsoVVVL_PFHT450_v31, process.HLT_Mu15_IsoVVVL_PFHT600_v35, process.HLT_Mu3er1p5_PFJet100er2p5_PFMET80_PFMHT80_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMET90_PFMHT90_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMET100_PFMHT100_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu80_PFMHTNoMu80_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu90_PFMHTNoMu90_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu100_PFMHTNoMu100_IDTight_v18, process.HLT_Dimuon10_Upsilon_y1p4_v17, process.HLT_Dimuon12_Upsilon_y1p4_v18, process.HLT_Dimuon14_Phi_Barrel_Seagulls_v23, process.HLT_Dimuon25_Jpsi_v30, process.HLT_Dimuon14_PsiPrime_v29, process.HLT_Dimuon14_PsiPrime_noCorrL1_v21, process.HLT_Dimuon18_PsiPrime_v30, process.HLT_Dimuon18_PsiPrime_noCorrL1_v22, process.HLT_Dimuon24_Upsilon_noCorrL1_v22, process.HLT_Dimuon24_Phi_noCorrL1_v22, process.HLT_Dimuon25_Jpsi_noCorrL1_v22, process.HLT_DiMu4_Ele9_CaloIdL_TrackIdL_DZ_Mass3p8_v33, process.HLT_DiMu9_Ele9_CaloIdL_TrackIdL_DZ_v33, process.HLT_DiMu9_Ele9_CaloIdL_TrackIdL_v33, process.HLT_DoubleIsoMu20_eta2p1_v23, process.HLT_TrkMu12_DoubleTrkMu5NoFiltersNoVtx_v21, process.HLT_Mu8_v28, process.HLT_Mu17_v29, process.HLT_Mu19_v20, process.HLT_Mu17_Photon30_IsoCaloId_v22, process.HLT_Ele8_CaloIdL_TrackIdL_IsoVL_PFJet30_v32, process.HLT_Ele12_CaloIdL_TrackIdL_IsoVL_PFJet30_v34, process.HLT_Ele14_eta2p5_IsoVVVL_Gsf_PFHT200_PNetBTag0p53_v9, process.HLT_Ele23_CaloIdL_TrackIdL_IsoVL_PFJet30_v34, process.HLT_Ele8_CaloIdM_TrackIdM_PFJet30_v34, process.HLT_Ele17_CaloIdM_TrackIdM_PFJet30_v32, process.HLT_Ele23_CaloIdM_TrackIdM_PFJet30_v34, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_PFJet165_v34, process.HLT_Ele115_CaloIdVT_GsfTrkIdT_v28, process.HLT_Ele135_CaloIdVT_GsfTrkIdT_v21, process.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_v25, process.HLT_PFHT400_SixPFJet32_v25, process.HLT_PFHT400_SixPFJet32_PNet2BTagMean0p50_v13, process.HLT_PFHT450_SixPFJet36_v24, process.HLT_PFHT450_SixPFJet36_PNetBTag0p35_v13, process.HLT_PFHT400_FivePFJet_120_120_60_30_30_v10, process.HLT_PFHT350_v35, process.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT350_v14, process.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT380_v14, process.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT400_v14, process.HLT_ECALHT800_v22, process.HLT_DiSC30_18_EIso_AND_HE_Mass70_v25, process.HLT_Photon20_HoverELoose_v21, process.HLT_Photon30_HoverELoose_v21, process.HLT_L1_CDC_SingleMu_3_er1p2_TOP120_DPHI2p618_3p142_v10, process.HLT_CDC_L2cosmic_10_er1p0_v11, process.HLT_CDC_L2cosmic_5p5_er1p0_v11, process.HLT_Photon60_R9Id90_HE10_IsoM_EBOnly_PFJetsMJJ300DEta3_v13, process.HLT_Photon75_R9Id90_HE10_IsoM_EBOnly_PFJetsMJJ300DEta3_v21, process.HLT_Mu18_Mu9_SameSign_v20, process.HLT_DoubleMu2_Jpsi_DoubleTrk1_Phi1p05_v22, process.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_v26, process.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_Mass2p0_v10, process.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_Mass2p0_noDCA_v10, process.HLT_TripleMu_5_3_3_Mass3p8_DCA_v19, process.HLT_QuadPFJet103_88_75_15_v21, process.HLT_QuadPFJet105_88_76_15_v21, process.HLT_QuadPFJet111_90_80_15_v21, process.HLT_Diphoton30_18_R9IdL_AND_HE_AND_IsoCaloId_v14, process.HLT_Diphoton30_18_R9IdL_AND_HE_AND_IsoCaloId_Mass55_v14, process.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Tight_eta2p3_CrossL1_v11, process.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Medium_eta2p3_CrossL1_v11, process.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Loose_eta2p3_CrossL1_v11, process.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_PNet3BTag_4p3_v9, process.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_PNet3BTag_2p0_v9, process.HLT_PFHT400_FivePFJet_120_120_60_30_30_PNet2BTag_5p6_v10, process.HLT_PFHT400_FivePFJet_120_120_60_30_30_PNet2BTag_4p3_v10, process.HLT_QuadPFJet103_88_75_15_PNetBTag_0p4_VBF2_v10, process.HLT_QuadPFJet103_88_75_15_PNet2BTag_0p4_0p12_VBF1_v10, process.HLT_QuadPFJet105_88_76_15_PNetBTag_0p4_VBF2_v10, process.HLT_QuadPFJet105_88_76_15_PNet2BTag_0p4_0p12_VBF1_v10, process.HLT_QuadPFJet111_90_80_15_PNetBTag_0p4_VBF2_v10, process.HLT_QuadPFJet111_90_80_15_PNet2BTag_0p4_0p12_VBF1_v10, process.HLT_PFHT250_QuadPFJet25_v10, process.HLT_PFHT250_QuadPFJet25_PNet2BTagMean0p55_v10, process.HLT_PFHT250_QuadPFJet25_PNet1BTag0p20_PNet1Tauh0p50_v10, process.HLT_PFHT250_QuadPFJet30_PNet2BTagMean0p55_v10, process.HLT_PFHT250_QuadPFJet30_PNet1BTag0p20_PNet1Tauh0p50_v10, process.HLT_PFHT280_QuadPFJet30_PNet1BTag0p20_PNet1Tauh0p50_v10, process.HLT_PFHT280_QuadPFJet30_v13, process.HLT_PFHT280_QuadPFJet30_PNet2BTagMean0p55_v13, process.HLT_PFHT280_QuadPFJet30_PNet2BTagMean0p60_v13, process.HLT_PFHT280_QuadPFJet35_PNet2BTagMean0p60_v13, process.HLT_PFHT340_QuadPFJet70_50_40_40_PNet2BTagMean0p70_v14, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_v13, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_QuadPFJet30_v13, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_QuadPFJet30_PNet2BTagMean0p55_v13, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PNet2BTagMean0p50_v13, process.HLT_QuadPFJet100_88_70_30_v14, process.HLT_QuadPFJet105_88_75_30_v13, process.HLT_QuadPFJet111_90_80_30_v13, process.HLT_QuadPFJet100_88_70_30_PNet1CvsAll0p5_VBF3Tight_v14, process.HLT_QuadPFJet105_88_75_30_PNet1CvsAll0p5_VBF3Tight_v14, process.HLT_QuadPFJet111_90_80_30_PNet1CvsAll0p6_VBF3Tight_v14, process.HLT_AK8PFJet220_SoftDropMass40_v17, process.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p50_v13, process.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p53_v13, process.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p55_v13, process.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p60_v13, process.HLT_AK8PFJet230_SoftDropMass40_v17, process.HLT_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, process.HLT_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, process.HLT_AK8PFJet230_SoftDropMass40_PNetTauTau0p03_v13, process.HLT_AK8PFJet230_SoftDropMass40_PNetTauTau0p05_v13, process.HLT_AK8PFJet250_SoftDropMass40_PNetBB0p06_v13, process.HLT_AK8PFJet250_SoftDropMass40_PNetBB0p10_v13, process.HLT_AK8PFJet250_SoftDropMass40_PNetTauTau0p03_v13, process.HLT_AK8PFJet250_SoftDropMass40_PNetTauTau0p05_v13, process.HLT_AK8PFJet275_SoftDropMass40_PNetBB0p06_v13, process.HLT_AK8PFJet275_SoftDropMass40_PNetBB0p10_v13, process.HLT_AK8PFJet275_SoftDropMass40_PNetTauTau0p03_v13, process.HLT_AK8PFJet275_SoftDropMass40_PNetTauTau0p05_v13, process.HLT_AK8PFJet275_Nch45_v10, process.HLT_AK8PFJet275_Nch40_v10, process.HLT_IsoMu50_AK8PFJet220_SoftDropMass40_v16, process.HLT_IsoMu50_AK8PFJet220_SoftDropMass40_PNetBB0p06_v13, process.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_v16, process.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, process.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet220_SoftDropMass40_v16, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet220_SoftDropMass40_PNetBB0p06_v13, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_v16, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_DoubleAK4PFJet60_30_v14, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_DoubleAK4PFJet60_30_PNet2BTagMean0p50_v14, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_v10, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_v10, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_PNet2BTagMean0p55_v10, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_PNet1BTag0p20_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Medium_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Tight_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_PFJet60_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_PFJet75_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Tight_eta2p3_CrossL1_ETau_Monitoring_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Medium_eta2p3_CrossL1_ETau_Monitoring_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Loose_eta2p3_CrossL1_ETau_Monitoring_v10, process.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Tight_eta2p3_CrossL1_v10, process.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Medium_eta2p3_CrossL1_v10, process.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Loose_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet20_eta2p2_SingleL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet45_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PFHT250_v10, process.HLT_IsoMu24_eta2p1_PFHT250_QuadPFJet25_v10, process.HLT_IsoMu24_eta2p1_PFHT250_QuadPFJet25_PNet1Tauh0p50_v10, process.HLT_IsoMu24_eta2p1_SinglePFJet25_PNet1Tauh0p50_v10, process.HLT_DoublePNetTauhPFJet30_Medium_L2NN_eta2p3_v10, process.HLT_DoublePNetTauhPFJet30_Tight_L2NN_eta2p3_v10, process.HLT_DoublePNetTauhPFJet26_L2NN_eta2p3_PFJet60_v10, process.HLT_DoublePNetTauhPFJet26_L2NN_eta2p3_PFJet75_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Loose_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Medium_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Tight_L2NN_eta2p3_CrossL1_v10, process.HLT_SinglePNetTauhPFJet130_Loose_L2NN_eta2p3_v10, process.HLT_SinglePNetTauhPFJet130_Medium_L2NN_eta2p3_v10, process.HLT_SinglePNetTauhPFJet130_Tight_L2NN_eta2p3_v10, process.HLT_DoubleL2Mu10NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v16, process.HLT_DoubleL2Mu12NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, process.HLT_DoubleL2Mu14NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, process.HLT_DoubleL3Mu16_10NoVtx_DxyMin0p01cm_v14, process.HLT_DoubleL3Mu18_10NoVtx_DxyMin0p01cm_v13, process.HLT_DoubleL3Mu20_10NoVtx_DxyMin0p01cm_v13, process.HLT_L2Mu10NoVtx_2Cha_v10, process.HLT_L2Mu10NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, process.HLT_L3Mu10NoVtx_v13, process.HLT_L3Mu10NoVtx_DxyMin0p01cm_v13, process.HLT_DoubleL2Mu_L3Mu16NoVtx_VetoL3Mu0DxyMax0p1cm_v13, process.HLT_DoubleL2Mu_L3Mu18NoVtx_VetoL3Mu0DxyMax0p1cm_v13, process.HLT_DoubleL2Mu10NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, process.HLT_DoubleL2Mu12NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, process.HLT_L2Mu10NoVtx_2Cha_CosmicSeed_v10, process.HLT_L2Mu10NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, process.HLT_DoubleL3dTksMu16_10NoVtx_DxyMin0p01cm_v14, process.HLT_L2Mu50NoVtx_3Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v8, process.HLT_L2Mu50NoVtx_3Cha_VetoL3Mu0DxyMax1cm_v8, process.HLT_L3Mu30NoVtx_DxyMin0p01cm_v6, process.HLT_L3Mu50NoVtx_DxyMin0p01cm_v6, process.HLT_L3dTksMu10_NoVtx_DxyMin0p01cm_v14, process.HLT_Mu20NoFiltersNoVtxDisplaced_Photon20_CaloCustomId_v14, process.HLT_DisplacedMu24_MediumChargedIsoDisplacedPFTauHPS24_v12, process.HLT_Photon34_R9Id90_CaloIdL_IsoL_DisplacedIdL_MediumChargedIsoDisplacedPFTauHPS34_v12, process.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS32_Trk1_eta2p1_v17, process.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS36_Trk1_eta2p1_v12, process.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS32_Trk1_eta2p1_noDxy_v12, process.HLT_IsoMu27_MediumChargedIsoDisplacedPFTauHPS24_eta2p1_SingleL1_v12, process.HLT_HT350_DelayedJet40_SingleDelay1p5To3p5nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay1p6To3p5nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay1p75To3p5nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay3nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay3p25nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay3p5nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay0p5nsInclusive_v11, process.HLT_HT430_DelayedJet40_SingleDelay1nsInclusive_v11, process.HLT_HT430_DelayedJet40_SingleDelay1To1p5nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay1p1To1p6nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay1p25To1p75nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay1p5nsInclusive_v11, process.HLT_HT430_DelayedJet40_SingleDelay2nsInclusive_v13, process.HLT_HT430_DelayedJet40_SingleDelay2p25nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay2p5nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay0p5nsTrackless_v12, process.HLT_HT430_DelayedJet40_SingleDelay1nsTrackless_v14, process.HLT_HT430_DelayedJet40_SingleDelay1p25nsTrackless_v10, process.HLT_HT430_DelayedJet40_SingleDelay1p5nsTrackless_v10, process.HLT_HT430_DelayedJet40_DoubleDelay0p5nsInclusive_v12, process.HLT_HT430_DelayedJet40_DoubleDelay1nsInclusive_v13, process.HLT_HT430_DelayedJet40_DoubleDelay1p25nsInclusive_v9, process.HLT_HT430_DelayedJet40_DoubleDelay1p5nsInclusive_v9, process.HLT_HT430_DelayedJet40_DoubleDelay0p5nsTrackless_v14, process.HLT_HT430_DelayedJet40_DoubleDelay0p75nsTrackless_v10, process.HLT_HT430_DelayedJet40_DoubleDelay1nsTrackless_v10, process.HLT_L1Tau_DelayedJet40_SingleDelay2p5To4nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay2p6To4nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay2p75To4nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay3p5nsInclusive_v11, process.HLT_L1Tau_DelayedJet40_SingleDelay3p75nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay4nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay2p5nsTrackless_v12, process.HLT_L1Tau_DelayedJet40_SingleDelay2p75nsTrackless_v10, process.HLT_L1Tau_DelayedJet40_SingleDelay3nsTrackless_v10, process.HLT_L1Tau_DelayedJet40_DoubleDelay0p75nsInclusive_v11, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p25nsInclusive_v11, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p5nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p75nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_DoubleDelay0p5nsTrackless_v12, process.HLT_L1Tau_DelayedJet40_DoubleDelay1nsTrackless_v12, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p25nsTrackless_v10, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p5nsTrackless_v10, process.HLT_L1Mu6HT240_v10, process.HLT_Mu6HT240_DisplacedDijet30_Inclusive1PtrkShortSig5_DisplacedLoose_v14, process.HLT_Mu6HT240_DisplacedDijet35_Inclusive0PtrkShortSig5_v14, process.HLT_Mu6HT240_DisplacedDijet35_Inclusive1PtrkShortSig5_DisplacedLoose_v14, process.HLT_Mu6HT240_DisplacedDijet40_Inclusive0PtrkShortSig5_v14, process.HLT_Mu6HT240_DisplacedDijet40_Inclusive1PtrkShortSig5_DisplacedLoose_v14, process.HLT_Mu6HT240_DisplacedDijet45_Inclusive0PtrkShortSig5_v14, process.HLT_Mu6HT240_DisplacedDijet50_Inclusive0PtrkShortSig5_v14, process.HLT_HT350_v9, process.HLT_HT425_v21, process.HLT_HT360_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, process.HLT_HT360_DisplacedDijet45_Inclusive1PtrkShortSig5_v10, process.HLT_HT390_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, process.HLT_HT390_DisplacedDijet45_Inclusive1PtrkShortSig5_v10, process.HLT_HT390eta2p0_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, process.HLT_HT430_DisplacedDijet40_Inclusive1PtrkShortSig5_v14, process.HLT_HT400_DisplacedDijet40_DisplacedTrack_v26, process.HLT_HT430_DisplacedDijet40_DisplacedTrack_v26, process.HLT_HT550_DisplacedDijet60_Inclusive_v26, process.HLT_HT650_DisplacedDijet60_Inclusive_v26, process.HLT_CaloMET60_DTCluster50_v13, process.HLT_CaloMET60_DTClusterNoMB1S50_v13, process.HLT_L1MET_DTCluster50_v13, process.HLT_L1MET_DTClusterNoMB1S50_v13, process.HLT_CscCluster_Loose_v11, process.HLT_CscCluster_Medium_v11, process.HLT_CscCluster_Tight_v11, process.HLT_CscCluster50_Photon20Unseeded_v5, process.HLT_CscCluster50_Photon30Unseeded_v5, process.HLT_CscCluster100_Ele5_v7, process.HLT_CscCluster100_Mu5_v10, process.HLT_CscCluster100_PNetTauhPFJet10_Loose_v10, process.HLT_CscCluster150_DisplacedSingleJet30_Inclusive1PtrkShortSig5_v3, process.HLT_CscCluster150_DisplacedSingleJet35_Inclusive1PtrkShortSig5_v3, process.HLT_CscCluster150_DisplacedSingleJet40_Inclusive1PtrkShortSig5_v3, process.HLT_DoubleCscCluster75_v8, process.HLT_IsoTrk200_L1SingleMuShower_v8, process.HLT_IsoTrk400_L1SingleMuShower_v8, process.HLT_DoubleCscCluster100_v8, process.HLT_L1CSCShower_DTCluster50_v11, process.HLT_L1CSCShower_DTCluster75_v11, process.HLT_PFMET105_IsoTrk50_v17, process.HLT_L1SingleLLPJet_v8, process.HLT_L1SingleMuShower_v1, process.HLT_HT170_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, process.HLT_HT200_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, process.HLT_HT200_L1SingleLLPJet_DisplacedDijet60_DisplacedTrack_v14, process.HLT_HT270_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, process.HLT_HT200_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v14, process.HLT_HT240_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11, process.HLT_HT280_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11, process.HLT_HT320_L1SingleLLPJet_DisplacedDijet60_Inclusive_v14, process.HLT_HT420_L1SingleLLPJet_DisplacedDijet60_Inclusive_v14, process.HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay1nsTrackless_v14, process.HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay2nsInclusive_v14, process.HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay0p5nsTrackless_v14, process.HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay1nsInclusive_v14, process.HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p7_v10, process.HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p8_v10, process.HLT_DiPhoton10Time1ns_v11, process.HLT_DiPhoton10Time1p2ns_v11, process.HLT_DiPhoton10Time1p4ns_v11, process.HLT_DiPhoton10Time1p6ns_v11, process.HLT_DiPhoton10Time1p8ns_v11, process.HLT_DiPhoton10Time2ns_v11, process.HLT_DiPhoton10_CaloIdL_v11, process.HLT_DiphotonMVA14p25_Low_Mass60_v1, process.HLT_DiphotonMVA14p25_Medium_Mass60_v1, process.HLT_DiphotonMVA14p25_High_Mass60_v1, process.HLT_DiphotonMVA14p25_TightLow_Mass60_v1, process.HLT_DiphotonMVA14p25_TightMedium_Mass60_v1, process.HLT_DiphotonMVA14p25_TightHigh_Mass60_v1, process.HLT_Diphoton15_10_EBEB_TightID_ECALTrackIsoDr0p2_v3, process.HLT_Diphoton15_12_EBEB_TightID_ECALTrackIsoDr0p2_v3, process.HLT_Diphoton15_10_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v3, process.HLT_Diphoton15_12_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v3, process.HLT_Dielectron12_5_EBEB_TightID_ECALTrackIsoDr0p2_v4, process.HLT_Dielectron12_5_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v4, process.HLT_DoubleEle6p5_eta1p22_mMax6_v13, process.HLT_DoubleEle8_eta1p22_mMax6_v13, process.HLT_DoubleEle10_eta1p22_mMax6_v13, process.HLT_SingleEle8_v12, process.HLT_SingleEle8_SingleEGL1_v12, process.HLT_Diphoton20_14_eta1p5_R9IdL_AND_HE_AND_IsoTCaloIdT_v13, process.HLT_Diphoton20_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, process.HLT_Diphoton22_14_eta1p5_R9IdL_AND_HE_AND_IsoTCaloIdT_v13, process.HLT_Diphoton22_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, process.HLT_Diphoton24_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, process.HLT_Diphoton24_16_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, process.HLT_Mu50_L1SingleMuShower_v15, process.HLT_IsoMu24_OneProng32_v13, process.HLT_Photon32_OneProng32_M50To105_v14, process.HLT_VBF_DiPFJet125_45_Mjj1050_v12, process.HLT_VBF_DiPFJet125_45_Mjj1150_v4, process.HLT_VBF_DiPFJet125_45_Mjj1250_v4, process.HLT_VBF_DiPFJet75_45_Mjj800_DiPFJet60_v10, process.HLT_VBF_DiPFJet75_45_Mjj900_DiPFJet60_v4, process.HLT_VBF_DiPFJet75_45_Mjj1000_DiPFJet60_v4, process.HLT_VBF_DiPFJet80_45_Mjj650_PFMETNoMu85_v10, process.HLT_VBF_DiPFJet80_45_Mjj750_PFMETNoMu85_v10, process.HLT_VBF_DiPFJet80_45_Mjj850_PFMETNoMu85_v4, process.HLT_VBF_DiPFJet95_45_Mjj750_Mu3_TrkIsoVVL_v10, process.HLT_VBF_DiPFJet95_45_Mjj850_Mu3_TrkIsoVVL_v10, process.HLT_VBF_DiPFJet95_45_Mjj950_Mu3_TrkIsoVVL_v4, process.HLT_VBF_DiPFJet50_Mjj650_Photon22_v10, process.HLT_VBF_DiPFJet50_Mjj750_Photon22_v10, process.HLT_VBF_DiPFJet50_Mjj850_Photon22_v4, process.HLT_VBF_DiPFJet50_Mjj600_Ele22_eta2p1_WPTight_Gsf_v11, process.HLT_VBF_DiPFJet50_Mjj700_Ele22_eta2p1_WPTight_Gsf_v5, process.HLT_VBF_DiPFJet50_Mjj800_Ele22_eta2p1_WPTight_Gsf_v5, process.HLT_VBF_DiPFJet115_40_Mjj850_DoublePNetTauhPFJet20_eta2p3_v4, process.HLT_VBF_DiPFJet115_40_Mjj1000_DoublePNetTauhPFJet20_eta2p3_v4, process.HLT_VBF_DiPFJet115_40_Mjj1100_DoublePNetTauhPFJet20_eta2p3_v4, process.HLT_VBF_DiPFJet115_40_Mjj1200_DoublePNetTauhPFJet20_eta2p3_v4, process.HLT_VBF_DiPFJet45_Mjj650_PNetTauhPFJet45_L2NN_eta2p3_v10, process.HLT_VBF_DiPFJet45_Mjj750_PNetTauhPFJet45_L2NN_eta2p3_v10, process.HLT_VBF_DiPFJet45_Mjj850_PNetTauhPFJet45_L2NN_eta2p3_v4, process.HLT_L1HT200_QuadPFJet20_PNet1BTag0p50_PNet1Tauh0p50_v4, process.HLT_L1HT200_QuadPFJet25_PNet1BTag0p50_PNet1Tauh0p50_v4, process.HLT_IsoMu24_eta2p1_L1HT200_v4, process.HLT_IsoMu24_eta2p1_L1HT200_QuadPFJet25_v4, process.HLT_IsoMu24_eta2p1_L1HT200_QuadPFJet25_PNet1Tauh0p50_v4, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_v4, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet20_v4, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet25_v4, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet25_PNet1BTag0p50_v4, process.HLT_PFJet200_TimeLtNeg2p5ns_v14, process.HLT_PFJet200_TimeGt2p5ns_v14, process.HLT_Photon50_TimeLtNeg2p5ns_v8, process.HLT_Photon50_TimeGt2p5ns_v8, process.HLT_PPSMaxTracksPerArm1_v10, process.HLT_PPSMaxTracksPerRP4_v10, process.HLT_PPSRandom_v1, process.HLT_HIL1NotBptxOR_v15, process.HLT_HIL1UnpairedBunchBptxPlus_v15, process.HLT_HIL1UnpairedBunchBptxMinus_v15, process.HLT_HIPhysics_v15, process.HLT_HIPhysicsForZS_v15, process.HLT_HIRandom_v8, process.HLT_HIRandom_HighRate_v4, process.HLT_HIHcalNZS_v15, process.HLT_HIHcalPhiSym_v15, process.HLT_HIZeroBias_v15, process.HLT_HIZeroBias_HighRate_v8, process.HLT_HIZeroBias_FirstCollisionAfterAbortGap_v15, process.HLT_HIZeroBias_HighRateRAW_v5, process.HLT_HIMinimumBiasHF1AND_v8, process.HLT_HIMinimumBiasHF1AND_copy_v7, process.HLT_HIMinimumBiasHF1ANDZDC1nOR_v5, process.HLT_HIMinimumBiasHF1ANDZDC2nOR_v8, process.HLT_HIMinimumBiasHF1ANDZDC1nOR_copy_v5, process.HLT_HIMinimumBiasHF1ANDZDC2nOR_copy_v7, process.HLT_HICentrality30100_FirstCollisionAfterAbortGap_v15, process.HLT_HICentrality50100MinimumBiasHF1AND_Beamspot_v2, process.HLT_HIL1Centrality30_50_v8, process.HLT_HIL1_UCC_0_0p5_v9, process.HLT_HIL1_UCC_0_1_v9, process.HLT_HIPuAK4CaloJet40Eta5p1_MinBiasHF1AND_v8, process.HLT_HIPuAK4CaloJet40Eta5p1_MinBiasHF1AND_ZDC1nOR_v6, process.HLT_HIPuAK4CaloJet40Eta5p1_MinBiasHF1AND_ZDC2nOR_v8, process.HLT_HIPuAK4CaloJet60Eta5p1_MinBiasHF1AND_v8, process.HLT_HIPuAK4CaloJet60Eta5p1_MinBiasHF1AND_ZDC1nOR_v6, process.HLT_HIPuAK4CaloJet60Eta5p1_MinBiasHF1AND_ZDC2nOR_v8, process.HLT_HIPuAK4CaloJet80Eta5p1_v16, process.HLT_HIPuAK4CaloJet100Eta5p1_v16, process.HLT_HIPuAK4CaloJet120Eta2p1_v9, process.HLT_HIPuAK4CaloJet120Eta5p1_v16, process.HLT_HIPuAK4CaloJet40Fwd_v9, process.HLT_HIPuAK4CaloJet60Fwd_v9, process.HLT_HIPuAK4CaloJet80Fwd_v9, process.HLT_HIPuAK4CaloJet100Fwd_v9, process.HLT_HIPuAK4CaloJet120Fwd_v9, process.HLT_HIGEDPhoton10_v16, process.HLT_HIGEDPhoton10_EB_v16, process.HLT_HIGEDPhoton20_v16, process.HLT_HIGEDPhoton20_EB_v16, process.HLT_HIGEDPhoton30_v16, process.HLT_HIGEDPhoton30_EB_v16, process.HLT_HIGEDPhoton40_v16, process.HLT_HIGEDPhoton40_EB_v16, process.HLT_HIGEDPhoton50_v16, process.HLT_HIGEDPhoton50_EB_v16, process.HLT_HIGEDPhoton60_v16, process.HLT_HIGEDPhoton60_EB_v16, process.HLT_HIDoubleGEDPhoton20_v9, process.HLT_HIEle10Gsf_v16, process.HLT_HIEle15Gsf_v16, process.HLT_HIEle20Gsf_v16, process.HLT_HIEle30Gsf_v16, process.HLT_HIEle40Gsf_v16, process.HLT_HIEle50Gsf_v16, process.HLT_HIEle15Ele10Gsf_v16, process.HLT_HIEle15Ele10GsfMass50_v16, process.HLT_HIDoubleEle10Gsf_v16, process.HLT_HIDoubleEle10GsfMass50_v16, process.HLT_HIDoubleEle15Gsf_v16, process.HLT_HIDoubleEle15GsfMass50_v16, process.HLT_HIUPC_ZeroBias_MinPixelCluster400_MaxPixelCluster10000_v15, process.HLT_HIUPC_ZeroBias_SinglePixelTrackLowPt_MaxPixelCluster400_v14, process.HLT_HIUPC_ZeroBias_SinglePixelTrack_MaxPixelTrack_v15, process.HLT_HIUPC_NotMBHF2_v6, process.HLT_HIUPC_ZDC1nOR_MinPixelCluster400_MaxPixelCluster10000_v15, process.HLT_HIUPC_ZDC1nOR_SinglePixelTrackLowPt_MaxPixelCluster400_v14, process.HLT_HIUPC_ZDC1nOR_SinglePixelTrack_MaxPixelTrack_v15, process.HLT_HIUPC_ZDC1nXOR_MBHF1AND_PixelTrackMultiplicity20_v15, process.HLT_HIUPC_ZDC1nXOR_MBHF1AND_PixelTrackMultiplicity30_v15, process.HLT_HIUPC_ZDC1nXOR_MBHF1AND_PixelTrackMultiplicity40_v15, process.HLT_HIUPC_ZDC1nXOR_MBHF2AND_PixelTrackMultiplicity20_v15, process.HLT_HIUPC_ZDC1nXOR_MBHF2AND_PixelTrackMultiplicity30_v15, process.HLT_HIUPC_ZDC1nXOR_MBHF2AND_PixelTrackMultiplicity40_v15, process.HLT_HIUPC_ZDC1nAsymXOR_MBHF1AND_PixelTrackMultiplicity20_v7, process.HLT_HIUPC_ZDC1nAsymXOR_MBHF1AND_PixelTrackMultiplicity30_v7, process.HLT_HIUPC_ZDC1nAsymXOR_MBHF1AND_PixelTrackMultiplicity40_v7, process.HLT_HIUPC_ZDC1nAsymXOR_MBHF2AND_PixelTrackMultiplicity20_v7, process.HLT_HIUPC_ZDC1nAsymXOR_MBHF2AND_PixelTrackMultiplicity30_v7, process.HLT_HIUPC_ZDC1nAsymXOR_MBHF2AND_PixelTrackMultiplicity40_v7, process.HLT_HIUPC_SingleMuCosmic_BptxAND_MaxPixelCluster1000_v8, process.HLT_HIUPC_SingleMuCosmic_NotMBHF2AND_v11, process.HLT_HIUPC_SingleMuCosmic_NotMBHF2AND_MaxPixelCluster1000_v8, process.HLT_HIUPC_SingleMuCosmic_NotMBHF2OR_v11, process.HLT_HIUPC_SingleMuCosmic_NotMBHF2OR_MaxPixelCluster1000_v8, process.HLT_HIUPC_SingleMuOpen_BptxAND_MaxPixelCluster1000_v8, process.HLT_HIUPC_SingleMuOpen_NotMBHF2AND_v13, process.HLT_HIUPC_SingleMuOpen_NotMBHF2AND_MaxPixelCluster1000_v8, process.HLT_HIUPC_SingleMuOpen_NotMBHF2OR_v13, process.HLT_HIUPC_SingleMuOpen_NotMBHF2OR_MaxPixelCluster1000_v8, process.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_BptxAND_MaxPixelCluster1000_v8, process.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2AND_v11, process.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2AND_MaxPixelCluster1000_v8, process.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2OR_v11, process.HLT_HIUPC_SingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2OR_MaxPixelCluster1000_v8, process.HLT_HIUPC_DoubleMuCosmic_BptxAND_MaxPixelCluster1000_v8, process.HLT_HIUPC_DoubleMuCosmic_NotMBHF2AND_MaxPixelCluster1000_v8, process.HLT_HIUPC_DoubleMuCosmic_NotMBHF2AND_v11, process.HLT_HIUPC_DoubleMuOpen_BptxAND_MaxPixelCluster1000_v8, process.HLT_HIUPC_DoubleMuOpen_NotMBHF2AND_v11, process.HLT_HIUPC_DoubleMuOpen_NotMBHF2AND_MaxPixelCluster1000_v8, process.HLT_HIUPC_SingleEG2_NotMBHF2AND_ZDC1nOR_SinglePixelTrack_MaxPixelTrack_v14, process.HLT_HIUPC_SingleEG3_BptxAND_SinglePixelTrack_MaxPixelTrack_v17, process.HLT_HIUPC_SingleEG3_NotMBHF2AND_v13, process.HLT_HIUPC_SingleEG3_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v16, process.HLT_HIUPC_SingleEG3_NotMBHF2OR_v13, process.HLT_HIUPC_SingleEG3_NotMBHF2OR_SinglePixelTrack_MaxPixelTrack_v16, process.HLT_HIUPC_SingleEG5_BptxAND_SinglePixelTrack_MaxPixelTrack_v17, process.HLT_HIUPC_SingleEG4_NotMBHF2AND_v2, process.HLT_HIUPC_SingleEG5_NotMBHF2AND_v13, process.HLT_HIUPC_SingleEG5_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v16, process.HLT_HIUPC_DoubleEG2_BptxAND_SinglePixelTrack_MaxPixelTrack_v17, process.HLT_HIUPC_DoubleEG2_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v16, process.HLT_HIUPC_DoubleEG2_NotMBHF2AND_v13, process.HLT_HIUPC_DoubleEG3_NotMBHF2AND_v1, process.HLT_HIUPC_DoubleEG3_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v2, process.HLT_HIUPC_DoubleEG5_BptxAND_SinglePixelTrack_MaxPixelTrack_v17, process.HLT_HIUPC_DoubleEG5_NotMBHF2AND_SinglePixelTrack_MaxPixelTrack_v16, process.HLT_HIUPC_DoubleEG5_NotMBHF2AND_v13, process.HLT_HIUPC_SingleJet8_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet12_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet16_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet20_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet24_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet28_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet8_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet12_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet16_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet20_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet24_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet28_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet8_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet12_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet16_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet20_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet24_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet28_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_ZeroBias_MaxPixelCluster10000_v4, process.HLT_HIUPC_ZDC1nOR_MaxPixelCluster10000_v4, process.HLT_HIUPC_ZDC1nOR_MBHF1AND_PixelTrackMultiplicity20400_v4, process.HLT_HIUPC_ZDC1nOR_MBHF1AND_PixelTrackMultiplicity30400_v4, process.HLT_HIUPC_ZDC1nOR_MBHF1AND_PixelTrackMultiplicity40400_v4, process.HLT_HIUPC_ZDC1nAND_NotMBHF2_MaxPixelCluster10000_v4, process.HLT_HIUPC_MinPixelThrust0p8_MaxPixelCluster10000_v4, process.HLT_HIUPC_SingleUncorrJet8_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet12_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet16_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet20_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet24_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet28_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet8_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet12_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet16_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet20_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet24_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet28_ZDC1nXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet8_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet12_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet16_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet20_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet24_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet28_ZDC1nAsymXOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleUncorrJet8_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleUncorrJet12_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleUncorrJet16_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleUncorrJet8_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleUncorrJet12_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleUncorrJet16_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleUncorrJet8_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleUncorrJet12_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleUncorrJet16_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, process.HLT_HIUPC_ZDC1nOR_RapGap_MaxPixelCluster10000_v4, process.HLT_HIUPC_SingleJet8_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet12_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet16_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet20_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet24_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet28_ZDC1nXOR_RapGap_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet8_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet12_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet16_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet20_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet24_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleJet28_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet8_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet12_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet16_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet20_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet24_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_SingleUncorrJet28_NotZDC_OR_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleJet8_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleJet12_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleJet16_DeltaPhi2p0_NotMBHF2AND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleJet8_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleJet12_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleJet16_DeltaPhi2p0_NotZDCAND_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleJet8_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleJet12_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_DoubleJet16_DeltaPhi2p0_NotZDC1nOR_MaxPixelCluster10000_v3, process.HLT_HIUPC_Random_HighRate_v2, process.HLT_HIUPC_HFafterglowCombined_v2, process.HLT_HIL1SingleMuOpen_Centrality30to100_v2, process.HLT_HIL1SingleMu0_Centrality30to100_v2, process.HLT_HIL1SingleMu0_Centrality40to100_v2, process.HLT_HIL1SingleMu0_v8, process.HLT_HIL1SingleMu0_Open_v8, process.HLT_HIL1SingleMu0_Cosmic_v8, process.HLT_HIL1SingleMu5_SingleEG20Gsf_v9, process.HLT_HIL1SingleMu5_SingleGEDPhoton20_v9, process.HLT_HIL1SingleMu7_SingleEG20Gsf_v9, process.HLT_HIL1SingleMu7_SingleGEDPhoton20_v3, process.HLT_HIL2DoubleMuOpen_Centrality40to100_v2, process.HLT_HIL2DoubleMuOpen_SS_v2, process.HLT_HIL2DoubleMuOpen_OS_v2, process.HLT_HIL1DoubleMu0_v8, process.HLT_HIL2DoubleMu0_SQ_v2, process.HLT_HIL1DoubleMu0_MaxDr3p5_Open_v8, process.HLT_HIL1DoubleMu0_SQ_v8, process.HLT_HIL2SingleMuOpen_Centrality30to100_v2, process.HLT_HIL2SingleMu0_Centrality30to100_v2, process.HLT_HIL2SingleMu0_Centrality40to100_v2, process.HLT_HIL2SingleMu3_Open_v8, process.HLT_HIL2SingleMu5_v8, process.HLT_HIL2SingleMu7_v8, process.HLT_HIL2SingleMu12_v2, process.HLT_HIL2DoubleMu0_Open_v8, process.HLT_HIL2DoubleMu0_M1p5to6_Open_v8, process.HLT_HIL2DoubleMu0_M7to15_Open_v8, process.HLT_HIL2DoubleMu2p8_M1p5to6_Open_v8, process.HLT_HIL2DoubleMu3_M7to15_Open_v8, process.HLT_HIDmesonPPOnAATrackingGlobal_Dpt30_v10, process.HLT_HIDmesonPPOnAATrackingGlobal_Dpt45_v10, process.HLT_HIDmesonPPOnAATrackingGlobal_Dpt60_v10, process.HLT_HICscCluster_Loose_v8, process.HLT_HICscCluster_Medium_v8, process.HLT_HICscCluster_Tight_v8, process.HLT_HIL1UnpairedBunchBptxMinusForPPRef_v10, process.HLT_HIL1UnpairedBunchBptxPlusForPPRef_v10, process.HLT_HIL1NotBptxORForPPRef_v10, process.HLT_HIHT80_Beamspot_ppRef5TeV_v19, process.HLT_PPRefZeroBias_v7, process.HLT_AK4CaloJet40_v8, process.HLT_AK4CaloJet60_v8, process.HLT_AK4CaloJet70_v8, process.HLT_AK4CaloJet80_v8, process.HLT_AK4CaloJet100_v8, process.HLT_AK4CaloJet120_v8, process.HLT_AK4CaloJetFwd40_v8, process.HLT_AK4CaloJetFwd60_v8, process.HLT_AK4CaloJetFwd70_v8, process.HLT_AK4CaloJetFwd80_v8, process.HLT_AK4CaloJetFwd100_v8, process.HLT_AK4CaloJetFwd120_v8, process.HLT_AK4PFJet40_v12, process.HLT_AK4PFJet60_v12, process.HLT_AK4PFJet80_v12, process.HLT_AK4PFJet100_v12, process.HLT_AK4PFJet120_v12, process.HLT_AK4PFJetFwd40_v12, process.HLT_AK4PFJetFwd60_v12, process.HLT_AK4PFJetFwd80_v12, process.HLT_AK4PFJetFwd100_v12, process.HLT_AK4PFJetFwd120_v12, process.HLT_PPRefDoubleEle10Gsf_v10, process.HLT_PPRefDoubleEle10GsfMass50_v10, process.HLT_PPRefDoubleEle15Gsf_v10, process.HLT_PPRefDoubleEle15GsfMass50_v10, process.HLT_PPRefEle15Ele10Gsf_v10, process.HLT_PPRefEle15Ele10GsfMass50_v10, process.HLT_PPRefEle10Gsf_v10, process.HLT_PPRefEle15Gsf_v10, process.HLT_PPRefEle20Gsf_v11, process.HLT_PPRefEle30Gsf_v11, process.HLT_PPRefEle40Gsf_v10, process.HLT_PPRefEle50Gsf_v10, process.HLT_PPRefGEDPhoton10_v8, process.HLT_PPRefGEDPhoton10_EB_v8, process.HLT_PPRefGEDPhoton20_v8, process.HLT_PPRefGEDPhoton20_EB_v8, process.HLT_PPRefGEDPhoton30_v8, process.HLT_PPRefGEDPhoton30_EB_v8, process.HLT_PPRefGEDPhoton40_v8, process.HLT_PPRefGEDPhoton40_EB_v8, process.HLT_PPRefGEDPhoton50_v8, process.HLT_PPRefGEDPhoton50_EB_v8, process.HLT_PPRefGEDPhoton60_v8, process.HLT_PPRefGEDPhoton60_EB_v8, process.HLT_PPRefDoubleGEDPhoton20_v3, process.HLT_PPRefL1DoubleMu0_v7, process.HLT_PPRefL1DoubleMu0_SQ_v2, process.HLT_PPRefL1DoubleMu0_Open_v7, process.HLT_PPRefL1DoubleMu2_v2, process.HLT_PPRefL1DoubleMu2_SQ_v2, process.HLT_PPRefL1SingleMu0_Cosmics_v7, process.HLT_PPRefL1SingleMu7_v7, process.HLT_PPRefL1SingleMu12_v7, process.HLT_PPRefL1SingleMu5_Ele20Gsf_v5, process.HLT_PPRefL1SingleMu5_GEDPhoton20_v3, process.HLT_PPRefL1SingleMu7_Ele20Gsf_v5, process.HLT_PPRefL1SingleMu7_GEDPhoton10_v3, process.HLT_PPRefL2DoubleMu0_v7, process.HLT_PPRefL2DoubleMu0_Open_v7, process.HLT_PPRefL2SingleMu7_v7, process.HLT_PPRefL2SingleMu12_v7, process.HLT_PPRefL2SingleMu15_v7, process.HLT_PPRefL2SingleMu20_v7, process.HLT_PPRefL3DoubleMu0_v12, process.HLT_PPRefL3DoubleMu0_Open_v12, process.HLT_PPRefL3SingleMu3_v12, process.HLT_PPRefL3SingleMu5_v12, process.HLT_PPRefL3SingleMu7_v12, process.HLT_PPRefL3SingleMu12_v12, process.HLT_PPRefL3SingleMu15_v12, process.HLT_PPRefL3SingleMu20_v12, process.HLT_PPRefL3SingleMu3_SingleAK4CaloJet40_v5, process.HLT_PPRefL3SingleMu3_SingleAK4CaloJet60_v5, process.HLT_PPRefL3SingleMu3_SingleAK4CaloJet80_v5, process.HLT_PPRefL3SingleMu5_SingleAK4CaloJet40_v5, process.HLT_PPRefL3SingleMu5_SingleAK4CaloJet60_v5, process.HLT_PPRefL3SingleMu5_SingleAK4CaloJet80_v5, process.HLT_PPRefCscCluster_Loose_v7, process.HLT_PPRefCscCluster_Medium_v7, process.HLT_PPRefCscCluster_Tight_v7, process.HLT_PPRefUPC_SingleJet8_ZDC1nAsymXOR_v2, process.HLT_PPRefUPC_SingleJet12_ZDC1nAsymXOR_v2, process.HLT_PPRefUPC_SingleJet16_ZDC1nAsymXOR_v2, process.HLT_PPRefUPC_SingleJet20_ZDC1nAsymXOR_v2, process.HLT_PPRefUPC_SingleJet24_ZDC1nAsymXOR_v2, process.HLT_PPRefUPC_SingleJet28_ZDC1nAsymXOR_v2, process.HLT_PPRefUPC_SingleJet8_ZDC1nOR_v2, process.HLT_PPRefUPC_SingleJet12_ZDC1nOR_v2, process.HLT_PPRefUPC_SingleJet16_ZDC1nOR_v2, process.HLT_PPRefUPC_SingleJet20_ZDC1nOR_v2, process.HLT_PPRefUPC_SingleJet24_ZDC1nOR_v2, process.HLT_PPRefUPC_SingleJet28_ZDC1nOR_v2, process.HLT_PPRefUPC_ZDC1nAsymXOR_v2, process.HLT_PPRefUPC_ZDC1nOR_v2, process.HLT_PPRefZeroBias_FirstCollisionInTrain_v1, process.HLT_TestData_v1, process.MC_ReducedIterativeTracking_v26, process.MC_AK4CaloJets_v21, process.MC_AK4CaloJetsFromPV_v21, process.MC_CaloHT_v20, process.MC_AK8CaloHT_v20, process.MC_CaloMHT_v20, process.MC_AK4PFJets_v33, process.MC_PFHT_v32, process.MC_AK8PFJets_v33, process.MC_AK8PFHT_v32, process.MC_CaloMET_v20, process.MC_CaloMET_JetIdCleaned_v21, process.MC_PFMET_v33, process.MC_PFMHT_v32, process.MC_AK4PFJetPNet_v9, process.MC_AK8PFJetPNet_v9, process.MC_Egamma_Open_v12, process.MC_Egamma_Open_Unseeded_v12, process.MC_Ele5_WPTight_Gsf_v23, process.MC_Ele15_Ele10_CaloIdL_TrackIdL_IsoVL_DZ_v29, process.MC_Diphoton10_10_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass10_v26, process.MC_DoubleEle5_CaloIdL_MW_v29, process.MC_IsoMu_v31, process.MC_DoubleMu_TrkIsoVVL_DZ_v27, process.MC_DoubleMuNoFiltersNoVtx_v20, process.MC_PFScouting_v10, process.HLT_SpecialHLTPhysics_v8, process.AlCa_LumiPixelsCounts_RandomHighRate_v6, process.AlCa_LumiPixelsCounts_ZeroBiasVdM_v6, process.AlCa_LumiPixelsCounts_ZeroBiasGated_v7, process.HLT_L1AlwaysTrue_v1, process.HLT_L1SingleMuOpen_v7, process.HLT_L1SingleMuOpen_DT_v7, process.HLT_L1SingleMu3_v6, process.HLT_L1SingleMu5_v6, process.HLT_L1SingleMu7_v6, process.HLT_L1DoubleMu0_v6, process.HLT_L1SingleJet8erHE_v6, process.HLT_L1SingleJet10erHE_v6, process.HLT_L1SingleJet12erHE_v6, process.HLT_L1SingleJet35_v6, process.HLT_L1SingleJet200_v6, process.HLT_L1SingleEG8er2p5_v5, process.HLT_L1SingleEG10er2p5_v5, process.HLT_L1SingleEG15er2p5_v5, process.HLT_L1SingleEG26er2p5_v5, process.HLT_L1SingleEG28er2p5_v5, process.HLT_L1SingleEG28er2p1_v5, process.HLT_L1SingleEG28er1p5_v5, process.HLT_L1SingleEG34er2p5_v5, process.HLT_L1SingleEG36er2p5_v5, process.HLT_L1SingleEG38er2p5_v5, process.HLT_L1SingleEG40er2p5_v5, process.HLT_L1SingleEG42er2p5_v5, process.HLT_L1SingleEG45er2p5_v5, process.HLT_L1SingleEG50_v5, process.HLT_L1SingleJet60_v5, process.HLT_L1SingleJet90_v5, process.HLT_L1SingleJet120_v5, process.HLT_L1SingleJet180_v5, process.HLT_L1HTT120er_v5, process.HLT_L1HTT160er_v5, process.HLT_L1HTT200er_v5, process.HLT_L1HTT255er_v5, process.HLT_L1HTT280er_v5, process.HLT_L1HTT320er_v5, process.HLT_L1HTT360er_v5, process.HLT_L1HTT400er_v5, process.HLT_L1HTT450er_v5, process.HLT_L1ETM120_v5, process.HLT_L1ETM150_v5, process.HLT_L1EXT_HCAL_LaserMon1_v6, process.HLT_L1EXT_HCAL_LaserMon4_v6, process.HLT_L1MinimumBiasHF0ANDBptxAND_v1, process.HLT_L1AXOVVTight_v1, process.HLT_L1AXOVVVTight_v1, process.HLT_L1CICADA_VVTight_v1, process.HLT_L1CICADA_VVVTight_v1, process.HLT_L1CICADA_VVVVTight_v1, process.HLT_CscCluster_Cosmic_v5, process.HLT_HT60_Beamspot_v26, process.HLT_Beamspot_PixelClusters_WP2_v10, process.HLT_PixelClusters_WP2_v5, process.HLT_PixelClusters_WP2_HighRate_v1, process.HLT_PixelClusters_WP1_v5, process.HLT_BptxOR_v7, process.HLT_L1SingleMuCosmics_EMTF_v5, process.HLT_L1SingleMuCosmics_CosmicTracking_v2, process.HLT_L1SingleMuCosmics_PointingCosmicTracking_v2, process.HLT_L1FatEvents_v6, process.HLT_Random_HighRate_v1, process.HLT_ZeroBias_HighRate_v5, process.HLT_ZeroBias_Gated_v6, process.HLT_SpecialZeroBias_v7, process.HLT_HIHT80_Beamspot_Oxy5TeV_v3, process.HLT_MinimumBiasHF_AND_BptxAND_v1, process.HLT_MinimumBiasHF_OR_BptxAND_v1, process.HLT_MinimumBiasZDC1n_OR_BptxAND_v1, process.HLT_MinimumBiasZDC1n_OR_MinimumBiasHF_AND_BptxAND_v1, process.HLT_MinimumBiasZDC1n_OR_MinimumBiasHF_OR_BptxAND_v1, process.HLT_MinimumBiasZDC1n_OR_OR_MinimumBiasHF_OR_BptxAND_v1, process.HLT_MinimumBiasZDC_Asym_MinimumBiasHF_OR_BptxAND_v1, process.HLT_OxyDoubleEG2_NotMBHF2AND_v1, process.HLT_OxyDoubleEG5_NotMBHF2AND_v1, process.HLT_OxyL1CentralityGate_v1, process.HLT_OxyL1DoubleMu0_v1, process.HLT_OxyL1DoubleMuOpen_v1, process.HLT_OxyL1SingleEG10_v1, process.HLT_OxyL1SingleEG15_v1, process.HLT_OxyL1SingleEG15er2p1_v1, process.HLT_OxyL1SingleEG15er2p5_v1, process.HLT_OxyL1SingleEG21_v1, process.HLT_OxyL1SingleJet20_v1, process.HLT_OxyL1SingleJet28_v1, process.HLT_OxyL1SingleJet35_v1, process.HLT_OxyL1SingleJet44_v1, process.HLT_OxyL1SingleJet60_v1, process.HLT_OxyL1SingleMu0_v1, process.HLT_OxyL1SingleMu3_v1, process.HLT_OxyL1SingleMu5_v1, process.HLT_OxyL1SingleMu7_v1, process.HLT_OxyL1SingleMuOpen_v1, process.HLT_OxyNotMBHF2_v1, process.HLT_OxySingleEG2_NotMBHF2AND_ZDC1nOR_v1, process.HLT_OxySingleEG3_NotMBHF2AND_v1, process.HLT_OxySingleEG3_NotMBHF2OR_v1, process.HLT_OxySingleEG5_NotMBHF2AND_v1, process.HLT_OxySingleJet16_ZDC1nAsymXOR_NotPreBptx_v1, process.HLT_OxySingleJet16_ZDC1nAsymXOR_v1, process.HLT_OxySingleJet16_ZDC1nXOR_v1, process.HLT_OxySingleJet24_ZDC1nAsymXOR_NotPreBptx_v1, process.HLT_OxySingleJet24_ZDC1nAsymXOR_v1, process.HLT_OxySingleJet24_ZDC1nXOR_v1, process.HLT_OxySingleJet8_ZDC1nAsymXOR_NotPreBptx_v1, process.HLT_OxySingleJet8_ZDC1nAsymXOR_v1, process.HLT_OxySingleJet8_ZDC1nXOR_v1, process.HLT_OxySingleMuCosmic_NotMBHF2AND_v1, process.HLT_OxySingleMuOpen_NotMBHF2AND_v1, process.HLT_OxySingleMuOpen_NotMBHF2OR_v1, process.HLT_OxySingleMuOpen_OR_SingleMuCosmic_EMTF_BptxAND_v1, process.HLT_OxySingleMuOpen_OR_SingleMuCosmic_EMTF_NotMBHF2AND_v1, process.HLT_OxyZDC1nOR_v1, process.HLT_OxyZeroBias_v1, process.HLT_OxyZeroBias_SinglePixelTrackLowPt_MaxPixelCluster400_v1, process.HLT_OxyZeroBias_MinPixelCluster400_v1, process.HLTriggerFinalPath, process.HLTAnalyzerEndpath, process.DQMHistograms, process.RatesMonitoring, process.Dataset_AlCaHcalIsoTrk, process.Dataset_AlCaLowPtJet, process.Dataset_AlCaLumiPixelsCountsExpress, process.Dataset_AlCaLumiPixelsCountsPrompt, process.Dataset_AlCaLumiPixelsCountsPromptHighRate0, process.Dataset_AlCaLumiPixelsCountsPromptHighRate1, process.Dataset_AlCaLumiPixelsCountsPromptHighRate2, process.Dataset_AlCaLumiPixelsCountsPromptHighRate3, process.Dataset_AlCaLumiPixelsCountsPromptHighRate4, process.Dataset_AlCaLumiPixelsCountsPromptHighRate5, process.Dataset_AlCaLumiPixelsCountsGated, process.Dataset_AlCaP0, process.Dataset_AlCaPPSExpress, process.Dataset_AlCaPPSPrompt, process.Dataset_AlCaPhiSym, process.Dataset_BTagMu, process.Dataset_Commissioning, process.Dataset_Cosmics, process.Dataset_DQMGPUvsCPU, process.Dataset_DQMOnlineBeamspot, process.Dataset_DQMPPSRandom, process.Dataset_EGamma0, process.Dataset_EGamma1, process.Dataset_EGamma2, process.Dataset_EGamma3, process.Dataset_EcalLaser, process.Dataset_EmptyBX, process.Dataset_EphemeralHLTPhysics0, process.Dataset_EphemeralHLTPhysics1, process.Dataset_EphemeralHLTPhysics2, process.Dataset_EphemeralHLTPhysics3, process.Dataset_EphemeralHLTPhysics4, process.Dataset_EphemeralHLTPhysics5, process.Dataset_EphemeralHLTPhysics6, process.Dataset_EphemeralHLTPhysics7, process.Dataset_EphemeralZeroBias0, process.Dataset_EphemeralZeroBias1, process.Dataset_EphemeralZeroBias2, process.Dataset_EphemeralZeroBias3, process.Dataset_EphemeralZeroBias4, process.Dataset_EphemeralZeroBias5, process.Dataset_EphemeralZeroBias6, process.Dataset_EphemeralZeroBias7, process.Dataset_EventDisplay, process.Dataset_ExpressAlignment, process.Dataset_ExpressCosmics, process.Dataset_ExpressPhysics, process.Dataset_HIDQMGPUvsCPU, process.Dataset_HIDQMOnlineBeamspot, process.Dataset_HIEmptyBX, process.Dataset_HIEphemeralHLTPhysics, process.Dataset_HIEphemeralZeroBias0, process.Dataset_HIEphemeralZeroBias1, process.Dataset_HIEventDisplay, process.Dataset_HIExpressAlignment, process.Dataset_HIExpressPhysics, process.Dataset_HIExpressPhysicsRawPrime, process.Dataset_HIForward0, process.Dataset_HIForward1, process.Dataset_HIForward2, process.Dataset_HIForward3, process.Dataset_HIForward4, process.Dataset_HIForward5, process.Dataset_HIForward6, process.Dataset_HIForward7, process.Dataset_HIForward8, process.Dataset_HIForward9, process.Dataset_HIForward10, process.Dataset_HIForward11, process.Dataset_HIForward12, process.Dataset_HIForward13, process.Dataset_HIForward14, process.Dataset_HIForward15, process.Dataset_HIForward16, process.Dataset_HIForward17, process.Dataset_HIForward18, process.Dataset_HIForward19, process.Dataset_HIHLTPhysics, process.Dataset_HIHcalNZS, process.Dataset_HIOnlineMonitor, process.Dataset_HIMinimumBias0, process.Dataset_HIMinimumBias1, process.Dataset_HIMinimumBias2, process.Dataset_HIMinimumBias3, process.Dataset_HIPhysicsRawPrime0, process.Dataset_HITrackerNZS, process.Dataset_HIZeroBias0, process.Dataset_HIZeroBias1, process.Dataset_HIZeroBias2, process.Dataset_HLTMonitor, process.Dataset_HLTPhysics, process.Dataset_HcalNZS, process.Dataset_JetMET0, process.Dataset_JetMET1, process.Dataset_L1Accept, process.Dataset_MinimumBias, process.Dataset_MonteCarlo, process.Dataset_Muon0, process.Dataset_Muon1, process.Dataset_MuonEG, process.Dataset_MuonShower, process.Dataset_NoBPTX, process.Dataset_OnlineMonitor, process.Dataset_PPRefDoubleMuon0, process.Dataset_PPRefDoubleMuon1, process.Dataset_PPRefDoubleMuon2, process.Dataset_PPRefDoubleMuon3, process.Dataset_PPRefHardProbes0, process.Dataset_PPRefSingleMuon0, process.Dataset_PPRefZeroBiasPlusForward0, process.Dataset_ParkingDoubleMuonLowMass0, process.Dataset_ParkingDoubleMuonLowMass1, process.Dataset_ParkingDoubleMuonLowMass2, process.Dataset_ParkingDoubleMuonLowMass3, process.Dataset_ParkingDoubleMuonLowMass4, process.Dataset_ParkingDoubleMuonLowMass5, process.Dataset_ParkingDoubleMuonLowMass6, process.Dataset_ParkingDoubleMuonLowMass7, process.Dataset_ParkingHH0, process.Dataset_ParkingHH1, process.Dataset_ParkingLLP0, process.Dataset_ParkingLLP1, process.Dataset_ParkingSingleMuon0, process.Dataset_ParkingSingleMuon1, process.Dataset_ParkingSingleMuon2, process.Dataset_ParkingSingleMuon3, process.Dataset_ParkingSingleMuon4, process.Dataset_ParkingSingleMuon5, process.Dataset_ParkingSingleMuon6, process.Dataset_ParkingSingleMuon7, process.Dataset_ParkingSingleMuon8, process.Dataset_ParkingSingleMuon9, process.Dataset_ParkingSingleMuon10, process.Dataset_ParkingSingleMuon11, process.Dataset_ParkingSingleMuon12, process.Dataset_ParkingSingleMuon13, process.Dataset_ParkingSingleMuon14, process.Dataset_ParkingSingleMuon15, process.Dataset_ParkingVBF0, process.Dataset_ParkingVBF1, process.Dataset_ParkingVBF2, process.Dataset_ParkingVBF3, process.Dataset_ParkingVBF4, process.Dataset_ParkingVBF5, process.Dataset_ParkingVBF6, process.Dataset_ParkingVBF7, process.Dataset_ParkingAnomalyDetection, process.Dataset_RPCMonitor, process.Dataset_ScoutingPFMonitor, process.Dataset_ScoutingPF0, process.Dataset_ScoutingPF1, process.Dataset_Tau, process.Dataset_TestEnablesEcalHcal, process.Dataset_TestEnablesEcalHcalDQM, process.Dataset_VRRandom0, process.Dataset_VRRandom1, process.Dataset_VRRandom2, process.Dataset_VRRandom3, process.Dataset_VRRandom4, process.Dataset_VRRandom5, process.Dataset_VRRandom6, process.Dataset_VRRandom7, process.Dataset_VRRandom8, process.Dataset_VRRandom9, process.Dataset_VRRandom10, process.Dataset_VRRandom11, process.Dataset_VRRandom12, process.Dataset_VRRandom13, process.Dataset_VRRandom14, process.Dataset_VRRandom15, process.Dataset_ZeroBias, process.Dataset_SpecialRandom0, process.Dataset_SpecialRandom1, process.Dataset_SpecialRandom2, process.Dataset_SpecialRandom3, process.Dataset_SpecialRandom4, process.Dataset_SpecialRandom5, process.Dataset_SpecialRandom6, process.Dataset_SpecialRandom7, process.Dataset_SpecialRandom8, process.Dataset_SpecialRandom9, process.Dataset_SpecialRandom10, process.Dataset_SpecialRandom11, process.Dataset_SpecialRandom12, process.Dataset_SpecialRandom13, process.Dataset_SpecialRandom14, process.Dataset_SpecialRandom15, process.Dataset_SpecialRandom16, process.Dataset_SpecialRandom17, process.Dataset_SpecialRandom18, process.Dataset_SpecialRandom19, process.Dataset_SpecialZeroBias0, process.Dataset_SpecialZeroBias1, process.Dataset_SpecialZeroBias2, process.Dataset_SpecialZeroBias3, process.Dataset_SpecialZeroBias4, process.Dataset_SpecialZeroBias5, process.Dataset_SpecialZeroBias6, process.Dataset_SpecialZeroBias7, process.Dataset_SpecialZeroBias8, process.Dataset_SpecialZeroBias9, process.Dataset_SpecialZeroBias10, process.Dataset_SpecialZeroBias11, process.Dataset_SpecialZeroBias12, process.Dataset_SpecialZeroBias13, process.Dataset_SpecialZeroBias14, process.Dataset_SpecialZeroBias15, process.Dataset_SpecialZeroBias16, process.Dataset_SpecialZeroBias17, process.Dataset_SpecialZeroBias18, process.Dataset_SpecialZeroBias19, process.Dataset_SpecialZeroBias20, process.Dataset_SpecialZeroBias21, process.Dataset_SpecialZeroBias22, process.Dataset_SpecialZeroBias23, process.Dataset_SpecialZeroBias24, process.Dataset_SpecialZeroBias25, process.Dataset_SpecialZeroBias26, process.Dataset_SpecialZeroBias27, process.Dataset_SpecialZeroBias28, process.Dataset_SpecialZeroBias29, process.Dataset_SpecialZeroBias30, process.Dataset_SpecialZeroBias31, process.Dataset_SpecialHLTPhysics0, process.Dataset_SpecialHLTPhysics1, process.Dataset_SpecialHLTPhysics2, process.Dataset_SpecialHLTPhysics3, process.Dataset_SpecialHLTPhysics4, process.Dataset_SpecialHLTPhysics5, process.Dataset_SpecialHLTPhysics6, process.Dataset_SpecialHLTPhysics7, process.Dataset_SpecialHLTPhysics8, process.Dataset_SpecialHLTPhysics9, process.Dataset_SpecialHLTPhysics10, process.Dataset_SpecialHLTPhysics11, process.Dataset_SpecialHLTPhysics12, process.Dataset_SpecialHLTPhysics13, process.Dataset_SpecialHLTPhysics14, process.Dataset_SpecialHLTPhysics15, process.Dataset_SpecialHLTPhysics16, process.Dataset_SpecialHLTPhysics17, process.Dataset_SpecialHLTPhysics18, process.Dataset_SpecialHLTPhysics19, process.Dataset_PPRefZeroBiasPlusForward1, process.Dataset_PPRefZeroBiasPlusForward2, process.Dataset_PPRefZeroBiasPlusForward3, process.Dataset_PPRefZeroBiasPlusForward4, process.Dataset_PPRefZeroBiasPlusForward5, process.Dataset_PPRefZeroBiasPlusForward6, process.Dataset_PPRefZeroBiasPlusForward7, process.Dataset_PPRefZeroBiasPlusForward8, process.Dataset_PPRefZeroBiasPlusForward9, process.Dataset_PPRefZeroBiasPlusForward10, process.Dataset_PPRefZeroBiasPlusForward11, process.Dataset_PPRefZeroBiasPlusForward12, process.Dataset_PPRefZeroBiasPlusForward13, process.Dataset_PPRefZeroBiasPlusForward14, process.Dataset_PPRefZeroBiasPlusForward15, process.Dataset_PPRefZeroBiasPlusForward16, process.Dataset_PPRefZeroBiasPlusForward17, process.Dataset_PPRefZeroBiasPlusForward18, process.Dataset_PPRefZeroBiasPlusForward19, process.Dataset_PPRefZeroBiasPlusForward20, process.Dataset_PPRefZeroBiasPlusForward21, process.Dataset_PPRefZeroBiasPlusForward22, process.Dataset_PPRefZeroBiasPlusForward23, process.Dataset_PPRefZeroBiasPlusForward24, process.Dataset_PPRefSingleMuon1, process.Dataset_PPRefSingleMuon2, process.Dataset_PPRefSingleMuon3, process.Dataset_PPRefHardProbes1, process.Dataset_PPRefHardProbes2, process.Dataset_PPRefHardProbes3, process.Dataset_PPRefHardProbes4, process.Dataset_SpecialMinimumBias0, process.Dataset_SpecialMinimumBias1, process.Dataset_SpecialMinimumBias2, process.Dataset_SpecialMinimumBias3, process.Dataset_HIPhysicsRawPrime1, process.Dataset_HIPhysicsRawPrime2, process.Dataset_HIPhysicsRawPrime3, process.Dataset_HIPhysicsRawPrime4, process.Dataset_HIPhysicsRawPrime5, process.Dataset_HIPhysicsRawPrime6, process.Dataset_HIPhysicsRawPrime7, process.Dataset_HIPhysicsRawPrime8, process.Dataset_HIPhysicsRawPrime9, process.Dataset_HIPhysicsRawPrime10, process.Dataset_HIPhysicsRawPrime11, process.Dataset_HIPhysicsRawPrime12, process.Dataset_HIPhysicsRawPrime13, process.Dataset_HIPhysicsRawPrime14, process.Dataset_HIPhysicsRawPrime15, process.Dataset_HIPhysicsRawPrime16, process.Dataset_HIPhysicsRawPrime17, process.Dataset_HIPhysicsRawPrime18, process.Dataset_HIPhysicsRawPrime19, process.Dataset_HIPhysicsRawPrime20, process.Dataset_HIPhysicsRawPrime21, process.Dataset_HIPhysicsRawPrime22, process.Dataset_HIPhysicsRawPrime23, process.Dataset_HIPhysicsRawPrime24, process.Dataset_HIPhysicsRawPrime25, process.Dataset_HIPhysicsRawPrime26, process.Dataset_HIPhysicsRawPrime27, process.Dataset_HIPhysicsRawPrime28, process.Dataset_HIPhysicsRawPrime29, process.Dataset_HIPhysicsRawPrime30, process.Dataset_HIPhysicsRawPrime31, process.Dataset_HIPhysicsRawPrime32, process.Dataset_HIPhysicsRawPrime33, process.Dataset_HIPhysicsRawPrime34, process.Dataset_HIPhysicsRawPrime35, process.Dataset_HIPhysicsRawPrime36, process.Dataset_HIPhysicsRawPrime37, process.Dataset_HIPhysicsRawPrime38, process.Dataset_HIPhysicsRawPrime39, process.Dataset_HIPhysicsRawPrime40, process.Dataset_HIPhysicsRawPrime41, process.Dataset_HIPhysicsRawPrime42, process.Dataset_HIPhysicsRawPrime43, process.Dataset_HIPhysicsRawPrime44, process.Dataset_HIPhysicsRawPrime45, process.Dataset_HIPhysicsRawPrime46, process.Dataset_HIPhysicsRawPrime47, process.Dataset_HIPhysicsRawPrime48, process.Dataset_HIPhysicsRawPrime49, process.Dataset_HIPhysicsRawPrime50, process.Dataset_HIPhysicsRawPrime51, process.Dataset_HIPhysicsRawPrime52, process.Dataset_HIPhysicsRawPrime53, process.Dataset_HIPhysicsRawPrime54, process.Dataset_HIPhysicsRawPrime55, process.Dataset_HIPhysicsRawPrime56, process.Dataset_HIPhysicsRawPrime57, process.Dataset_HIPhysicsRawPrime58, process.Dataset_HIPhysicsRawPrime59, process.Dataset_CosmicHLTMonitor, process.Dataset_TestDataRaw, process.Dataset_TestDataScouting, process.Dataset_EmittanceScan0, process.Dataset_EmittanceScan1, process.Dataset_EmittanceScan2, process.Dataset_EmittanceScan3, process.Dataset_EmittanceScan4, process.Dataset_EmittanceScan5, process.Dataset_IonPhysics, process.Dataset_DQMOnlineScouting, process.ALCAHcalIsoTrkOutput, process.ALCALowPtJetOutput, process.ALCALumiPixelsCountsExpressOutput, process.ALCALumiPixelsCountsGatedOutput, process.ALCALumiPixelsCountsPromptOutput, process.ALCALumiPixelsCountsPromptHighRate0Output, process.ALCALumiPixelsCountsPromptHighRate1Output, process.ALCALumiPixelsCountsPromptHighRate2Output, process.ALCALumiPixelsCountsPromptHighRate3Output, process.ALCALumiPixelsCountsPromptHighRate4Output, process.ALCALumiPixelsCountsPromptHighRate5Output, process.ALCAP0Output, process.ALCAPHISYMOutput, process.ALCAPPSExpressOutput, process.ALCAPPSPromptOutput, process.CalibrationOutput, process.DQMOutput, process.DQMCalibrationOutput, process.DQMEventDisplayOutput, process.DQMGPUvsCPUOutput, process.DQMOnlineBeamspotOutput, process.DQMOnlineScoutingOutput, process.DQMPPSRandomOutput, process.EcalCalibrationOutput, process.ExpressOutput, process.ExpressAlignmentOutput, process.ExpressCosmicsOutput, process.HIDQMOutput, process.HIDQMEventDisplayOutput, process.HIDQMGPUvsCPUOutput, process.HIDQMOnlineBeamspotOutput, process.HIExpressOutput, process.HIExpressAlignmentOutput, process.HIExpressRawPrimeOutput, process.HLTMonitorOutput, process.NanoDSTOutput, process.ParkingDoubleMuonLowMass0Output, process.ParkingDoubleMuonLowMass1Output, process.ParkingDoubleMuonLowMass2Output, process.ParkingDoubleMuonLowMass3Output, process.ParkingHHOutput, process.ParkingLLPOutput, process.ParkingSingleMuon0Output, process.ParkingSingleMuon1Output, process.ParkingSingleMuon10Output, process.ParkingSingleMuon11Output, process.ParkingSingleMuon12Output, process.ParkingSingleMuon13Output, process.ParkingSingleMuon14Output, process.ParkingSingleMuon15Output, process.ParkingSingleMuon2Output, process.ParkingSingleMuon3Output, process.ParkingSingleMuon4Output, process.ParkingSingleMuon5Output, process.ParkingSingleMuon6Output, process.ParkingSingleMuon7Output, process.ParkingSingleMuon8Output, process.ParkingSingleMuon9Output, process.ParkingVBF0Output, process.ParkingVBF1Output, process.ParkingVBF2Output, process.ParkingVBF3Output, process.ParkingAnomalyDetectionOutput, process.PhysicsCommissioningOutput, process.PhysicsBTagMuEGTauOutput, process.PhysicsEGamma0Output, process.PhysicsEGamma1Output, process.PhysicsEGamma2Output, process.PhysicsEGamma3Output, process.PhysicsHICommissioningOutput, process.PhysicsHIForward0Output, process.PhysicsHIForward1Output, process.PhysicsHIForward10Output, process.PhysicsHIForward11Output, process.PhysicsHIForward12Output, process.PhysicsHIForward13Output, process.PhysicsHIForward14Output, process.PhysicsHIForward15Output, process.PhysicsHIForward16Output, process.PhysicsHIForward17Output, process.PhysicsHIForward18Output, process.PhysicsHIForward19Output, process.PhysicsHIForward2Output, process.PhysicsHIForward3Output, process.PhysicsHIForward4Output, process.PhysicsHIForward5Output, process.PhysicsHIForward6Output, process.PhysicsHIForward7Output, process.PhysicsHIForward8Output, process.PhysicsHIForward9Output, process.PhysicsHIHLTPhysicsOutput, process.PhysicsHIMinimumBias0Output, process.PhysicsHIMinimumBias1Output, process.PhysicsHIMinimumBias2Output, process.PhysicsHIMinimumBias3Output, process.PhysicsHIPhysicsRawPrime0Output, process.PhysicsHIPhysicsRawPrime1Output, process.PhysicsHIPhysicsRawPrime10Output, process.PhysicsHIPhysicsRawPrime11Output, process.PhysicsHIPhysicsRawPrime12Output, process.PhysicsHIPhysicsRawPrime13Output, process.PhysicsHIPhysicsRawPrime14Output, process.PhysicsHIPhysicsRawPrime15Output, process.PhysicsHIPhysicsRawPrime16Output, process.PhysicsHIPhysicsRawPrime17Output, process.PhysicsHIPhysicsRawPrime18Output, process.PhysicsHIPhysicsRawPrime19Output, process.PhysicsHIPhysicsRawPrime2Output, process.PhysicsHIPhysicsRawPrime20Output, process.PhysicsHIPhysicsRawPrime21Output, process.PhysicsHIPhysicsRawPrime22Output, process.PhysicsHIPhysicsRawPrime23Output, process.PhysicsHIPhysicsRawPrime24Output, process.PhysicsHIPhysicsRawPrime25Output, process.PhysicsHIPhysicsRawPrime26Output, process.PhysicsHIPhysicsRawPrime27Output, process.PhysicsHIPhysicsRawPrime28Output, process.PhysicsHIPhysicsRawPrime29Output, process.PhysicsHIPhysicsRawPrime3Output, process.PhysicsHIPhysicsRawPrime30Output, process.PhysicsHIPhysicsRawPrime31Output, process.PhysicsHIPhysicsRawPrime32Output, process.PhysicsHIPhysicsRawPrime33Output, process.PhysicsHIPhysicsRawPrime34Output, process.PhysicsHIPhysicsRawPrime35Output, process.PhysicsHIPhysicsRawPrime36Output, process.PhysicsHIPhysicsRawPrime37Output, process.PhysicsHIPhysicsRawPrime38Output, process.PhysicsHIPhysicsRawPrime39Output, process.PhysicsHIPhysicsRawPrime4Output, process.PhysicsHIPhysicsRawPrime40Output, process.PhysicsHIPhysicsRawPrime41Output, process.PhysicsHIPhysicsRawPrime42Output, process.PhysicsHIPhysicsRawPrime43Output, process.PhysicsHIPhysicsRawPrime44Output, process.PhysicsHIPhysicsRawPrime45Output, process.PhysicsHIPhysicsRawPrime46Output, process.PhysicsHIPhysicsRawPrime47Output, process.PhysicsHIPhysicsRawPrime48Output, process.PhysicsHIPhysicsRawPrime49Output, process.PhysicsHIPhysicsRawPrime5Output, process.PhysicsHIPhysicsRawPrime50Output, process.PhysicsHIPhysicsRawPrime51Output, process.PhysicsHIPhysicsRawPrime52Output, process.PhysicsHIPhysicsRawPrime53Output, process.PhysicsHIPhysicsRawPrime54Output, process.PhysicsHIPhysicsRawPrime55Output, process.PhysicsHIPhysicsRawPrime56Output, process.PhysicsHIPhysicsRawPrime57Output, process.PhysicsHIPhysicsRawPrime58Output, process.PhysicsHIPhysicsRawPrime59Output, process.PhysicsHIPhysicsRawPrime6Output, process.PhysicsHIPhysicsRawPrime7Output, process.PhysicsHIPhysicsRawPrime8Output, process.PhysicsHIPhysicsRawPrime9Output, process.PhysicsHITrackerNZSOutput, process.PhysicsHIZeroBiasOutput, process.PhysicsHIZeroBiasRAW0Output, process.PhysicsHIZeroBiasRAW1Output, process.PhysicsHIZeroBiasRAW2Output, process.PhysicsHLTPhysics0Output, process.PhysicsHLTPhysics1Output, process.PhysicsHLTPhysics2Output, process.PhysicsHLTPhysics3Output, process.PhysicsJetMET0Output, process.PhysicsJetMET1Output, process.PhysicsMuon0Output, process.PhysicsMuon1Output, process.PhysicsPPRefDoubleMuon0Output, process.PhysicsPPRefDoubleMuon1Output, process.PhysicsPPRefDoubleMuon2Output, process.PhysicsPPRefDoubleMuon3Output, process.PhysicsPPRefHardProbes0Output, process.PhysicsPPRefHardProbes1Output, process.PhysicsPPRefHardProbes2Output, process.PhysicsPPRefHardProbes3Output, process.PhysicsPPRefHardProbes4Output, process.PhysicsPPRefSingleMuon0Output, process.PhysicsPPRefSingleMuon1Output, process.PhysicsPPRefSingleMuon2Output, process.PhysicsPPRefSingleMuon3Output, process.PhysicsPPRefZeroBiasPlusForward0Output, process.PhysicsPPRefZeroBiasPlusForward1Output, process.PhysicsPPRefZeroBiasPlusForward10Output, process.PhysicsPPRefZeroBiasPlusForward11Output, process.PhysicsPPRefZeroBiasPlusForward12Output, process.PhysicsPPRefZeroBiasPlusForward13Output, process.PhysicsPPRefZeroBiasPlusForward14Output, process.PhysicsPPRefZeroBiasPlusForward15Output, process.PhysicsPPRefZeroBiasPlusForward16Output, process.PhysicsPPRefZeroBiasPlusForward17Output, process.PhysicsPPRefZeroBiasPlusForward18Output, process.PhysicsPPRefZeroBiasPlusForward19Output, process.PhysicsPPRefZeroBiasPlusForward2Output, process.PhysicsPPRefZeroBiasPlusForward20Output, process.PhysicsPPRefZeroBiasPlusForward21Output, process.PhysicsPPRefZeroBiasPlusForward22Output, process.PhysicsPPRefZeroBiasPlusForward23Output, process.PhysicsPPRefZeroBiasPlusForward24Output, process.PhysicsPPRefZeroBiasPlusForward3Output, process.PhysicsPPRefZeroBiasPlusForward4Output, process.PhysicsPPRefZeroBiasPlusForward5Output, process.PhysicsPPRefZeroBiasPlusForward6Output, process.PhysicsPPRefZeroBiasPlusForward7Output, process.PhysicsPPRefZeroBiasPlusForward8Output, process.PhysicsPPRefZeroBiasPlusForward9Output, process.PhysicsScoutingPFMonitorOutput, process.PhysicsSpecialHLTPhysics0Output, process.PhysicsSpecialHLTPhysics1Output, process.PhysicsSpecialHLTPhysics10Output, process.PhysicsSpecialHLTPhysics11Output, process.PhysicsSpecialHLTPhysics12Output, process.PhysicsSpecialHLTPhysics13Output, process.PhysicsSpecialHLTPhysics14Output, process.PhysicsSpecialHLTPhysics15Output, process.PhysicsSpecialHLTPhysics16Output, process.PhysicsSpecialHLTPhysics17Output, process.PhysicsSpecialHLTPhysics18Output, process.PhysicsSpecialHLTPhysics19Output, process.PhysicsSpecialHLTPhysics2Output, process.PhysicsSpecialHLTPhysics3Output, process.PhysicsSpecialHLTPhysics4Output, process.PhysicsSpecialHLTPhysics5Output, process.PhysicsSpecialHLTPhysics6Output, process.PhysicsSpecialHLTPhysics7Output, process.PhysicsSpecialHLTPhysics8Output, process.PhysicsSpecialHLTPhysics9Output, process.PhysicsSpecialMinimumBias0Output, process.PhysicsSpecialMinimumBias1Output, process.PhysicsSpecialMinimumBias2Output, process.PhysicsSpecialMinimumBias3Output, process.PhysicsSpecialRandom0Output, process.PhysicsSpecialRandom1Output, process.PhysicsSpecialRandom2Output, process.PhysicsSpecialRandom3Output, process.PhysicsSpecialRandom4Output, process.PhysicsSpecialRandom5Output, process.PhysicsSpecialRandom6Output, process.PhysicsSpecialRandom7Output, process.PhysicsSpecialRandom8Output, process.PhysicsSpecialRandom9Output, process.PhysicsSpecialZeroBias0Output, process.PhysicsSpecialZeroBias1Output, process.PhysicsSpecialZeroBias2Output, process.PhysicsSpecialZeroBias3Output, process.PhysicsSpecialZeroBias4Output, process.PhysicsSpecialZeroBias5Output, process.PhysicsSpecialZeroBias6Output, process.PhysicsSpecialZeroBias7Output, process.PhysicsSpecialZeroBias8Output, process.PhysicsSpecialZeroBias10Output, process.PhysicsSpecialZeroBias11Output, process.PhysicsSpecialZeroBias12Output, process.PhysicsSpecialZeroBias13Output, process.PhysicsSpecialZeroBias14Output, process.PhysicsSpecialZeroBias15Output, process.PhysicsSpecialZeroBias16Output, process.PhysicsSpecialZeroBias17Output, process.PhysicsSpecialZeroBias18Output, process.PhysicsSpecialZeroBias19Output, process.PhysicsSpecialZeroBias9Output, process.PhysicsSpecialZeroBias20Output, process.PhysicsSpecialZeroBias21Output, process.PhysicsSpecialZeroBias22Output, process.PhysicsSpecialZeroBias23Output, process.PhysicsSpecialZeroBias24Output, process.PhysicsSpecialZeroBias25Output, process.PhysicsSpecialZeroBias26Output, process.PhysicsSpecialZeroBias27Output, process.PhysicsSpecialZeroBias28Output, process.PhysicsSpecialZeroBias29Output, process.PhysicsSpecialZeroBias30Output, process.PhysicsSpecialZeroBias31Output, process.PhysicsVRRandom0Output, process.PhysicsVRRandom1Output, process.PhysicsVRRandom2Output, process.PhysicsVRRandom3Output, process.PhysicsVRRandom4Output, process.PhysicsVRRandom5Output, process.PhysicsVRRandom6Output, process.PhysicsVRRandom7Output, process.PhysicsZeroBias0Output, process.PhysicsZeroBias1Output, process.PhysicsZeroBias2Output, process.PhysicsZeroBias3Output, process.PhysicsEmittanceScan0Output, process.PhysicsEmittanceScan1Output, process.PhysicsEmittanceScan2Output, process.PhysicsIonPhysicsOutput, process.RPCMONOutput, process.ScoutingPF0Output, process.ScoutingPF1Output, process.CosmicHLTMonitorOutput, process.LocalTestDataRawOutput, process.LocalTestDataScoutingOutput, )) # source module (EDM inputs) diff --git a/HLTrigger/Configuration/test/OnLine_HLT_Fake.py b/HLTrigger/Configuration/test/OnLine_HLT_Fake.py index d912798d39372..e411ad86708f3 100644 --- a/HLTrigger/Configuration/test/OnLine_HLT_Fake.py +++ b/HLTrigger/Configuration/test/OnLine_HLT_Fake.py @@ -1,13 +1,13 @@ -# hltGetConfiguration /dev/CMSSW_15_0_0/Fake --full --data --type Fake --unprescale --process HLTFake --globaltag auto:run1_hlt_Fake --input file:RelVal_Raw_Fake_DATA.root +# hltGetConfiguration /dev/CMSSW_15_1_0/Fake --full --data --type Fake --unprescale --process HLTFake --globaltag auto:run1_hlt_Fake --input file:RelVal_Raw_Fake_DATA.root -# /dev/CMSSW_15_0_0/Fake/V11 (CMSSW_15_0_11) +# /dev/CMSSW_15_1_0/Fake/V9 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTFake" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string("/dev/CMSSW_15_0_0/Fake/V11") + tableName = cms.string("/dev/CMSSW_15_1_0/Fake/V9") ) process.streams = cms.PSet( A = cms.vstring( 'InitialPD' ) ) diff --git a/HLTrigger/Configuration/test/OnLine_HLT_Fake1.py b/HLTrigger/Configuration/test/OnLine_HLT_Fake1.py index d25e8f7e34007..dd2ad0d2b79f0 100644 --- a/HLTrigger/Configuration/test/OnLine_HLT_Fake1.py +++ b/HLTrigger/Configuration/test/OnLine_HLT_Fake1.py @@ -1,13 +1,13 @@ -# hltGetConfiguration /dev/CMSSW_15_0_0/Fake1 --full --data --type Fake1 --unprescale --process HLTFake1 --globaltag auto:run2_hlt_Fake1 --input file:RelVal_Raw_Fake1_DATA.root +# hltGetConfiguration /dev/CMSSW_15_1_0/Fake1 --full --data --type Fake1 --unprescale --process HLTFake1 --globaltag auto:run2_hlt_Fake1 --input file:RelVal_Raw_Fake1_DATA.root -# /dev/CMSSW_15_0_0/Fake1/V11 (CMSSW_15_0_11) +# /dev/CMSSW_15_1_0/Fake1/V9 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTFake1" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string("/dev/CMSSW_15_0_0/Fake1/V11") + tableName = cms.string("/dev/CMSSW_15_1_0/Fake1/V9") ) process.streams = cms.PSet( A = cms.vstring( 'InitialPD' ) ) @@ -26,7 +26,6 @@ frontierKey = cms.untracked.string( "" ), toGet = cms.VPSet( ), - JsonDumpFileName = cms.untracked.string( "" ), DumpStat = cms.untracked.bool( False ), ReconnectEachRun = cms.untracked.bool( True ), RefreshAlways = cms.untracked.bool( False ), diff --git a/HLTrigger/Configuration/test/OnLine_HLT_Fake2.py b/HLTrigger/Configuration/test/OnLine_HLT_Fake2.py index edeb5c62e746a..83857547a1a6a 100644 --- a/HLTrigger/Configuration/test/OnLine_HLT_Fake2.py +++ b/HLTrigger/Configuration/test/OnLine_HLT_Fake2.py @@ -1,13 +1,13 @@ -# hltGetConfiguration /dev/CMSSW_15_0_0/Fake2 --full --data --type Fake2 --unprescale --process HLTFake2 --globaltag auto:run2_hlt_Fake2 --input file:RelVal_Raw_Fake2_DATA.root +# hltGetConfiguration /dev/CMSSW_15_1_0/Fake2 --full --data --type Fake2 --unprescale --process HLTFake2 --globaltag auto:run2_hlt_Fake2 --input file:RelVal_Raw_Fake2_DATA.root -# /dev/CMSSW_15_0_0/Fake2/V11 (CMSSW_15_0_11) +# /dev/CMSSW_15_1_0/Fake2/V9 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTFake2" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string("/dev/CMSSW_15_0_0/Fake2/V11") + tableName = cms.string("/dev/CMSSW_15_1_0/Fake2/V9") ) process.streams = cms.PSet( A = cms.vstring( 'InitialPD' ) ) diff --git a/HLTrigger/Configuration/test/OnLine_HLT_GRun.py b/HLTrigger/Configuration/test/OnLine_HLT_GRun.py index 8c931d75a8492..de919ae6c2951 100644 --- a/HLTrigger/Configuration/test/OnLine_HLT_GRun.py +++ b/HLTrigger/Configuration/test/OnLine_HLT_GRun.py @@ -1,6 +1,6 @@ -# hltGetConfiguration /dev/CMSSW_15_0_0/GRun --full --data --type GRun --unprescale --process HLTGRun --globaltag auto:run3_hlt_GRun --input file:RelVal_Raw_GRun_DATA.root +# hltGetConfiguration /dev/CMSSW_15_1_0/GRun --full --data --type GRun --unprescale --process HLTGRun --globaltag auto:run3_hlt_GRun --input file:RelVal_Raw_GRun_DATA.root -# /dev/CMSSW_15_0_0/GRun/V114 (CMSSW_15_0_11) +# /dev/CMSSW_15_1_0/GRun/V10 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms @@ -9,7 +9,7 @@ process.load("Configuration.StandardSequences.Accelerators_cff") process.HLTConfigVersion = cms.PSet( - tableName = cms.string("/dev/CMSSW_15_0_0/GRun/V114") + tableName = cms.string("/dev/CMSSW_15_1_0/GRun/V10") ) process.HLTGroupedCkfTrajectoryBuilderP5 = cms.PSet( @@ -2675,6 +2675,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -2815,8 +2816,8 @@ 'HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay2nsInclusive_v14', 'HLT_HT200_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14', 'HLT_HT200_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v14', - 'HLT_HT200_L1SingleLLPJet_DisplacedDijet60_DisplacedTrack_v14', - 'HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p7_v10')+cms.vstring( 'HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p8_v10', + 'HLT_HT200_L1SingleLLPJet_DisplacedDijet60_DisplacedTrack_v14')+cms.vstring( 'HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p7_v10', + 'HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p8_v10', 'HLT_HT240_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11', 'HLT_HT270_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14', 'HLT_HT280_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11', @@ -3069,8 +3070,8 @@ 'HLT_Photon165_R9Id90_HE10_IsoM_v28', 'HLT_Photon175_v26', 'HLT_Photon200_v25', - 'HLT_Photon20_HoverELoose_v21', - 'HLT_Photon300_NoHE_v24')+cms.vstring( 'HLT_Photon30EB_TightID_TightIso_v15', + 'HLT_Photon20_HoverELoose_v21')+cms.vstring( 'HLT_Photon300_NoHE_v24', + 'HLT_Photon30EB_TightID_TightIso_v15', 'HLT_Photon30_HoverELoose_v21', 'HLT_Photon32_OneProng32_M50To105_v14', 'HLT_Photon33_v16', @@ -3142,6 +3143,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -3201,6 +3203,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -3260,6 +3263,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -3319,6 +3323,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -3378,6 +3383,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -3437,6 +3443,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -3496,6 +3503,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -3555,6 +3563,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -4743,7 +4752,9 @@ 'EcalPreshower', 'TOWER' ) ) -process.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder" ) +process.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder", + appendToDataLabel = cms.string( "" ) +) process.CaloTowerConstituentsMapBuilder = cms.ESProducer( "CaloTowerConstituentsMapBuilder", MapFile = cms.untracked.string( "Geometry/CaloTopology/data/CaloTowerEEGeometric.map.gz" ), MapAuto = cms.untracked.bool( False ), @@ -4842,67 +4853,81 @@ appendToDataLabel = cms.string( "" ) ) process.MaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterial" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.MaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.MaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMf" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOppositeForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositePropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStepOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) process.ParametrizedMagneticFieldProducer = cms.ESProducer( "AutoParametrizedMagneticFieldProducer", version = cms.string( "Parabolic" ), @@ -4910,22 +4935,26 @@ valueOverride = cms.int32( -1 ) ) process.PropagatorWithMaterialForLoopers = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 4.0 ), ComponentName = cms.string( "PropagatorWithMaterialForLoopers" ), Mass = cms.double( 0.1396 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 4.0 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.PropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStep" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) process.RPCGeometryESModule = cms.ESProducer( "RPCGeometryESModule", fromDDD = cms.untracked.bool( False ), @@ -5135,7 +5164,9 @@ ), timeThresh = cms.double( 2.0 ) ) -process.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP" ) +process.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP", + appendToDataLabel = cms.string( "" ) +) process.hcalDDDRecConstants = cms.ESProducer( "HcalDDDRecConstantsESModule", appendToDataLabel = cms.string( "" ) ) @@ -5437,13 +5468,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPBwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPBwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPChi2ChargeLooseMeasurementEstimator16 = cms.ESProducer( "Chi2ChargeMeasurementEstimatorESProducer", MaxChi2 = cms.double( 16.0 ), @@ -5822,13 +5855,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPFwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPFwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPGlobalDetLayerGeometry = cms.ESProducer( "GlobalDetLayerGeometryESProducer", ComponentName = cms.string( "hltESPGlobalDetLayerGeometry" ), @@ -6404,13 +6439,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPRungeKuttaTrackerPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPRungeKuttaTrackerPropagator" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( True ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPSiPixelCablingSoA = cms.ESProducer( "SiPixelCablingSoAESProducer@alpaka", CablingMapLabel = cms.string( "" ), @@ -6509,7 +6546,8 @@ mTIB_P0 = cms.double( -0.742 ), mTID_P1 = cms.double( 0.433 ), mTID_P0 = cms.double( -1.427 ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.hltESPTTRHBWithTrackAngle = cms.ESProducer( "TkTransientTrackingRecHitBuilderESProducer", ComponentName = cms.string( "hltESPTTRHBWithTrackAngle" ), @@ -6784,7 +6822,9 @@ UseQualityInfo = cms.bool( False ), appendToDataLabel = cms.string( "" ) ) -process.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer" ) +process.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer", + appendToDataLabel = cms.string( "" ) +) process.siStripBackPlaneCorrectionDepESProducer = cms.ESProducer( "SiStripBackPlaneCorrectionDepESProducer", LatencyRecord = cms.PSet( label = cms.untracked.string( "" ), @@ -6797,7 +6837,8 @@ BackPlaneCorrectionDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripBackPlaneCorrectionRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.siStripLorentzAngleDepESProducer = cms.ESProducer( "SiStripLorentzAngleDepESProducer", LatencyRecord = cms.PSet( @@ -6811,7 +6852,8 @@ LorentzAngleDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripLorentzAngleRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.sistripconn = cms.ESProducer( "SiStripConnectivity" ) process.trackerTopology = cms.ESProducer( "TrackerTopologyEP", @@ -7060,9 +7102,9 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -7663,14 +7705,22 @@ process.hltSiPixelClustersSoA = cms.EDProducer( "SiPixelRawToClusterPhase1@alpaka", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) @@ -7696,36 +7746,38 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltSiPixelRecHits = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), src = cms.InputTag( "hltSiPixelClusters" ) ) process.hltPixelTracksSoA = cms.EDProducer( "CAHitNtupletAlpakaPhase1@alpaka", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -7737,9 +7789,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltPixelTracks = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", @@ -10584,74 +10643,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -12093,9 +12152,9 @@ shouldRunTimingComputation = cms.bool( True ) ) process.hltEcalUncalibRecHitSerialSync = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -12207,74 +12266,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbherecoSerialSync" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHitSerialSync:EcalRecHitsEB','hltEcalRecHitSerialSync:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbherecoSerialSync" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHitSerialSync:EcalRecHitsEB','hltEcalRecHitSerialSync:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -12510,14 +12569,22 @@ process.hltSiPixelClustersSoASerialSync = cms.EDProducer( "alpaka_serial_sync::SiPixelRawToClusterPhase1", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ) ) process.hltSiPixelClustersSerialSync = cms.EDProducer( "SiPixelDigisClustersFromSoAAlpakaPhase1", @@ -12541,6 +12608,7 @@ CPE = cms.string( "PixelCPEFastParams" ) ) process.hltSiPixelRecHitsSerialSync = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), src = cms.InputTag( "hltSiPixelClustersSerialSync" ) ) @@ -12809,31 +12877,32 @@ ) process.hltPixelTracksSoASerialSync = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -12845,9 +12914,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ) + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) process.hltPixelTracksSerialSync = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -20103,7 +20179,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 4096 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( False ) ) process.hltL1sHcalNZS = cms.EDFilter( "HLTL1TSeed", @@ -20148,7 +20224,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 107 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( True ) ) process.hltPrePhysics = cms.EDFilter( "HLTPrescaler", @@ -33286,74 +33362,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( True ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "" ), + ecalInputs = cms.VInputTag( ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -40171,74 +40247,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltCaloRecHitsBeamHaloCleaned" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEB','hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltCaloRecHitsBeamHaloCleaned" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEB','hltCaloRecHitsBeamHaloCleaned:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -40735,22 +40811,23 @@ TriggerTypes = cms.vint32( 86 ) ) process.hltDeepBLifetimeTagInfosPF = cms.EDProducer( "CandIPProducer", - primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), - computeProbabilities = cms.bool( True ), - computeGhostTrack = cms.bool( True ), - ghostTrackPriorDeltaR = cms.double( 0.03 ), - minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 3 ), maximumTransverseImpactParameter = cms.double( 0.2 ), + minimumNumberOfHits = cms.int32( 3 ), minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), + primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), maximumLongitudinalImpactParameter = cms.double( 17.0 ), - jetDirectionUsingTracks = cms.bool( False ), + computeGhostTrack = cms.bool( True ), + maxDeltaR = cms.double( 0.4 ), + candidates = cms.InputTag( "hltParticleFlow" ), jetDirectionUsingGhostTrack = cms.bool( False ), + minimumNumberOfPixelHits = cms.int32( 2 ), + jetDirectionUsingTracks = cms.bool( False ), + computeProbabilities = cms.bool( True ), useTrackQuality = cms.bool( False ), jets = cms.InputTag( "hltPFJetForBtag" ), - candidates = cms.InputTag( "hltParticleFlow" ), - maxDeltaR = cms.double( 0.4 ) + ghostTrackPriorDeltaR = cms.double( 0.03 ), + maximumChiSquared = cms.double( 5.0 ), + explicitJTA = cms.bool( False ) ) process.hltDeepInclusiveVertexFinderPF = cms.EDProducer( "InclusiveCandidateVertexFinder", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -42946,15 +43023,15 @@ etMin = cms.double( 20.0 ) ) process.hltBSoftMuonDiJet20L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet20L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -42995,15 +43072,15 @@ invertRapidityCut = cms.bool( False ) ) process.hltBSoftMuonDiJet20L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet20L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet20L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43065,15 +43142,15 @@ etMin = cms.double( 40.0 ) ) process.hltBSoftMuonDiJet40L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet40L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43091,15 +43168,15 @@ TriggerType = cms.int32( 86 ) ) process.hltBSoftMuonDiJet40L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet40L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet40L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43161,15 +43238,15 @@ etMin = cms.double( 70.0 ) ) process.hltBSoftMuonDiJet70L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet70L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43187,15 +43264,15 @@ TriggerType = cms.int32( 86 ) ) process.hltBSoftMuonDiJet70L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet70L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet70L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43257,15 +43334,15 @@ etMin = cms.double( 110.0 ) ) process.hltBSoftMuonDiJet110L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet110L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43283,15 +43360,15 @@ TriggerType = cms.int32( 86 ) ) process.hltBSoftMuonDiJet110L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet110L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet110L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43353,15 +43430,15 @@ etMin = cms.double( 110.0 ) ) process.hltBSoftMuonDiJet200L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet200L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43379,15 +43456,15 @@ TriggerType = cms.int32( 86 ) ) process.hltBSoftMuonDiJet200L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonDiJet200L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonDiJet200L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43449,15 +43526,15 @@ etMin = cms.double( 300.0 ) ) process.hltBSoftMuonJet300L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonJet300L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43475,15 +43552,15 @@ TriggerType = cms.int32( 86 ) ) process.hltBSoftMuonJet300L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.4 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonJet300L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43532,15 +43609,15 @@ etMin = cms.double( 110.0 ) ) process.hltBSoftMuonAK8DiJet170L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonAK8DiJet170L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43558,15 +43635,15 @@ TriggerType = cms.int32( 85 ) ) process.hltBSoftMuonAK8DiJet170L1FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8DiJet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonAK8DiJet170L1FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43660,15 +43737,15 @@ etMin = cms.double( 170.0 ) ) process.hltBSoftMuonAK8Jet170L1FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonAK8Jet170L1FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43736,15 +43813,15 @@ invertRapidityCut = cms.bool( False ) ) process.hltBSoftMuonAK8Jet170L1FastJetDoubleMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonDoubleMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonAK8Jet170L1FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonAK8Jet170L1FastJetDoubleMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43793,15 +43870,15 @@ etMin = cms.double( 300.0 ) ) process.hltBSoftMuonJet300L1AK8FastJetL25TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltL2Muons" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonJet300L1AK8FastJetL25BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -43819,15 +43896,15 @@ TriggerType = cms.int32( 85 ) ) process.hltBSoftMuonJet300L1AK8FastJetMu5SelL3TagInfos = cms.EDProducer( "SoftLepton", - primaryVertex = cms.InputTag( "nominal" ), - jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), + muonSelection = cms.uint32( 0 ), leptons = cms.InputTag( "hltBSoftMuonMu5L3" ), + primaryVertex = cms.InputTag( "nominal" ), leptonCands = cms.InputTag( "" ), leptonId = cms.InputTag( "" ), refineJetAxis = cms.uint32( 0 ), + jets = cms.InputTag( "hltBSoftMuonJet300L1AK8FastJetL25Jets" ), leptonDeltaRCut = cms.double( 0.8 ), - leptonChi2Cut = cms.double( 0.0 ), - muonSelection = cms.uint32( 0 ) + leptonChi2Cut = cms.double( 0.0 ) ) process.hltBSoftMuonJet300L1AK8FastJetMu5SelL3BJetTagsByDR = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPSoftLeptonByDistance" ), @@ -50182,6 +50259,98 @@ BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), MuonTag = cms.InputTag( "hltIterL3MuonCandidates" ) ) +process.hltPreDimuon0LowMassInclusive = cms.EDFilter( "HLTPrescaler", + offset = cms.uint32( 0 ), + L1GtReadoutRecordTag = cms.InputTag( "hltGtStage2Digis" ) +) +process.hltL1fL1DoubleMu0SQInclusiveL1Filtered0 = cms.EDFilter( "HLTMuonL1TFilter", + saveTags = cms.bool( True ), + CandTag = cms.InputTag( 'hltGtStage2Digis','Muon' ), + PreviousCandTag = cms.InputTag( "hltL1sDoubleMu0SQOS" ), + MaxEta = cms.double( 2.5 ), + MinPt = cms.double( 0.0 ), + MaxDeltaR = cms.double( 0.3 ), + MinN = cms.int32( 2 ), + CentralBxOnly = cms.bool( True ), + SelectQualities = cms.vint32( ) +) +process.hltL2fL1sL1DoubleMu0SQInclusiveL2PreFiltered0 = cms.EDFilter( "HLTMuonL2FromL1TPreFilter", + saveTags = cms.bool( True ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + CandTag = cms.InputTag( "hltL2MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltL1fL1DoubleMu0SQInclusiveL1Filtered0" ), + SeedMapTag = cms.InputTag( "hltL2Muons" ), + MinN = cms.int32( 0 ), + MaxEta = cms.double( 2.5 ), + AbsEtaBins = cms.vdouble( 0.0 ), + MinNstations = cms.vint32( 0 ), + MinNhits = cms.vint32( 0 ), + CutOnChambers = cms.bool( False ), + MinNchambers = cms.vint32( 0 ), + MaxDr = cms.double( 9999.0 ), + MinDr = cms.double( -1.0 ), + MaxDz = cms.double( 9999.0 ), + MinDxySig = cms.double( -1.0 ), + MinPt = cms.double( 0.0 ), + NSigmaPt = cms.double( 0.0 ), + MatchToPreviousCand = cms.bool( True ) +) +process.hltL1fForIterL3L1fL1DoubleMu0SQInclusiveL1Filtered0 = cms.EDFilter( "HLTMuonL1TFilter", + saveTags = cms.bool( True ), + CandTag = cms.InputTag( "hltL1MuonsPt0" ), + PreviousCandTag = cms.InputTag( "hltL1fL1DoubleMu0SQInclusiveL1Filtered0" ), + MaxEta = cms.double( 2.5 ), + MinPt = cms.double( 0.0 ), + MaxDeltaR = cms.double( 0.3 ), + MinN = cms.int32( 1 ), + CentralBxOnly = cms.bool( True ), + SelectQualities = cms.vint32( ) +) +process.hltDimuon0LowMassInclusiveL3Filtered = cms.EDFilter( "HLTMuonDimuonL3Filter", + saveTags = cms.bool( True ), + BeamSpotTag = cms.InputTag( "hltOnlineBeamSpot" ), + CandTag = cms.InputTag( "hltIterL3MuonCandidates" ), + PreviousCandTag = cms.InputTag( "hltL2fL1sL1DoubleMu0SQInclusiveL2PreFiltered0" ), + L1CandTag = cms.InputTag( "hltL1fForIterL3L1fL1DoubleMu0SQInclusiveL1Filtered0" ), + inputMuonCollection = cms.InputTag( "hltIterL3Muons" ), + PreviousCandIsL2 = cms.bool( True ), + FastAccept = cms.bool( False ), + MinN = cms.int32( 1 ), + MaxEta = cms.double( 2.5 ), + MinNhits = cms.int32( 0 ), + MaxDr = cms.double( 2.0 ), + MaxDz = cms.double( 9999.0 ), + ChargeOpt = cms.int32( 0 ), + MinPtPair = cms.vdouble( 0.0 ), + MaxPtPair = cms.vdouble( 1.0E125 ), + MinPtMax = cms.vdouble( 0.0 ), + MinPtMin = cms.vdouble( 0.0 ), + MaxPtMin = cms.vdouble( 1.0E125 ), + MinInvMass = cms.vdouble( 0.2 ), + MaxInvMass = cms.vdouble( 12.0 ), + MinDiMuonDeltaR = cms.double( -1.0 ), + MinAcop = cms.double( -999.0 ), + MaxAcop = cms.double( 999.0 ), + MinPtBalance = cms.double( -1.0 ), + MaxPtBalance = cms.double( 999999.0 ), + NSigmaPt = cms.double( 0.0 ), + MaxDCAMuMu = cms.double( 0.5 ), + MaxRapidityPair = cms.double( 999999.0 ), + CutCowboys = cms.bool( False ), + InputLinks = cms.InputTag( "hltL3MuonsIterL3Links" ), + L1MatchingdR = cms.double( 0.3 ), + MatchToPreviousCand = cms.bool( True ), + useSimpleGeometry = cms.bool( True ), + useStation2 = cms.bool( True ), + fallbackToME1 = cms.bool( False ), + cosmicPropagationHypothesis = cms.bool( False ), + useMB2InOverlap = cms.bool( False ), + useTrack = cms.string( "tracker" ), + useState = cms.string( "atVertex" ), + propagatorAlong = cms.ESInputTag( "","hltESPSteppingHelixPropagatorAlong" ), + propagatorAny = cms.ESInputTag( "","SteppingHelixPropagatorAny" ), + propagatorOpposite = cms.ESInputTag( "","hltESPSteppingHelixPropagatorOpposite" ) +) process.hltL1sTripleMu530NoMass = cms.EDFilter( "HLTL1TSeed", saveTags = cms.bool( True ), L1SeedsLogicalExpression = cms.string( "L1_TripleMu_5SQ_3SQ_0OQ" ), @@ -60339,74 +60508,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( True ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "" ), + hbheInput = cms.InputTag( "" ), + hoInput = cms.InputTag( "" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -66674,22 +66843,23 @@ TriggerTypes = cms.vint32( 86 ) ) process.hltDeepBLifetimeTagInfosPFMinPt20 = cms.EDProducer( "CandIPProducer", - primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), - computeProbabilities = cms.bool( True ), - computeGhostTrack = cms.bool( True ), - ghostTrackPriorDeltaR = cms.double( 0.03 ), - minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 3 ), maximumTransverseImpactParameter = cms.double( 0.2 ), + minimumNumberOfHits = cms.int32( 3 ), minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), + primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), maximumLongitudinalImpactParameter = cms.double( 17.0 ), - jetDirectionUsingTracks = cms.bool( False ), + computeGhostTrack = cms.bool( True ), + maxDeltaR = cms.double( 0.4 ), + candidates = cms.InputTag( "hltParticleFlow" ), jetDirectionUsingGhostTrack = cms.bool( False ), + minimumNumberOfPixelHits = cms.int32( 2 ), + jetDirectionUsingTracks = cms.bool( False ), + computeProbabilities = cms.bool( True ), useTrackQuality = cms.bool( False ), jets = cms.InputTag( "hltPFJetForBtagMinPt20" ), - candidates = cms.InputTag( "hltParticleFlow" ), - maxDeltaR = cms.double( 0.4 ) + ghostTrackPriorDeltaR = cms.double( 0.03 ), + maximumChiSquared = cms.double( 5.0 ), + explicitJTA = cms.bool( False ) ) process.hltPrimaryVertexAssociationMinPt20 = cms.EDProducer( "PFCandidatePrimaryVertexSorter", sorting = cms.PSet( ), @@ -73233,20 +73403,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerLowPtSingle = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPtSingle" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPtSingle" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLowPtSingle = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -73815,20 +73985,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPtSingle = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPtSingle" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPtSingle" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPtSingle = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -73977,20 +74147,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerLowPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLowPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -74019,20 +74189,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -74387,20 +74557,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerLow30Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow30PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74429,20 +74599,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow30Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow30Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74740,20 +74910,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLow30Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow30Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) process.hltL4DisplacedDijetFullTracksJetTagProducerLooseFromIPLow30Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1stLoose" ), @@ -74798,20 +74968,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerLow35Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow35PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74840,20 +75010,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow35Pt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow35Pt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74897,20 +75067,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow35Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow35Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -74939,20 +75109,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLow35Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow35Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) process.hltL4DisplacedDijetFullTracksJetTagProducerLooseFromIPLow35Pt1PtrkPt0p5ShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1stLoose" ), @@ -75000,20 +75170,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75057,20 +75227,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLowPt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLowPt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75099,20 +75269,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLowPt1PtrkPt0p5ShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) process.hltL4DisplacedDijetFullTracksJetTagProducerLooseFromIPLowPt1PtrkPt0p5ShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1stLoose" ), @@ -75157,20 +75327,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerLow45Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow45Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow45Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow45PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75199,20 +75369,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow45Pt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow45Pt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow45Pt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow45Pt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75257,20 +75427,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerLow50Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow50Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexLow50Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPLow50PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75299,20 +75469,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerLow50Pt0PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow50Pt0PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexLow50Pt0PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPLow50Pt0PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75375,20 +75545,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducer45Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertex45Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertex45Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIP45PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75417,20 +75587,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducer45Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertex45Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertex45Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIP45Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -75518,20 +75688,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerLowPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexLowPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) process.hltL4DisplacedDijetFullTracksJetTagProducerFromIPLowPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1st" ), @@ -75589,20 +75759,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedDijet100FullTracksTrackIPProducerMidPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedDijetFullTracksJetTagProducerFromIPMidPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -75631,20 +75801,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedDijetFullTracksTrackIPProducerMidPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexMidPt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetPromptTracksAssociatorAtVertexMidPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedDijetFullTracksJetTagProducerFromIPMidPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducer" ), @@ -76168,22 +76338,23 @@ TriggerTypes = cms.vint32( 86 ) ) process.hltDeepBLifetimeTagInfosPFMinPt10 = cms.EDProducer( "CandIPProducer", - primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), - computeProbabilities = cms.bool( True ), - computeGhostTrack = cms.bool( True ), - ghostTrackPriorDeltaR = cms.double( 0.03 ), - minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 3 ), maximumTransverseImpactParameter = cms.double( 0.2 ), + minimumNumberOfHits = cms.int32( 3 ), minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), + primaryVertex = cms.InputTag( "hltVerticesPFFilter" ), maximumLongitudinalImpactParameter = cms.double( 17.0 ), - jetDirectionUsingTracks = cms.bool( False ), + computeGhostTrack = cms.bool( True ), + maxDeltaR = cms.double( 0.4 ), + candidates = cms.InputTag( "hltParticleFlow" ), jetDirectionUsingGhostTrack = cms.bool( False ), + minimumNumberOfPixelHits = cms.int32( 2 ), + jetDirectionUsingTracks = cms.bool( False ), + computeProbabilities = cms.bool( True ), useTrackQuality = cms.bool( False ), jets = cms.InputTag( "hltPFJetForBtagMinPt10" ), - candidates = cms.InputTag( "hltParticleFlow" ), - maxDeltaR = cms.double( 0.4 ) + ghostTrackPriorDeltaR = cms.double( 0.03 ), + maximumChiSquared = cms.double( 5.0 ), + explicitJTA = cms.bool( False ) ) process.hltPrimaryVertexAssociationMinPt10 = cms.EDProducer( "PFCandidatePrimaryVertexSorter", sorting = cms.PSet( ), @@ -76344,20 +76515,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedSingleJet100FullTracksTrackIPProducer30Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex30Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex30Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedSingleJetFullTracksJetTagProducerFromIP30PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76386,20 +76557,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedSingleJetFullTracksTrackIPProducer30Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex30Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex30Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedSingleJetFullTracksJetTagProducerFromIP30Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76468,20 +76639,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedSingleJet100FullTracksTrackIPProducer35Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex35Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex35Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedSingleJetFullTracksJetTagProducerFromIP35PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76510,20 +76681,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedSingleJetFullTracksTrackIPProducer35Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex35Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex35Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedSingleJetFullTracksJetTagProducerFromIP35Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76556,20 +76727,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL3DisplacedSingleJet100FullTracksTrackIPProducer40Pt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex40Pt" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL3DisplacedSingleJetFullTracksJetTracksAssociatorAtVertex40Pt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL3DisplacedSingleJetFullTracksJetTagProducerFromIP40PtShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76598,20 +76769,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4PromptDisplacedSingleJetFullTracksTrackIPProducer40Pt1PtrkShortSig5 = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex40Pt1PtrkShortSig5" ), + maximumTransverseImpactParameter = cms.double( 0.1 ), + minimumNumberOfHits = cms.int32( 8 ), + minimumTransverseMomentum = cms.double( 0.5 ), primaryVertex = cms.InputTag( "hltFastPVPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 0.1 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedSingleJetFullTracksJetPromptTracksAssociatorAtVertex40Pt1PtrkShortSig5" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 2 ), - minimumNumberOfHits = cms.int32( 8 ), - maximumTransverseImpactParameter = cms.double( 0.1 ), - minimumTransverseMomentum = cms.double( 0.5 ), - maximumChiSquared = cms.double( 20.0 ), - maximumLongitudinalImpactParameter = cms.double( 0.1 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 20.0 ) ) process.hltL4PromptDisplacedSingleJetFullTracksJetTagProducerFromIP40Pt1PtrkShortSig5 = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltPromptTrackCountingESProducerShortSig5" ), @@ -76894,20 +77065,20 @@ pvSrc = cms.InputTag( "" ) ) process.hltL4TaggedDisplacedDijetFullTracksTrackIPProducerMidPt = cms.EDProducer( "TrackIPProducer", - jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + maximumTransverseImpactParameter = cms.double( 9999999.0 ), + minimumNumberOfHits = cms.int32( 6 ), + minimumTransverseMomentum = cms.double( 1.0 ), primaryVertex = cms.InputTag( "hltDisplacedhltTrimmedPixelVertices" ), - computeProbabilities = cms.bool( False ), + maximumLongitudinalImpactParameter = cms.double( 17.0 ), computeGhostTrack = cms.bool( False ), ghostTrackPriorDeltaR = cms.double( 0.03 ), + jetTracks = cms.InputTag( "hltL4DisplacedDijetFullTracksJetTracksAssociatorAtVertexMidPt" ), + jetDirectionUsingGhostTrack = cms.bool( False ), minimumNumberOfPixelHits = cms.int32( 0 ), - minimumNumberOfHits = cms.int32( 6 ), - maximumTransverseImpactParameter = cms.double( 9999999.0 ), - minimumTransverseMomentum = cms.double( 1.0 ), - maximumChiSquared = cms.double( 5.0 ), - maximumLongitudinalImpactParameter = cms.double( 17.0 ), jetDirectionUsingTracks = cms.bool( False ), - jetDirectionUsingGhostTrack = cms.bool( False ), - useTrackQuality = cms.bool( False ) + computeProbabilities = cms.bool( False ), + useTrackQuality = cms.bool( False ), + maximumChiSquared = cms.double( 5.0 ) ) process.hltL4DisplacedDijetFullTracksJetTagProducerFromIPMidPt = cms.EDProducer( "JetTagProducer", jetTagComputer = cms.string( "hltESPDisplacedDijethltTrackCounting2D1st" ), @@ -87513,6 +87684,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -87653,8 +87825,8 @@ 'HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay2nsInclusive_v14', 'HLT_HT200_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14', 'HLT_HT200_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v14', - 'HLT_HT200_L1SingleLLPJet_DisplacedDijet60_DisplacedTrack_v14', - 'HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p7_v10')+cms.vstring( 'HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p8_v10', + 'HLT_HT200_L1SingleLLPJet_DisplacedDijet60_DisplacedTrack_v14')+cms.vstring( 'HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p7_v10', + 'HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p8_v10', 'HLT_HT240_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11', 'HLT_HT270_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14', 'HLT_HT280_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11', @@ -87907,8 +88079,8 @@ 'HLT_Photon165_R9Id90_HE10_IsoM_v28', 'HLT_Photon175_v26', 'HLT_Photon200_v25', - 'HLT_Photon20_HoverELoose_v21', - 'HLT_Photon300_NoHE_v24')+cms.vstring( 'HLT_Photon30EB_TightID_TightIso_v15', + 'HLT_Photon20_HoverELoose_v21')+cms.vstring( 'HLT_Photon300_NoHE_v24', + 'HLT_Photon30EB_TightID_TightIso_v15', 'HLT_Photon30_HoverELoose_v21', 'HLT_Photon32_OneProng32_M50To105_v14', 'HLT_Photon33_v16', @@ -87986,6 +88158,7 @@ 'HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23', 'HLT_Dimuon0_Jpsi_NoVertexing_v24', 'HLT_Dimuon0_Jpsi_v24', + 'HLT_Dimuon0_LowMass_Inclusive_v1', 'HLT_Dimuon0_LowMass_L1_0er1p5_v24', 'HLT_Dimuon0_LowMass_L1_4_v24', 'HLT_Dimuon0_LowMass_L1_TM530_v22', @@ -90777,6 +90950,7 @@ process.HLT_Dimuon0_LowMass_L1_0er1p5_v24 = cms.Path( process.HLTBeginSequence + process.hltL1sDoubleMu0er1p5 + process.hltPreDimuon0LowMassL10er1p5 + process.hltL1sEmuDoubleMu0er1p5 + process.hltL1fL1sL1DoubleMu0er1p5L1Filtered0 + process.HLTL2muonrecoSequence + cms.ignore(process.hltL2fL1sL1DoubleMu0er1p5L1f0L2PreFiltered0) + process.HLTL3muonrecoSequence + cms.ignore(process.hltL1fForIterL3L1fL1sL1DoubleMu0er1p5L1Filtered0) + process.hltDimuon0LowMassL1s0er1p5L3Filtered + process.hltDisplacedmumuVtxProducerDimuon0LowMassL1s0er1p5 + process.hltDisplacedmumuFilterDimuon0LowMassL1s0er1p5 + process.HLTEndSequence ) process.HLT_Dimuon0_LowMass_v24 = cms.Path( process.HLTBeginSequence + process.hltL1sDoubleMu0SQOS + process.hltPreDimuon0LowMass + process.hltL1sEmuDoubleMu0SQOS + process.hltL1fL1DoubleMu0SQOSL1Filtered0 + process.HLTL2muonrecoSequence + cms.ignore(process.hltL2fL1sL1DoubleMu0SQOSL2PreFiltered0) + process.HLTL3muonrecoSequence + cms.ignore(process.hltL1fForIterL3L1fL1DoubleMu0SQOSL1Filtered0) + process.hltDimuon0LowMassL3Filtered + process.hltDisplacedmumuVtxProducerDimuon0LowMass + process.hltDisplacedmumuFilterDimuon0LowMass + process.HLTEndSequence ) process.HLT_Dimuon0_LowMass_L1_4_v24 = cms.Path( process.HLTBeginSequence + process.hltL1sDoubleMu4SQOS + process.hltPreDimuon0LowMassL14 + process.hltL1sEmuDoubleMu4SQOS + process.hltL1fL1sL1DoubleMu4SQOSL1Filtered0 + process.HLTL2muonrecoSequence + cms.ignore(process.hltL2fL1sL1DoubleMu4SQOSL1f0L2PreFiltered0) + process.HLTL3muonrecoSequence + cms.ignore(process.hltL1fForIterL3L1fL1sL1DoubleMu4SQOSL1Filtered0) + process.hltDimuon0LowMassL1s4L3Filtered + process.hltDisplacedmumuVtxProducerDimuon0LowMassL1s4 + process.hltDisplacedmumuFilterDimuon0LowMassL1s4 + process.HLTEndSequence ) +process.HLT_Dimuon0_LowMass_Inclusive_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sDoubleMu0SQOS + process.hltPreDimuon0LowMassInclusive + process.hltL1fL1DoubleMu0SQInclusiveL1Filtered0 + process.HLTL2muonrecoSequence + cms.ignore(process.hltL2fL1sL1DoubleMu0SQInclusiveL2PreFiltered0) + process.HLTL3muonrecoSequence + cms.ignore(process.hltL1fForIterL3L1fL1DoubleMu0SQInclusiveL1Filtered0) + process.hltDimuon0LowMassInclusiveL3Filtered + process.HLTEndSequence ) process.HLT_Dimuon0_LowMass_L1_TM530_v22 = cms.Path( process.HLTBeginSequence + process.hltL1sTripleMu530NoMass + process.hltPreDimuon0LowMassL1TM530 + process.hltL1fL1sL1TripleMuNoMassL1Filtered0 + process.HLTL2muonrecoSequence + cms.ignore(process.hltL2fL1sL1TripleMuNoMassL1f0L2PreFiltered0) + process.HLTL3muonrecoSequence + cms.ignore(process.hltL1fForIterL3L1fL1sL1TripleMuNoMassL1Filtered0) + process.hltDimuon0LowMassL1sTM530L3Filtered + process.hltDisplacedmumuVtxProducerDimuon0LowMassL1sTM530 + process.hltDisplacedmumuFilterDimuon0LowMassL1sTM530 + process.HLTEndSequence ) process.HLT_Dimuon0_Upsilon_Muon_NoL1Mass_v22 = cms.Path( process.HLTBeginSequence + process.hltL1sTripleMu53p52p5 + process.hltPreDimuon0UpsilonMuonNoL1Mass + process.hltTripleMuon53p52p5L1Filtered0 + process.HLTL2muonrecoSequence + cms.ignore(process.hltTripleMuon53p52p5L2PreFiltered0) + process.HLTL3muonrecoSequence + cms.ignore(process.hltL1fForIterL3TripleMuon53p52p5L1Filtered0) + process.hltTripleMu0NoL1MassL3PreFiltered0 + process.hltUpsilon0MuonL3FilteredNoL1Mass + process.hltDisplacedmumuVtxProducerUpsilon0MuonNoL1Mass + process.hltVertexmumuFilterUpsilon0MuonNoL1Mass + process.HLTEndSequence ) process.HLT_Dimuon0_Upsilon_v2 = cms.Path( process.HLTBeginSequence + process.hltL1s12ForUpsilonDimuon0Mass8to12 + process.hltPreDimuon0Upsilon + process.hltL1fL1sL1s12DoubleMu0er2p0SQOSMass8to12L1v2Filtered0 + process.HLTL2muonrecoSequence + cms.ignore(process.hltL2fL1sL1s12DoubleMu0er2p0SQOSMass8to12L1f0L2v2PreFiltered0) + process.HLTL3muonrecoSequence + cms.ignore(process.hltL1fForIterL3L1fL1sL1s12DoubleMu0er2p0SQOSMass8to12L1v2Filtered0) + process.hltDimuon0UpsilonyL3fL3Filtered + process.hltDisplacedmumuVtxProducerDimuon0Upsilonsv3 + process.hltDisplacedmumuFilterDimuon0Upsilonsv3 + process.HLTEndSequence ) @@ -91402,7 +91576,7 @@ process.LocalTestDataScoutingOutput = cms.EndPath( process.hltOutputLocalTestDataScouting ) -process.schedule = cms.Schedule( *(process.HLTriggerFirstPath, process.Status_OnCPU, process.Status_OnGPU, process.AlCa_EcalPhiSym_v22, process.AlCa_EcalEtaEBonly_v27, process.AlCa_EcalEtaEEonly_v27, process.AlCa_EcalPi0EBonly_v27, process.AlCa_EcalPi0EEonly_v27, process.AlCa_IsoTrackHBHE_v3, process.AlCa_RPCMuonNormalisation_v25, process.AlCa_LumiPixelsCounts_Random_v12, process.AlCa_LumiPixelsCounts_ZeroBias_v15, process.AlCa_PFJet40_v36, process.AlCa_PFJet40_CPUOnly_v15, process.AlCa_AK8PFJet40_v31, process.DQM_PixelReconstruction_v14, process.DQM_EcalReconstruction_v13, process.DQM_HcalReconstruction_v11, process.DST_ZeroBias_v12, process.DST_Physics_v17, process.DST_PFScouting_DoubleMuonNoVtx_v4, process.DST_PFScouting_DoubleMuonVtx_v4, process.DST_PFScouting_DoubleMuonVtxMonitorJPsi_v4, process.DST_PFScouting_DoubleMuonVtxMonitorZ_v4, process.DST_PFScouting_DoubleEG_v10, process.DST_PFScouting_DoubleEGMonitorJPsi_v1, process.DST_PFScouting_DoubleEGMonitorZ_v1, process.DST_PFScouting_SinglePhotonEBMonitorJPsi_v1, process.DST_PFScouting_SinglePhotonEBMonitorZ_v1, process.DST_PFScouting_JetHT_v10, process.DST_PFScouting_AXOVLoose_v8, process.DST_PFScouting_AXOLoose_v8, process.DST_PFScouting_AXOMedium_v4, process.DST_PFScouting_AXOTight_v10, process.DST_PFScouting_AXOVTight_v8, process.HLT_MonitorL1TPureRate_AXO_v1, process.DST_PFScouting_CICADAVLoose_v6, process.DST_PFScouting_CICADALoose_v6, process.DST_PFScouting_CICADAMedium_v6, process.DST_PFScouting_CICADATight_v6, process.DST_PFScouting_CICADAVTight_v6, process.HLT_MonitorL1TPureRate_CICADA_v1, process.DST_PFScouting_SingleMuon_v10, process.DST_PFScouting_SinglePhotonEB_v7, process.DST_PFScouting_ZeroBias_v8, process.HLT_TriggersForScoutingPFMonitor_PS125_v1, process.HLT_TriggersForScoutingPFMonitor_PS250_v1, process.HLT_TriggersForScoutingPFMonitor_PS500_v1, process.HLT_TriggersForScoutingPFMonitor_PS1000_v1, process.HLT_EphemeralPhysics_v10, process.HLT_EphemeralZeroBias_v10, process.HLT_EcalCalibration_v4, process.HLT_HcalCalibration_v6, process.HLT_HcalNZS_v22, process.HLT_HcalPhiSym_v24, process.HLT_Random_v3, process.HLT_Physics_v15, process.HLT_ZeroBias_v14, process.HLT_ZeroBias_Alignment_v9, process.HLT_ZeroBias_Beamspot_v20, process.HLT_ZeroBias_IsolatedBunches_v13, process.HLT_ZeroBias_FirstBXAfterTrain_v11, process.HLT_ZeroBias_FirstCollisionAfterAbortGap_v13, process.HLT_ZeroBias_FirstCollisionInTrain_v12, process.HLT_ZeroBias_LastCollisionInTrain_v11, process.HLT_HT300_Beamspot_v27, process.HLT_PFJet40_GPUvsCPU_v8, process.HLT_AK8PFJet380_SoftDropMass30_v10, process.HLT_AK8PFJet400_SoftDropMass30_v10, process.HLT_AK8PFJet425_SoftDropMass30_v10, process.HLT_AK8PFJet450_SoftDropMass30_v10, process.HLT_AK8DiPFJet250_250_SoftDropMass40_v10, process.HLT_AK8DiPFJet250_250_SoftDropMass50_v10, process.HLT_AK8DiPFJet260_260_SoftDropMass30_v10, process.HLT_AK8DiPFJet260_260_SoftDropMass40_v10, process.HLT_AK8DiPFJet270_270_SoftDropMass30_v10, process.HLT_AK8DiPFJet280_280_SoftDropMass30_v16, process.HLT_AK8DiPFJet290_290_SoftDropMass30_v10, process.HLT_CaloJet500_NoJetID_v24, process.HLT_CaloJet550_NoJetID_v19, process.HLT_DoubleMu5_Upsilon_DoubleEle3_CaloIdL_TrackIdL_v20, process.HLT_DoubleMu3_DoubleEle7p5_CaloIdL_TrackIdL_Upsilon_v20, process.HLT_Trimuon5_3p5_2_Upsilon_Muon_v21, process.HLT_TrimuonOpen_5_3p5_2_Upsilon_Muon_v18, process.HLT_DoubleEle25_CaloIdL_MW_v18, process.HLT_DoubleEle27_CaloIdL_MW_v18, process.HLT_DoubleEle33_CaloIdL_MW_v31, process.HLT_DoubleEle24_eta2p1_WPTight_Gsf_v22, process.HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_DZ_PFHT350_v36, process.HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_PFHT350_v36, process.HLT_Mu27_Ele37_CaloIdL_MW_v21, process.HLT_Mu37_Ele27_CaloIdL_MW_v21, process.HLT_Mu37_TkMu27_v21, process.HLT_DoubleMu4_3_Bs_v31, process.HLT_DoubleMu4_3_Jpsi_v31, process.HLT_DoubleMu4_3_LowMass_v17, process.HLT_DoubleMu4_LowMass_Displaced_v17, process.HLT_Mu0_L1DoubleMu_v17, process.HLT_Mu4_L1DoubleMu_v17, process.HLT_DoubleMu2_Jpsi_LowPt_v10, process.HLT_DoubleMu4_3_Photon4_BsToMMG_v16, process.HLT_DoubleMu4_3_Displaced_Photon4_BsToMMG_v16, process.HLT_DoubleMu3_Trk_Tau3mu_v28, process.HLT_DoubleMu3_TkMu_DsTau3Mu_v20, process.HLT_DoubleMu4_Mass3p8_DZ_PFHT350_v24, process.HLT_DoubleMu4_MuMuTrk_Displaced_v31, process.HLT_Mu3_PFJet40_v32, process.HLT_Mu7p5_L2Mu2_Jpsi_v26, process.HLT_Mu7p5_L2Mu2_Upsilon_v26, process.HLT_Mu3_L1SingleMu5orSingleMu7_v17, process.HLT_Mu0_Barrel_v10, process.HLT_Mu0_Barrel_L1HP6_v7, process.HLT_Mu0_Barrel_L1HP7_v7, process.HLT_Mu0_Barrel_L1HP8_v8, process.HLT_Mu0_Barrel_L1HP9_v8, process.HLT_Mu0_Barrel_L1HP10_v10, process.HLT_Mu0_Barrel_L1HP11_v10, process.HLT_Mu0_Barrel_L1HP13_v4, process.HLT_Mu0_Barrel_L1HP6_IP6_v7, process.HLT_Mu4_Barrel_IP4_v4, process.HLT_Mu4_Barrel_IP6_v4, process.HLT_Mu6_Barrel_L1HP7_IP6_v7, process.HLT_Mu7_Barrel_L1HP8_IP6_v8, process.HLT_Mu8_Barrel_L1HP9_IP6_v8, process.HLT_Mu9_Barrel_L1HP10_IP6_v10, process.HLT_Mu10_Barrel_L1HP11_IP4_v4, process.HLT_Mu10_Barrel_L1HP11_IP6_v10, process.HLT_Mu12_Barrel_L1HP13_IP4_v4, process.HLT_Mu12_Barrel_L1HP13_IP6_v4, process.HLT_DoublePhoton33_CaloIdL_v18, process.HLT_DoublePhoton70_v18, process.HLT_DoublePhoton85_v26, process.HLT_DiEle27_WPTightCaloOnly_L1DoubleEG_v16, process.HLT_Ele30_WPTight_Gsf_v16, process.HLT_Ele32_WPTight_Gsf_v30, process.HLT_Ele35_WPTight_Gsf_v24, process.HLT_Ele38_WPTight_Gsf_v24, process.HLT_Ele40_WPTight_Gsf_v24, process.HLT_Ele32_WPTight_Gsf_L1DoubleEG_v24, process.HLT_IsoMu20_v31, process.HLT_IsoMu24_v29, process.HLT_IsoMu24_HLTTracking_v4, process.HLT_IsoMu24_eta2p1_v31, process.HLT_IsoMu27_v32, process.HLT_UncorrectedJetE30_NoBPTX_v16, process.HLT_UncorrectedJetE30_NoBPTX3BX_v16, process.HLT_UncorrectedJetE60_NoBPTX3BX_v16, process.HLT_UncorrectedJetE70_NoBPTX3BX_v16, process.HLT_L1SingleMuCosmics_v9, process.HLT_L2Mu10_NoVertex_NoBPTX3BX_v15, process.HLT_L2Mu10_NoVertex_NoBPTX_v16, process.HLT_L2Mu45_NoVertex_3Sta_NoBPTX3BX_v14, process.HLT_L2Mu40_NoVertex_3Sta_NoBPTX3BX_v15, process.HLT_L2Mu23NoVtx_2Cha_v11, process.HLT_L2Mu23NoVtx_2Cha_CosmicSeed_v11, process.HLT_DoubleL2Mu30NoVtx_2Cha_CosmicSeed_Eta2p4_v12, process.HLT_DoubleL2Mu30NoVtx_2Cha_Eta2p4_v12, process.HLT_DoubleL2Mu50_v12, process.HLT_DoubleL2Mu23NoVtx_2Cha_CosmicSeed_v12, process.HLT_DoubleL2Mu25NoVtx_2Cha_CosmicSeed_v12, process.HLT_DoubleL2Mu25NoVtx_2Cha_CosmicSeed_Eta2p4_v12, process.HLT_DoubleL2Mu23NoVtx_2Cha_v12, process.HLT_DoubleL2Mu25NoVtx_2Cha_v12, process.HLT_DoubleL2Mu25NoVtx_2Cha_Eta2p4_v12, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v30, process.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_v19, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v31, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_HLTTracking_v4, process.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_v19, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_v21, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_PFJet30_v10, process.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_Mass8_v19, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass3p8_v21, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass3p8_HLTTracking_v4, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_CaloJet30_v9, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_AK8PFJet30_v9, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_AK8CaloJet30_v9, process.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_Mass3p8_v19, process.HLT_Mu30_TkMu0_Psi_v17, process.HLT_Mu30_TkMu0_Upsilon_v17, process.HLT_Mu25_TkMu0_Phi_v24, process.HLT_Mu15_v19, process.HLT_Mu20_v28, process.HLT_Mu27_v29, process.HLT_Mu50_v29, process.HLT_Mu55_v19, process.HLT_CascadeMu100_v16, process.HLT_HighPtTkMu100_v16, process.HLT_DiPFJetAve40_v30, process.HLT_DiPFJetAve60_v30, process.HLT_DiPFJetAve80_v30, process.HLT_DiPFJetAve140_v29, process.HLT_DiPFJetAve200_v29, process.HLT_DiPFJetAve260_v30, process.HLT_DiPFJetAve320_v30, process.HLT_DiPFJetAve400_v30, process.HLT_DiPFJetAve500_v30, process.HLT_DiPFJetAve60_HFJEC_v31, process.HLT_DiPFJetAve80_HFJEC_v33, process.HLT_DiPFJetAve100_HFJEC_v33, process.HLT_DiPFJetAve160_HFJEC_v32, process.HLT_DiPFJetAve220_HFJEC_v32, process.HLT_DiPFJetAve260_HFJEC_v15, process.HLT_DiPFJetAve300_HFJEC_v32, process.HLT_DiPFJetAve180_PPSMatch_Xi0p3_QuadJet_Max2ProtPerRP_v10, process.HLT_AK8PFJet40_v32, process.HLT_AK8PFJet60_v31, process.HLT_AK8PFJet80_v32, process.HLT_AK8PFJet140_v31, process.HLT_AK8PFJet200_v31, process.HLT_AK8PFJet260_v32, process.HLT_AK8PFJet320_v32, process.HLT_AK8PFJet400_v32, process.HLT_AK8PFJet450_v32, process.HLT_AK8PFJet500_v32, process.HLT_AK8PFJet550_v27, process.HLT_PFJet40_v37, process.HLT_PFJet60_v37, process.HLT_PFJet80_v37, process.HLT_PFJet110_v16, process.HLT_PFJet140_v35, process.HLT_PFJet200_v35, process.HLT_PFJet260_v36, process.HLT_PFJet320_v36, process.HLT_PFJet400_v36, process.HLT_PFJet450_v37, process.HLT_PFJet500_v37, process.HLT_PFJet550_v27, process.HLT_PFJetFwd40_v35, process.HLT_PFJetFwd60_v35, process.HLT_PFJetFwd80_v34, process.HLT_PFJetFwd140_v34, process.HLT_PFJetFwd200_v34, process.HLT_PFJetFwd260_v35, process.HLT_PFJetFwd320_v35, process.HLT_PFJetFwd400_v35, process.HLT_PFJetFwd450_v35, process.HLT_PFJetFwd500_v35, process.HLT_AK8PFJetFwd40_v31, process.HLT_AK8PFJetFwd60_v30, process.HLT_AK8PFJetFwd80_v30, process.HLT_AK8PFJetFwd140_v30, process.HLT_AK8PFJetFwd200_v30, process.HLT_AK8PFJetFwd260_v31, process.HLT_AK8PFJetFwd320_v31, process.HLT_AK8PFJetFwd400_v31, process.HLT_AK8PFJetFwd450_v31, process.HLT_AK8PFJetFwd500_v31, process.HLT_PFHT180_v33, process.HLT_PFHT250_v33, process.HLT_PFHT370_v33, process.HLT_PFHT430_v33, process.HLT_PFHT510_v33, process.HLT_PFHT590_v33, process.HLT_PFHT680_v33, process.HLT_PFHT780_v33, process.HLT_PFHT890_v33, process.HLT_PFHT1050_v34, process.HLT_PFHT500_PFMET100_PFMHT100_IDTight_v28, process.HLT_PFHT500_PFMET110_PFMHT110_IDTight_v28, process.HLT_PFHT700_PFMET85_PFMHT85_IDTight_v28, process.HLT_PFHT800_PFMET75_PFMHT75_IDTight_v28, process.HLT_PFMET120_PFMHT120_IDTight_v36, process.HLT_PFMET130_PFMHT130_IDTight_v36, process.HLT_PFMET140_PFMHT140_IDTight_v36, process.HLT_PFMET120_PFMHT120_IDTight_PFHT60_v25, process.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_PFHT60_v25, process.HLT_PFMETTypeOne140_PFMHT140_IDTight_v27, process.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_v36, process.HLT_PFMETNoMu130_PFMHTNoMu130_IDTight_v35, process.HLT_PFMETNoMu140_PFMHTNoMu140_IDTight_v35, process.HLT_PFMETNoMu110_PFMHTNoMu110_IDTight_FilterHF_v16, process.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_FilterHF_v16, process.HLT_PFMETNoMu130_PFMHTNoMu130_IDTight_FilterHF_v16, process.HLT_PFMETNoMu140_PFMHTNoMu140_IDTight_FilterHF_v16, process.HLT_L1ETMHadSeeds_v11, process.HLT_CaloMHT90_v16, process.HLT_CaloMET90_NotCleaned_v16, process.HLT_CaloMET350_NotCleaned_v16, process.HLT_PFMET200_NotCleaned_v25, process.HLT_PFMET250_NotCleaned_v25, process.HLT_PFMET300_NotCleaned_v25, process.HLT_PFMET200_BeamHaloCleaned_v25, process.HLT_PFMETTypeOne200_BeamHaloCleaned_v25, process.HLT_MET105_IsoTrk50_v23, process.HLT_MET120_IsoTrk50_v23, process.HLT_Mu12eta2p3_v17, process.HLT_Mu12eta2p3_PFJet40_v17, process.HLT_Mu12_DoublePFJets40_PNetBTag_0p11_v10, process.HLT_Mu12_DoublePFJets100_PNetBTag_0p11_v10, process.HLT_Mu12_DoublePFJets200_PNetBTag_0p11_v10, process.HLT_Mu12_DoublePFJets350_PNetBTag_0p11_v10, process.HLT_Mu12_DoublePFJets40MaxDeta1p6_PNet2BTag_0p11_v10, process.HLT_Mu12_DoublePFJets54MaxDeta1p6_PNet2BTag_0p11_v10, process.HLT_DoublePFJets40_PNetBTag_0p11_v10, process.HLT_DoublePFJets100_PNetBTag_0p11_v10, process.HLT_DoublePFJets200_PNetBTag_0p11_v10, process.HLT_DoublePFJets350_PNetBTag_0p11_v10, process.HLT_DoublePFJets116MaxDeta1p6_PNet2BTag_0p11_v10, process.HLT_DoublePFJets128MaxDeta1p6_PNet2BTag_0p11_v10, process.HLT_Photon300_NoHE_v24, process.HLT_Mu8_TrkIsoVVL_v28, process.HLT_Mu8_DiEle12_CaloIdL_TrackIdL_DZ_v34, process.HLT_Mu8_DiEle12_CaloIdL_TrackIdL_v34, process.HLT_Mu8_Ele8_CaloIdM_TrackIdM_Mass8_PFHT350_DZ_v35, process.HLT_Mu8_Ele8_CaloIdM_TrackIdM_Mass8_PFHT350_v35, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_v29, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_v17, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v27, process.HLT_Mu17_TrkIsoVVL_v29, process.HLT_Mu19_TrkIsoVVL_v20, process.HLT_BTagMu_AK4DiJet20_Mu5_v29, process.HLT_BTagMu_AK4DiJet40_Mu5_v29, process.HLT_BTagMu_AK4DiJet70_Mu5_v29, process.HLT_BTagMu_AK4DiJet110_Mu5_v29, process.HLT_BTagMu_AK4DiJet170_Mu5_v28, process.HLT_BTagMu_AK4Jet300_Mu5_v28, process.HLT_BTagMu_AK8DiJet170_Mu5_v25, process.HLT_BTagMu_AK8Jet170_DoubleMu5_v18, process.HLT_BTagMu_AK8Jet300_Mu5_v28, process.HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v33, process.HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_v33, process.HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v31, process.HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v23, process.HLT_Mu12_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v23, process.HLT_Mu12_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_v31, process.HLT_Mu12_IsoVVL_PFHT150_PNetBTag0p53_v9, process.HLT_Photon33_v16, process.HLT_Photon50_v24, process.HLT_Photon75_v24, process.HLT_Photon90_v24, process.HLT_Photon120_v24, process.HLT_Photon150_v18, process.HLT_Photon175_v26, process.HLT_Photon200_v25, process.HLT_Photon45EB_v4, process.HLT_Photon40EB_v4, process.HLT_Photon50EB_v5, process.HLT_Photon30EB_TightID_TightIso_v15, process.HLT_Photon40EB_TightID_TightIso_v6, process.HLT_Photon45EB_TightID_TightIso_v6, process.HLT_Photon50EB_TightID_TightIso_PFJet30_v10, process.HLT_Photon50EB_TightID_TightIso_CaloJet30_v6, process.HLT_Photon50EB_TightID_TightIso_AK8PFJet30_v9, process.HLT_Photon50EB_TightID_TightIso_AK8CaloJet30_v6, process.HLT_Photon50EB_TightID_TightIso_v11, process.HLT_Photon55EB_TightID_TightIso_v7, process.HLT_Photon75EB_TightID_TightIso_v11, process.HLT_Photon90EB_TightID_TightIso_v11, process.HLT_Photon110EB_TightID_TightIso_v15, process.HLT_Photon110EB_TightID_TightIso_PFJet30_v10, process.HLT_Photon110EB_TightID_TightIso_CaloJet30_v6, process.HLT_Photon110EB_TightID_TightIso_AK8PFJet30_v9, process.HLT_Photon110EB_TightID_TightIso_AK8CaloJet30_v6, process.HLT_Photon100EBHE10_v13, process.HLT_Photon50_R9Id90_HE10_IsoM_v27, process.HLT_Photon75_R9Id90_HE10_IsoM_v27, process.HLT_Photon90_R9Id90_HE10_IsoM_v27, process.HLT_Photon120_R9Id90_HE10_IsoM_v27, process.HLT_Photon165_R9Id90_HE10_IsoM_v28, process.HLT_Diphoton30_22_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass90_v26, process.HLT_Diphoton30_22_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass95_v26, process.HLT_Photon35_TwoProngs35_v17, process.HLT_IsoMu24_TwoProngs35_v17, process.HLT_Dimuon0_Jpsi_L1_NoOS_v23, process.HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23, process.HLT_Dimuon0_Jpsi_v24, process.HLT_Dimuon0_Jpsi_NoVertexing_v24, process.HLT_Dimuon0_Jpsi_L1_4R_0er1p5R_v23, process.HLT_Dimuon0_Jpsi_NoVertexing_L1_4R_0er1p5R_v23, process.HLT_Dimuon0_Jpsi3p5_Muon2_v21, process.HLT_Dimuon0_Upsilon_L1_4p5_v25, process.HLT_Dimuon0_Upsilon_L1_4p5er2p0_v25, process.HLT_Dimuon0_Upsilon_L1_4p5er2p0M_v23, process.HLT_Dimuon0_Upsilon_NoVertexing_v23, process.HLT_Dimuon0_LowMass_L1_0er1p5_v24, process.HLT_Dimuon0_LowMass_v24, process.HLT_Dimuon0_LowMass_L1_4_v24, process.HLT_Dimuon0_LowMass_L1_TM530_v22, process.HLT_Dimuon0_Upsilon_Muon_NoL1Mass_v22, process.HLT_Dimuon0_Upsilon_v2, process.HLT_TripleMu_5_3_3_Mass3p8_DZ_v24, process.HLT_TripleMu_10_5_5_DZ_v26, process.HLT_TripleMu_12_10_5_v26, process.HLT_Tau3Mu_Mu7_Mu1_TkMu1_Tau15_v20, process.HLT_Tau3Mu_Mu7_Mu1_TkMu1_Tau15_Charge1_v20, process.HLT_Tau3Mu_Mu7_Mu1_TkMu1_IsoTau15_v20, process.HLT_Tau3Mu_Mu7_Mu1_TkMu1_IsoTau15_Charge1_v20, process.HLT_DoubleMu3_DZ_PFMET50_PFMHT60_v26, process.HLT_DoubleMu3_DZ_PFMET70_PFMHT70_v26, process.HLT_DoubleMu3_DZ_PFMET90_PFMHT90_v26, process.HLT_DoubleMu3_Trk_Tau3mu_NoL1Mass_v22, process.HLT_DoubleMu4_3_LowMass_SS_v10, process.HLT_DoubleMu4_Jpsi_Displaced_v23, process.HLT_DoubleMu4_Jpsi_NoVertexing_v23, process.HLT_DoubleMu4_JpsiTrkTrk_Displaced_v23, process.HLT_DoubleMu4_JpsiTrk_Bc_v16, process.HLT_DoubleMu43NoFiltersNoVtx_v17, process.HLT_DoubleMu48NoFiltersNoVtx_v17, process.HLT_Mu43NoFiltersNoVtx_Photon43_CaloIdL_v18, process.HLT_Mu48NoFiltersNoVtx_Photon48_CaloIdL_v18, process.HLT_Mu38NoFiltersNoVtxDisplaced_Photon38_CaloIdL_v14, process.HLT_Mu43NoFiltersNoVtxDisplaced_Photon43_CaloIdL_v14, process.HLT_Ele28_HighEta_SC20_Mass55_v27, process.HLT_Ele15_IsoVVVL_PFHT450_PFMET50_v32, process.HLT_Ele15_IsoVVVL_PFHT450_v32, process.HLT_Ele50_IsoVVVL_PFHT450_v32, process.HLT_Ele15_IsoVVVL_PFHT600_v36, process.HLT_Mu15_IsoVVVL_PFHT450_PFMET50_v31, process.HLT_Mu15_IsoVVVL_PFHT450_v31, process.HLT_Mu50_IsoVVVL_PFHT450_v31, process.HLT_Mu15_IsoVVVL_PFHT600_v35, process.HLT_Mu3er1p5_PFJet100er2p5_PFMET80_PFMHT80_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMET90_PFMHT90_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMET100_PFMHT100_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu80_PFMHTNoMu80_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu90_PFMHTNoMu90_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu100_PFMHTNoMu100_IDTight_v18, process.HLT_Dimuon10_Upsilon_y1p4_v17, process.HLT_Dimuon12_Upsilon_y1p4_v18, process.HLT_Dimuon14_Phi_Barrel_Seagulls_v23, process.HLT_Dimuon25_Jpsi_v30, process.HLT_Dimuon14_PsiPrime_v29, process.HLT_Dimuon14_PsiPrime_noCorrL1_v21, process.HLT_Dimuon18_PsiPrime_v30, process.HLT_Dimuon18_PsiPrime_noCorrL1_v22, process.HLT_Dimuon24_Upsilon_noCorrL1_v22, process.HLT_Dimuon24_Phi_noCorrL1_v22, process.HLT_Dimuon25_Jpsi_noCorrL1_v22, process.HLT_DiMu4_Ele9_CaloIdL_TrackIdL_DZ_Mass3p8_v33, process.HLT_DiMu9_Ele9_CaloIdL_TrackIdL_DZ_v33, process.HLT_DiMu9_Ele9_CaloIdL_TrackIdL_v33, process.HLT_DoubleIsoMu20_eta2p1_v23, process.HLT_TrkMu12_DoubleTrkMu5NoFiltersNoVtx_v21, process.HLT_Mu8_v28, process.HLT_Mu17_v29, process.HLT_Mu19_v20, process.HLT_Mu17_Photon30_IsoCaloId_v22, process.HLT_Ele8_CaloIdL_TrackIdL_IsoVL_PFJet30_v32, process.HLT_Ele12_CaloIdL_TrackIdL_IsoVL_PFJet30_v34, process.HLT_Ele14_eta2p5_IsoVVVL_Gsf_PFHT200_PNetBTag0p53_v9, process.HLT_Ele23_CaloIdL_TrackIdL_IsoVL_PFJet30_v34, process.HLT_Ele8_CaloIdM_TrackIdM_PFJet30_v34, process.HLT_Ele17_CaloIdM_TrackIdM_PFJet30_v32, process.HLT_Ele23_CaloIdM_TrackIdM_PFJet30_v34, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_PFJet165_v34, process.HLT_Ele115_CaloIdVT_GsfTrkIdT_v28, process.HLT_Ele135_CaloIdVT_GsfTrkIdT_v21, process.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_v25, process.HLT_PFHT400_SixPFJet32_v25, process.HLT_PFHT400_SixPFJet32_PNet2BTagMean0p50_v13, process.HLT_PFHT450_SixPFJet36_v24, process.HLT_PFHT450_SixPFJet36_PNetBTag0p35_v13, process.HLT_PFHT400_FivePFJet_120_120_60_30_30_v10, process.HLT_PFHT350_v35, process.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT350_v14, process.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT380_v14, process.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT400_v14, process.HLT_ECALHT800_v22, process.HLT_DiSC30_18_EIso_AND_HE_Mass70_v25, process.HLT_Photon20_HoverELoose_v21, process.HLT_Photon30_HoverELoose_v21, process.HLT_L1_CDC_SingleMu_3_er1p2_TOP120_DPHI2p618_3p142_v10, process.HLT_CDC_L2cosmic_10_er1p0_v11, process.HLT_CDC_L2cosmic_5p5_er1p0_v11, process.HLT_Photon60_R9Id90_HE10_IsoM_EBOnly_PFJetsMJJ300DEta3_v13, process.HLT_Photon75_R9Id90_HE10_IsoM_EBOnly_PFJetsMJJ300DEta3_v21, process.HLT_Mu18_Mu9_SameSign_v20, process.HLT_DoubleMu2_Jpsi_DoubleTrk1_Phi1p05_v22, process.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_v26, process.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_Mass2p0_v10, process.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_Mass2p0_noDCA_v10, process.HLT_TripleMu_5_3_3_Mass3p8_DCA_v19, process.HLT_QuadPFJet103_88_75_15_v21, process.HLT_QuadPFJet105_88_76_15_v21, process.HLT_QuadPFJet111_90_80_15_v21, process.HLT_Diphoton30_18_R9IdL_AND_HE_AND_IsoCaloId_v14, process.HLT_Diphoton30_18_R9IdL_AND_HE_AND_IsoCaloId_Mass55_v14, process.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Tight_eta2p3_CrossL1_v11, process.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Medium_eta2p3_CrossL1_v11, process.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Loose_eta2p3_CrossL1_v11, process.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_PNet3BTag_4p3_v9, process.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_PNet3BTag_2p0_v9, process.HLT_PFHT400_FivePFJet_120_120_60_30_30_PNet2BTag_5p6_v10, process.HLT_PFHT400_FivePFJet_120_120_60_30_30_PNet2BTag_4p3_v10, process.HLT_QuadPFJet103_88_75_15_PNetBTag_0p4_VBF2_v10, process.HLT_QuadPFJet103_88_75_15_PNet2BTag_0p4_0p12_VBF1_v10, process.HLT_QuadPFJet105_88_76_15_PNetBTag_0p4_VBF2_v10, process.HLT_QuadPFJet105_88_76_15_PNet2BTag_0p4_0p12_VBF1_v10, process.HLT_QuadPFJet111_90_80_15_PNetBTag_0p4_VBF2_v10, process.HLT_QuadPFJet111_90_80_15_PNet2BTag_0p4_0p12_VBF1_v10, process.HLT_PFHT250_QuadPFJet25_v10, process.HLT_PFHT250_QuadPFJet25_PNet2BTagMean0p55_v10, process.HLT_PFHT250_QuadPFJet25_PNet1BTag0p20_PNet1Tauh0p50_v10, process.HLT_PFHT250_QuadPFJet30_PNet2BTagMean0p55_v10, process.HLT_PFHT250_QuadPFJet30_PNet1BTag0p20_PNet1Tauh0p50_v10, process.HLT_PFHT280_QuadPFJet30_PNet1BTag0p20_PNet1Tauh0p50_v10, process.HLT_PFHT280_QuadPFJet30_v13, process.HLT_PFHT280_QuadPFJet30_PNet2BTagMean0p55_v13, process.HLT_PFHT280_QuadPFJet30_PNet2BTagMean0p60_v13, process.HLT_PFHT280_QuadPFJet35_PNet2BTagMean0p60_v13, process.HLT_PFHT340_QuadPFJet70_50_40_40_PNet2BTagMean0p70_v14, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_v13, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_QuadPFJet30_v13, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_QuadPFJet30_PNet2BTagMean0p55_v13, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PNet2BTagMean0p50_v13, process.HLT_QuadPFJet100_88_70_30_v14, process.HLT_QuadPFJet105_88_75_30_v13, process.HLT_QuadPFJet111_90_80_30_v13, process.HLT_QuadPFJet100_88_70_30_PNet1CvsAll0p5_VBF3Tight_v14, process.HLT_QuadPFJet105_88_75_30_PNet1CvsAll0p5_VBF3Tight_v14, process.HLT_QuadPFJet111_90_80_30_PNet1CvsAll0p6_VBF3Tight_v14, process.HLT_AK8PFJet220_SoftDropMass40_v17, process.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p50_v13, process.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p53_v13, process.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p55_v13, process.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p60_v13, process.HLT_AK8PFJet230_SoftDropMass40_v17, process.HLT_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, process.HLT_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, process.HLT_AK8PFJet230_SoftDropMass40_PNetTauTau0p03_v13, process.HLT_AK8PFJet230_SoftDropMass40_PNetTauTau0p05_v13, process.HLT_AK8PFJet250_SoftDropMass40_PNetBB0p06_v13, process.HLT_AK8PFJet250_SoftDropMass40_PNetBB0p10_v13, process.HLT_AK8PFJet250_SoftDropMass40_PNetTauTau0p03_v13, process.HLT_AK8PFJet250_SoftDropMass40_PNetTauTau0p05_v13, process.HLT_AK8PFJet275_SoftDropMass40_PNetBB0p06_v13, process.HLT_AK8PFJet275_SoftDropMass40_PNetBB0p10_v13, process.HLT_AK8PFJet275_SoftDropMass40_PNetTauTau0p03_v13, process.HLT_AK8PFJet275_SoftDropMass40_PNetTauTau0p05_v13, process.HLT_AK8PFJet275_Nch45_v10, process.HLT_AK8PFJet275_Nch40_v10, process.HLT_IsoMu50_AK8PFJet220_SoftDropMass40_v16, process.HLT_IsoMu50_AK8PFJet220_SoftDropMass40_PNetBB0p06_v13, process.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_v16, process.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, process.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet220_SoftDropMass40_v16, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet220_SoftDropMass40_PNetBB0p06_v13, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_v16, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_DoubleAK4PFJet60_30_v14, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_DoubleAK4PFJet60_30_PNet2BTagMean0p50_v14, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_v10, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_v10, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_PNet2BTagMean0p55_v10, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_PNet1BTag0p20_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Medium_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Tight_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_PFJet60_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_PFJet75_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Tight_eta2p3_CrossL1_ETau_Monitoring_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Medium_eta2p3_CrossL1_ETau_Monitoring_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Loose_eta2p3_CrossL1_ETau_Monitoring_v10, process.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Tight_eta2p3_CrossL1_v10, process.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Medium_eta2p3_CrossL1_v10, process.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Loose_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet20_eta2p2_SingleL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet45_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PFHT250_v10, process.HLT_IsoMu24_eta2p1_PFHT250_QuadPFJet25_v10, process.HLT_IsoMu24_eta2p1_PFHT250_QuadPFJet25_PNet1Tauh0p50_v10, process.HLT_IsoMu24_eta2p1_SinglePFJet25_PNet1Tauh0p50_v10, process.HLT_DoublePNetTauhPFJet30_Medium_L2NN_eta2p3_v10, process.HLT_DoublePNetTauhPFJet30_Tight_L2NN_eta2p3_v10, process.HLT_DoublePNetTauhPFJet26_L2NN_eta2p3_PFJet60_v10, process.HLT_DoublePNetTauhPFJet26_L2NN_eta2p3_PFJet75_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Loose_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Medium_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Tight_L2NN_eta2p3_CrossL1_v10, process.HLT_SinglePNetTauhPFJet130_Loose_L2NN_eta2p3_v10, process.HLT_SinglePNetTauhPFJet130_Medium_L2NN_eta2p3_v10, process.HLT_SinglePNetTauhPFJet130_Tight_L2NN_eta2p3_v10, process.HLT_DoubleL2Mu10NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v16, process.HLT_DoubleL2Mu12NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, process.HLT_DoubleL2Mu14NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, process.HLT_DoubleL3Mu16_10NoVtx_DxyMin0p01cm_v14, process.HLT_DoubleL3Mu18_10NoVtx_DxyMin0p01cm_v13, process.HLT_DoubleL3Mu20_10NoVtx_DxyMin0p01cm_v13, process.HLT_L2Mu10NoVtx_2Cha_v10, process.HLT_L2Mu10NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, process.HLT_L3Mu10NoVtx_v13, process.HLT_L3Mu10NoVtx_DxyMin0p01cm_v13, process.HLT_DoubleL2Mu_L3Mu16NoVtx_VetoL3Mu0DxyMax0p1cm_v13, process.HLT_DoubleL2Mu_L3Mu18NoVtx_VetoL3Mu0DxyMax0p1cm_v13, process.HLT_DoubleL2Mu10NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, process.HLT_DoubleL2Mu12NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, process.HLT_L2Mu10NoVtx_2Cha_CosmicSeed_v10, process.HLT_L2Mu10NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, process.HLT_DoubleL3dTksMu16_10NoVtx_DxyMin0p01cm_v14, process.HLT_L2Mu50NoVtx_3Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v8, process.HLT_L2Mu50NoVtx_3Cha_VetoL3Mu0DxyMax1cm_v8, process.HLT_L3Mu30NoVtx_DxyMin0p01cm_v6, process.HLT_L3Mu50NoVtx_DxyMin0p01cm_v6, process.HLT_L3dTksMu10_NoVtx_DxyMin0p01cm_v14, process.HLT_Mu20NoFiltersNoVtxDisplaced_Photon20_CaloCustomId_v14, process.HLT_DisplacedMu24_MediumChargedIsoDisplacedPFTauHPS24_v12, process.HLT_Photon34_R9Id90_CaloIdL_IsoL_DisplacedIdL_MediumChargedIsoDisplacedPFTauHPS34_v12, process.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS32_Trk1_eta2p1_v17, process.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS36_Trk1_eta2p1_v12, process.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS32_Trk1_eta2p1_noDxy_v12, process.HLT_IsoMu27_MediumChargedIsoDisplacedPFTauHPS24_eta2p1_SingleL1_v12, process.HLT_HT350_DelayedJet40_SingleDelay1p5To3p5nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay1p6To3p5nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay1p75To3p5nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay3nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay3p25nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay3p5nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay0p5nsInclusive_v11, process.HLT_HT430_DelayedJet40_SingleDelay1nsInclusive_v11, process.HLT_HT430_DelayedJet40_SingleDelay1To1p5nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay1p1To1p6nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay1p25To1p75nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay1p5nsInclusive_v11, process.HLT_HT430_DelayedJet40_SingleDelay2nsInclusive_v13, process.HLT_HT430_DelayedJet40_SingleDelay2p25nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay2p5nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay0p5nsTrackless_v12, process.HLT_HT430_DelayedJet40_SingleDelay1nsTrackless_v14, process.HLT_HT430_DelayedJet40_SingleDelay1p25nsTrackless_v10, process.HLT_HT430_DelayedJet40_SingleDelay1p5nsTrackless_v10, process.HLT_HT430_DelayedJet40_DoubleDelay0p5nsInclusive_v12, process.HLT_HT430_DelayedJet40_DoubleDelay1nsInclusive_v13, process.HLT_HT430_DelayedJet40_DoubleDelay1p25nsInclusive_v9, process.HLT_HT430_DelayedJet40_DoubleDelay1p5nsInclusive_v9, process.HLT_HT430_DelayedJet40_DoubleDelay0p5nsTrackless_v14, process.HLT_HT430_DelayedJet40_DoubleDelay0p75nsTrackless_v10, process.HLT_HT430_DelayedJet40_DoubleDelay1nsTrackless_v10, process.HLT_L1Tau_DelayedJet40_SingleDelay2p5To4nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay2p6To4nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay2p75To4nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay3p5nsInclusive_v11, process.HLT_L1Tau_DelayedJet40_SingleDelay3p75nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay4nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay2p5nsTrackless_v12, process.HLT_L1Tau_DelayedJet40_SingleDelay2p75nsTrackless_v10, process.HLT_L1Tau_DelayedJet40_SingleDelay3nsTrackless_v10, process.HLT_L1Tau_DelayedJet40_DoubleDelay0p75nsInclusive_v11, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p25nsInclusive_v11, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p5nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p75nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_DoubleDelay0p5nsTrackless_v12, process.HLT_L1Tau_DelayedJet40_DoubleDelay1nsTrackless_v12, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p25nsTrackless_v10, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p5nsTrackless_v10, process.HLT_L1Mu6HT240_v10, process.HLT_Mu6HT240_DisplacedDijet30_Inclusive1PtrkShortSig5_DisplacedLoose_v14, process.HLT_Mu6HT240_DisplacedDijet35_Inclusive0PtrkShortSig5_v14, process.HLT_Mu6HT240_DisplacedDijet35_Inclusive1PtrkShortSig5_DisplacedLoose_v14, process.HLT_Mu6HT240_DisplacedDijet40_Inclusive0PtrkShortSig5_v14, process.HLT_Mu6HT240_DisplacedDijet40_Inclusive1PtrkShortSig5_DisplacedLoose_v14, process.HLT_Mu6HT240_DisplacedDijet45_Inclusive0PtrkShortSig5_v14, process.HLT_Mu6HT240_DisplacedDijet50_Inclusive0PtrkShortSig5_v14, process.HLT_HT350_v9, process.HLT_HT425_v21, process.HLT_HT360_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, process.HLT_HT360_DisplacedDijet45_Inclusive1PtrkShortSig5_v10, process.HLT_HT390_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, process.HLT_HT390_DisplacedDijet45_Inclusive1PtrkShortSig5_v10, process.HLT_HT390eta2p0_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, process.HLT_HT430_DisplacedDijet40_Inclusive1PtrkShortSig5_v14, process.HLT_HT400_DisplacedDijet40_DisplacedTrack_v26, process.HLT_HT430_DisplacedDijet40_DisplacedTrack_v26, process.HLT_HT550_DisplacedDijet60_Inclusive_v26, process.HLT_HT650_DisplacedDijet60_Inclusive_v26, process.HLT_CaloMET60_DTCluster50_v13, process.HLT_CaloMET60_DTClusterNoMB1S50_v13, process.HLT_L1MET_DTCluster50_v13, process.HLT_L1MET_DTClusterNoMB1S50_v13, process.HLT_CscCluster_Loose_v11, process.HLT_CscCluster_Medium_v11, process.HLT_CscCluster_Tight_v11, process.HLT_CscCluster50_Photon20Unseeded_v5, process.HLT_CscCluster50_Photon30Unseeded_v5, process.HLT_CscCluster100_Ele5_v7, process.HLT_CscCluster100_Mu5_v10, process.HLT_CscCluster100_PNetTauhPFJet10_Loose_v10, process.HLT_CscCluster150_DisplacedSingleJet30_Inclusive1PtrkShortSig5_v3, process.HLT_CscCluster150_DisplacedSingleJet35_Inclusive1PtrkShortSig5_v3, process.HLT_CscCluster150_DisplacedSingleJet40_Inclusive1PtrkShortSig5_v3, process.HLT_DoubleCscCluster75_v8, process.HLT_IsoTrk200_L1SingleMuShower_v8, process.HLT_IsoTrk400_L1SingleMuShower_v8, process.HLT_DoubleCscCluster100_v8, process.HLT_L1CSCShower_DTCluster50_v11, process.HLT_L1CSCShower_DTCluster75_v11, process.HLT_PFMET105_IsoTrk50_v17, process.HLT_L1SingleLLPJet_v8, process.HLT_L1SingleMuShower_v1, process.HLT_HT170_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, process.HLT_HT200_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, process.HLT_HT200_L1SingleLLPJet_DisplacedDijet60_DisplacedTrack_v14, process.HLT_HT270_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, process.HLT_HT200_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v14, process.HLT_HT240_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11, process.HLT_HT280_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11, process.HLT_HT320_L1SingleLLPJet_DisplacedDijet60_Inclusive_v14, process.HLT_HT420_L1SingleLLPJet_DisplacedDijet60_Inclusive_v14, process.HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay1nsTrackless_v14, process.HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay2nsInclusive_v14, process.HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay0p5nsTrackless_v14, process.HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay1nsInclusive_v14, process.HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p7_v10, process.HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p8_v10, process.HLT_DiPhoton10Time1ns_v11, process.HLT_DiPhoton10Time1p2ns_v11, process.HLT_DiPhoton10Time1p4ns_v11, process.HLT_DiPhoton10Time1p6ns_v11, process.HLT_DiPhoton10Time1p8ns_v11, process.HLT_DiPhoton10Time2ns_v11, process.HLT_DiPhoton10_CaloIdL_v11, process.HLT_DiphotonMVA14p25_Low_Mass60_v1, process.HLT_DiphotonMVA14p25_Medium_Mass60_v1, process.HLT_DiphotonMVA14p25_High_Mass60_v1, process.HLT_DiphotonMVA14p25_TightLow_Mass60_v1, process.HLT_DiphotonMVA14p25_TightMedium_Mass60_v1, process.HLT_DiphotonMVA14p25_TightHigh_Mass60_v1, process.HLT_Diphoton15_10_EBEB_TightID_ECALTrackIsoDr0p2_v3, process.HLT_Diphoton15_12_EBEB_TightID_ECALTrackIsoDr0p2_v3, process.HLT_Diphoton15_10_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v3, process.HLT_Diphoton15_12_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v3, process.HLT_Dielectron12_5_EBEB_TightID_ECALTrackIsoDr0p2_v4, process.HLT_Dielectron12_5_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v4, process.HLT_DoubleEle6p5_eta1p22_mMax6_v13, process.HLT_DoubleEle8_eta1p22_mMax6_v13, process.HLT_DoubleEle10_eta1p22_mMax6_v13, process.HLT_SingleEle8_v12, process.HLT_SingleEle8_SingleEGL1_v12, process.HLT_Diphoton20_14_eta1p5_R9IdL_AND_HE_AND_IsoTCaloIdT_v13, process.HLT_Diphoton20_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, process.HLT_Diphoton22_14_eta1p5_R9IdL_AND_HE_AND_IsoTCaloIdT_v13, process.HLT_Diphoton22_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, process.HLT_Diphoton24_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, process.HLT_Diphoton24_16_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, process.HLT_Mu50_L1SingleMuShower_v15, process.HLT_IsoMu24_OneProng32_v13, process.HLT_Photon32_OneProng32_M50To105_v14, process.HLT_VBF_DiPFJet125_45_Mjj1050_v12, process.HLT_VBF_DiPFJet125_45_Mjj1150_v4, process.HLT_VBF_DiPFJet125_45_Mjj1250_v4, process.HLT_VBF_DiPFJet75_45_Mjj800_DiPFJet60_v10, process.HLT_VBF_DiPFJet75_45_Mjj900_DiPFJet60_v4, process.HLT_VBF_DiPFJet75_45_Mjj1000_DiPFJet60_v4, process.HLT_VBF_DiPFJet80_45_Mjj650_PFMETNoMu85_v10, process.HLT_VBF_DiPFJet80_45_Mjj750_PFMETNoMu85_v10, process.HLT_VBF_DiPFJet80_45_Mjj850_PFMETNoMu85_v4, process.HLT_VBF_DiPFJet95_45_Mjj750_Mu3_TrkIsoVVL_v10, process.HLT_VBF_DiPFJet95_45_Mjj850_Mu3_TrkIsoVVL_v10, process.HLT_VBF_DiPFJet95_45_Mjj950_Mu3_TrkIsoVVL_v4, process.HLT_VBF_DiPFJet50_Mjj650_Photon22_v10, process.HLT_VBF_DiPFJet50_Mjj750_Photon22_v10, process.HLT_VBF_DiPFJet50_Mjj850_Photon22_v4, process.HLT_VBF_DiPFJet50_Mjj600_Ele22_eta2p1_WPTight_Gsf_v11, process.HLT_VBF_DiPFJet50_Mjj700_Ele22_eta2p1_WPTight_Gsf_v5, process.HLT_VBF_DiPFJet50_Mjj800_Ele22_eta2p1_WPTight_Gsf_v5, process.HLT_VBF_DiPFJet115_40_Mjj850_DoublePNetTauhPFJet20_eta2p3_v4, process.HLT_VBF_DiPFJet115_40_Mjj1000_DoublePNetTauhPFJet20_eta2p3_v4, process.HLT_VBF_DiPFJet115_40_Mjj1100_DoublePNetTauhPFJet20_eta2p3_v4, process.HLT_VBF_DiPFJet115_40_Mjj1200_DoublePNetTauhPFJet20_eta2p3_v4, process.HLT_VBF_DiPFJet45_Mjj650_PNetTauhPFJet45_L2NN_eta2p3_v10, process.HLT_VBF_DiPFJet45_Mjj750_PNetTauhPFJet45_L2NN_eta2p3_v10, process.HLT_VBF_DiPFJet45_Mjj850_PNetTauhPFJet45_L2NN_eta2p3_v4, process.HLT_L1HT200_QuadPFJet20_PNet1BTag0p50_PNet1Tauh0p50_v4, process.HLT_L1HT200_QuadPFJet25_PNet1BTag0p50_PNet1Tauh0p50_v4, process.HLT_IsoMu24_eta2p1_L1HT200_v4, process.HLT_IsoMu24_eta2p1_L1HT200_QuadPFJet25_v4, process.HLT_IsoMu24_eta2p1_L1HT200_QuadPFJet25_PNet1Tauh0p50_v4, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_v4, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet20_v4, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet25_v4, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet25_PNet1BTag0p50_v4, process.HLT_PFJet200_TimeLtNeg2p5ns_v14, process.HLT_PFJet200_TimeGt2p5ns_v14, process.HLT_Photon50_TimeLtNeg2p5ns_v8, process.HLT_Photon50_TimeGt2p5ns_v8, process.HLT_PPSMaxTracksPerArm1_v10, process.HLT_PPSMaxTracksPerRP4_v10, process.HLT_PPSRandom_v1, process.HLT_TestData_v1, process.MC_ReducedIterativeTracking_v26, process.MC_AK4CaloJets_v21, process.MC_AK4CaloJetsFromPV_v21, process.MC_CaloHT_v20, process.MC_AK8CaloHT_v20, process.MC_CaloMHT_v20, process.MC_AK4PFJets_v33, process.MC_PFHT_v32, process.MC_AK8PFJets_v33, process.MC_AK8PFHT_v32, process.MC_CaloMET_v20, process.MC_CaloMET_JetIdCleaned_v21, process.MC_PFMET_v33, process.MC_PFMHT_v32, process.MC_AK4PFJetPNet_v9, process.MC_AK8PFJetPNet_v9, process.MC_Egamma_Open_v12, process.MC_Egamma_Open_Unseeded_v12, process.MC_Ele5_WPTight_Gsf_v23, process.MC_Ele15_Ele10_CaloIdL_TrackIdL_IsoVL_DZ_v29, process.MC_Diphoton10_10_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass10_v26, process.MC_DoubleEle5_CaloIdL_MW_v29, process.MC_IsoMu_v31, process.MC_DoubleMu_TrkIsoVVL_DZ_v27, process.MC_DoubleMuNoFiltersNoVtx_v20, process.MC_PFScouting_v10, process.HLT_L1AlwaysTrue_v1, process.HLT_L1AXOVVTight_v1, process.HLT_L1AXOVVVTight_v1, process.HLT_L1CICADA_VVTight_v1, process.HLT_L1CICADA_VVVTight_v1, process.HLT_L1CICADA_VVVVTight_v1, process.HLTriggerFinalPath, process.HLTAnalyzerEndpath, process.Dataset_AlCaHcalIsoTrk, process.Dataset_AlCaLowPtJet, process.Dataset_AlCaLumiPixelsCountsExpress, process.Dataset_AlCaLumiPixelsCountsPrompt, process.Dataset_AlCaP0, process.Dataset_AlCaPPSExpress, process.Dataset_AlCaPPSPrompt, process.Dataset_AlCaPhiSym, process.Dataset_BTagMu, process.Dataset_Commissioning, process.Dataset_Cosmics, process.Dataset_DQMGPUvsCPU, process.Dataset_DQMOnlineBeamspot, process.Dataset_DQMPPSRandom, process.Dataset_EGamma0, process.Dataset_EGamma1, process.Dataset_EGamma2, process.Dataset_EGamma3, process.Dataset_EcalLaser, process.Dataset_EphemeralHLTPhysics0, process.Dataset_EphemeralHLTPhysics1, process.Dataset_EphemeralHLTPhysics2, process.Dataset_EphemeralHLTPhysics3, process.Dataset_EphemeralHLTPhysics4, process.Dataset_EphemeralHLTPhysics5, process.Dataset_EphemeralHLTPhysics6, process.Dataset_EphemeralHLTPhysics7, process.Dataset_EphemeralZeroBias0, process.Dataset_EphemeralZeroBias1, process.Dataset_EphemeralZeroBias2, process.Dataset_EphemeralZeroBias3, process.Dataset_EphemeralZeroBias4, process.Dataset_EphemeralZeroBias5, process.Dataset_EphemeralZeroBias6, process.Dataset_EphemeralZeroBias7, process.Dataset_EventDisplay, process.Dataset_ExpressAlignment, process.Dataset_ExpressPhysics, process.Dataset_HLTMonitor, process.Dataset_HLTPhysics, process.Dataset_HcalNZS, process.Dataset_JetMET0, process.Dataset_JetMET1, process.Dataset_L1Accept, process.Dataset_MonteCarlo, process.Dataset_Muon0, process.Dataset_Muon1, process.Dataset_MuonEG, process.Dataset_NoBPTX, process.Dataset_OnlineMonitor, process.Dataset_ParkingDoubleMuonLowMass0, process.Dataset_ParkingDoubleMuonLowMass1, process.Dataset_ParkingDoubleMuonLowMass2, process.Dataset_ParkingDoubleMuonLowMass3, process.Dataset_ParkingDoubleMuonLowMass4, process.Dataset_ParkingDoubleMuonLowMass5, process.Dataset_ParkingDoubleMuonLowMass6, process.Dataset_ParkingDoubleMuonLowMass7, process.Dataset_ParkingHH0, process.Dataset_ParkingHH1, process.Dataset_ParkingLLP0, process.Dataset_ParkingLLP1, process.Dataset_ParkingSingleMuon0, process.Dataset_ParkingSingleMuon1, process.Dataset_ParkingSingleMuon2, process.Dataset_ParkingSingleMuon3, process.Dataset_ParkingSingleMuon4, process.Dataset_ParkingSingleMuon5, process.Dataset_ParkingSingleMuon6, process.Dataset_ParkingSingleMuon7, process.Dataset_ParkingSingleMuon8, process.Dataset_ParkingSingleMuon9, process.Dataset_ParkingSingleMuon10, process.Dataset_ParkingSingleMuon11, process.Dataset_ParkingSingleMuon12, process.Dataset_ParkingSingleMuon13, process.Dataset_ParkingSingleMuon14, process.Dataset_ParkingSingleMuon15, process.Dataset_ParkingVBF0, process.Dataset_ParkingVBF1, process.Dataset_ParkingVBF2, process.Dataset_ParkingVBF3, process.Dataset_ParkingVBF4, process.Dataset_ParkingVBF5, process.Dataset_ParkingVBF6, process.Dataset_ParkingVBF7, process.Dataset_ParkingAnomalyDetection, process.Dataset_RPCMonitor, process.Dataset_ScoutingPFMonitor, process.Dataset_ScoutingPF0, process.Dataset_ScoutingPF1, process.Dataset_Tau, process.Dataset_TestEnablesEcalHcal, process.Dataset_TestEnablesEcalHcalDQM, process.Dataset_ZeroBias, process.Dataset_TestDataRaw, process.Dataset_TestDataScouting, process.Dataset_EmittanceScan0, process.Dataset_EmittanceScan1, process.Dataset_EmittanceScan2, process.Dataset_EmittanceScan3, process.Dataset_EmittanceScan4, process.Dataset_EmittanceScan5, process.Dataset_DQMOnlineScouting, process.ALCAHcalIsoTrkOutput, process.ALCALowPtJetOutput, process.ALCALumiPixelsCountsExpressOutput, process.ALCALumiPixelsCountsPromptOutput, process.ALCAP0Output, process.ALCAPHISYMOutput, process.ALCAPPSExpressOutput, process.ALCAPPSPromptOutput, process.CalibrationOutput, process.DQMOutput, process.DQMCalibrationOutput, process.DQMEventDisplayOutput, process.DQMGPUvsCPUOutput, process.DQMOnlineBeamspotOutput, process.DQMOnlineScoutingOutput, process.DQMPPSRandomOutput, process.EcalCalibrationOutput, process.ExpressOutput, process.ExpressAlignmentOutput, process.HLTMonitorOutput, process.NanoDSTOutput, process.ParkingDoubleMuonLowMass0Output, process.ParkingDoubleMuonLowMass1Output, process.ParkingDoubleMuonLowMass2Output, process.ParkingDoubleMuonLowMass3Output, process.ParkingHHOutput, process.ParkingLLPOutput, process.ParkingSingleMuon0Output, process.ParkingSingleMuon1Output, process.ParkingSingleMuon10Output, process.ParkingSingleMuon11Output, process.ParkingSingleMuon12Output, process.ParkingSingleMuon13Output, process.ParkingSingleMuon14Output, process.ParkingSingleMuon15Output, process.ParkingSingleMuon2Output, process.ParkingSingleMuon3Output, process.ParkingSingleMuon4Output, process.ParkingSingleMuon5Output, process.ParkingSingleMuon6Output, process.ParkingSingleMuon7Output, process.ParkingSingleMuon8Output, process.ParkingSingleMuon9Output, process.ParkingVBF0Output, process.ParkingVBF1Output, process.ParkingVBF2Output, process.ParkingVBF3Output, process.ParkingAnomalyDetectionOutput, process.PhysicsCommissioningOutput, process.PhysicsBTagMuEGTauOutput, process.PhysicsEGamma0Output, process.PhysicsEGamma1Output, process.PhysicsEGamma2Output, process.PhysicsEGamma3Output, process.PhysicsHLTPhysics0Output, process.PhysicsHLTPhysics1Output, process.PhysicsHLTPhysics2Output, process.PhysicsHLTPhysics3Output, process.PhysicsJetMET0Output, process.PhysicsJetMET1Output, process.PhysicsMuon0Output, process.PhysicsMuon1Output, process.PhysicsScoutingPFMonitorOutput, process.PhysicsZeroBias0Output, process.PhysicsZeroBias1Output, process.PhysicsZeroBias2Output, process.PhysicsZeroBias3Output, process.PhysicsEmittanceScan0Output, process.PhysicsEmittanceScan1Output, process.PhysicsEmittanceScan2Output, process.RPCMONOutput, process.ScoutingPF0Output, process.ScoutingPF1Output, process.LocalTestDataRawOutput, process.LocalTestDataScoutingOutput, )) +process.schedule = cms.Schedule( *(process.HLTriggerFirstPath, process.Status_OnCPU, process.Status_OnGPU, process.AlCa_EcalPhiSym_v22, process.AlCa_EcalEtaEBonly_v27, process.AlCa_EcalEtaEEonly_v27, process.AlCa_EcalPi0EBonly_v27, process.AlCa_EcalPi0EEonly_v27, process.AlCa_IsoTrackHBHE_v3, process.AlCa_RPCMuonNormalisation_v25, process.AlCa_LumiPixelsCounts_Random_v12, process.AlCa_LumiPixelsCounts_ZeroBias_v15, process.AlCa_PFJet40_v36, process.AlCa_PFJet40_CPUOnly_v15, process.AlCa_AK8PFJet40_v31, process.DQM_PixelReconstruction_v14, process.DQM_EcalReconstruction_v13, process.DQM_HcalReconstruction_v11, process.DST_ZeroBias_v12, process.DST_Physics_v17, process.DST_PFScouting_DoubleMuonNoVtx_v4, process.DST_PFScouting_DoubleMuonVtx_v4, process.DST_PFScouting_DoubleMuonVtxMonitorJPsi_v4, process.DST_PFScouting_DoubleMuonVtxMonitorZ_v4, process.DST_PFScouting_DoubleEG_v10, process.DST_PFScouting_DoubleEGMonitorJPsi_v1, process.DST_PFScouting_DoubleEGMonitorZ_v1, process.DST_PFScouting_SinglePhotonEBMonitorJPsi_v1, process.DST_PFScouting_SinglePhotonEBMonitorZ_v1, process.DST_PFScouting_JetHT_v10, process.DST_PFScouting_AXOVLoose_v8, process.DST_PFScouting_AXOLoose_v8, process.DST_PFScouting_AXOMedium_v4, process.DST_PFScouting_AXOTight_v10, process.DST_PFScouting_AXOVTight_v8, process.HLT_MonitorL1TPureRate_AXO_v1, process.DST_PFScouting_CICADAVLoose_v6, process.DST_PFScouting_CICADALoose_v6, process.DST_PFScouting_CICADAMedium_v6, process.DST_PFScouting_CICADATight_v6, process.DST_PFScouting_CICADAVTight_v6, process.HLT_MonitorL1TPureRate_CICADA_v1, process.DST_PFScouting_SingleMuon_v10, process.DST_PFScouting_SinglePhotonEB_v7, process.DST_PFScouting_ZeroBias_v8, process.HLT_TriggersForScoutingPFMonitor_PS125_v1, process.HLT_TriggersForScoutingPFMonitor_PS250_v1, process.HLT_TriggersForScoutingPFMonitor_PS500_v1, process.HLT_TriggersForScoutingPFMonitor_PS1000_v1, process.HLT_EphemeralPhysics_v10, process.HLT_EphemeralZeroBias_v10, process.HLT_EcalCalibration_v4, process.HLT_HcalCalibration_v6, process.HLT_HcalNZS_v22, process.HLT_HcalPhiSym_v24, process.HLT_Random_v3, process.HLT_Physics_v15, process.HLT_ZeroBias_v14, process.HLT_ZeroBias_Alignment_v9, process.HLT_ZeroBias_Beamspot_v20, process.HLT_ZeroBias_IsolatedBunches_v13, process.HLT_ZeroBias_FirstBXAfterTrain_v11, process.HLT_ZeroBias_FirstCollisionAfterAbortGap_v13, process.HLT_ZeroBias_FirstCollisionInTrain_v12, process.HLT_ZeroBias_LastCollisionInTrain_v11, process.HLT_HT300_Beamspot_v27, process.HLT_PFJet40_GPUvsCPU_v8, process.HLT_AK8PFJet380_SoftDropMass30_v10, process.HLT_AK8PFJet400_SoftDropMass30_v10, process.HLT_AK8PFJet425_SoftDropMass30_v10, process.HLT_AK8PFJet450_SoftDropMass30_v10, process.HLT_AK8DiPFJet250_250_SoftDropMass40_v10, process.HLT_AK8DiPFJet250_250_SoftDropMass50_v10, process.HLT_AK8DiPFJet260_260_SoftDropMass30_v10, process.HLT_AK8DiPFJet260_260_SoftDropMass40_v10, process.HLT_AK8DiPFJet270_270_SoftDropMass30_v10, process.HLT_AK8DiPFJet280_280_SoftDropMass30_v16, process.HLT_AK8DiPFJet290_290_SoftDropMass30_v10, process.HLT_CaloJet500_NoJetID_v24, process.HLT_CaloJet550_NoJetID_v19, process.HLT_DoubleMu5_Upsilon_DoubleEle3_CaloIdL_TrackIdL_v20, process.HLT_DoubleMu3_DoubleEle7p5_CaloIdL_TrackIdL_Upsilon_v20, process.HLT_Trimuon5_3p5_2_Upsilon_Muon_v21, process.HLT_TrimuonOpen_5_3p5_2_Upsilon_Muon_v18, process.HLT_DoubleEle25_CaloIdL_MW_v18, process.HLT_DoubleEle27_CaloIdL_MW_v18, process.HLT_DoubleEle33_CaloIdL_MW_v31, process.HLT_DoubleEle24_eta2p1_WPTight_Gsf_v22, process.HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_DZ_PFHT350_v36, process.HLT_DoubleEle8_CaloIdM_TrackIdM_Mass8_PFHT350_v36, process.HLT_Mu27_Ele37_CaloIdL_MW_v21, process.HLT_Mu37_Ele27_CaloIdL_MW_v21, process.HLT_Mu37_TkMu27_v21, process.HLT_DoubleMu4_3_Bs_v31, process.HLT_DoubleMu4_3_Jpsi_v31, process.HLT_DoubleMu4_3_LowMass_v17, process.HLT_DoubleMu4_LowMass_Displaced_v17, process.HLT_Mu0_L1DoubleMu_v17, process.HLT_Mu4_L1DoubleMu_v17, process.HLT_DoubleMu2_Jpsi_LowPt_v10, process.HLT_DoubleMu4_3_Photon4_BsToMMG_v16, process.HLT_DoubleMu4_3_Displaced_Photon4_BsToMMG_v16, process.HLT_DoubleMu3_Trk_Tau3mu_v28, process.HLT_DoubleMu3_TkMu_DsTau3Mu_v20, process.HLT_DoubleMu4_Mass3p8_DZ_PFHT350_v24, process.HLT_DoubleMu4_MuMuTrk_Displaced_v31, process.HLT_Mu3_PFJet40_v32, process.HLT_Mu7p5_L2Mu2_Jpsi_v26, process.HLT_Mu7p5_L2Mu2_Upsilon_v26, process.HLT_Mu3_L1SingleMu5orSingleMu7_v17, process.HLT_Mu0_Barrel_v10, process.HLT_Mu0_Barrel_L1HP6_v7, process.HLT_Mu0_Barrel_L1HP7_v7, process.HLT_Mu0_Barrel_L1HP8_v8, process.HLT_Mu0_Barrel_L1HP9_v8, process.HLT_Mu0_Barrel_L1HP10_v10, process.HLT_Mu0_Barrel_L1HP11_v10, process.HLT_Mu0_Barrel_L1HP13_v4, process.HLT_Mu0_Barrel_L1HP6_IP6_v7, process.HLT_Mu4_Barrel_IP4_v4, process.HLT_Mu4_Barrel_IP6_v4, process.HLT_Mu6_Barrel_L1HP7_IP6_v7, process.HLT_Mu7_Barrel_L1HP8_IP6_v8, process.HLT_Mu8_Barrel_L1HP9_IP6_v8, process.HLT_Mu9_Barrel_L1HP10_IP6_v10, process.HLT_Mu10_Barrel_L1HP11_IP4_v4, process.HLT_Mu10_Barrel_L1HP11_IP6_v10, process.HLT_Mu12_Barrel_L1HP13_IP4_v4, process.HLT_Mu12_Barrel_L1HP13_IP6_v4, process.HLT_DoublePhoton33_CaloIdL_v18, process.HLT_DoublePhoton70_v18, process.HLT_DoublePhoton85_v26, process.HLT_DiEle27_WPTightCaloOnly_L1DoubleEG_v16, process.HLT_Ele30_WPTight_Gsf_v16, process.HLT_Ele32_WPTight_Gsf_v30, process.HLT_Ele35_WPTight_Gsf_v24, process.HLT_Ele38_WPTight_Gsf_v24, process.HLT_Ele40_WPTight_Gsf_v24, process.HLT_Ele32_WPTight_Gsf_L1DoubleEG_v24, process.HLT_IsoMu20_v31, process.HLT_IsoMu24_v29, process.HLT_IsoMu24_HLTTracking_v4, process.HLT_IsoMu24_eta2p1_v31, process.HLT_IsoMu27_v32, process.HLT_UncorrectedJetE30_NoBPTX_v16, process.HLT_UncorrectedJetE30_NoBPTX3BX_v16, process.HLT_UncorrectedJetE60_NoBPTX3BX_v16, process.HLT_UncorrectedJetE70_NoBPTX3BX_v16, process.HLT_L1SingleMuCosmics_v9, process.HLT_L2Mu10_NoVertex_NoBPTX3BX_v15, process.HLT_L2Mu10_NoVertex_NoBPTX_v16, process.HLT_L2Mu45_NoVertex_3Sta_NoBPTX3BX_v14, process.HLT_L2Mu40_NoVertex_3Sta_NoBPTX3BX_v15, process.HLT_L2Mu23NoVtx_2Cha_v11, process.HLT_L2Mu23NoVtx_2Cha_CosmicSeed_v11, process.HLT_DoubleL2Mu30NoVtx_2Cha_CosmicSeed_Eta2p4_v12, process.HLT_DoubleL2Mu30NoVtx_2Cha_Eta2p4_v12, process.HLT_DoubleL2Mu50_v12, process.HLT_DoubleL2Mu23NoVtx_2Cha_CosmicSeed_v12, process.HLT_DoubleL2Mu25NoVtx_2Cha_CosmicSeed_v12, process.HLT_DoubleL2Mu25NoVtx_2Cha_CosmicSeed_Eta2p4_v12, process.HLT_DoubleL2Mu23NoVtx_2Cha_v12, process.HLT_DoubleL2Mu25NoVtx_2Cha_v12, process.HLT_DoubleL2Mu25NoVtx_2Cha_Eta2p4_v12, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_v30, process.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_v19, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v31, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_HLTTracking_v4, process.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_v19, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_v21, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_PFJet30_v10, process.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_Mass8_v19, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass3p8_v21, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass3p8_HLTTracking_v4, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_CaloJet30_v9, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_AK8PFJet30_v9, process.HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_Mass8_AK8CaloJet30_v9, process.HLT_Mu19_TrkIsoVVL_Mu9_TrkIsoVVL_DZ_Mass3p8_v19, process.HLT_Mu30_TkMu0_Psi_v17, process.HLT_Mu30_TkMu0_Upsilon_v17, process.HLT_Mu25_TkMu0_Phi_v24, process.HLT_Mu15_v19, process.HLT_Mu20_v28, process.HLT_Mu27_v29, process.HLT_Mu50_v29, process.HLT_Mu55_v19, process.HLT_CascadeMu100_v16, process.HLT_HighPtTkMu100_v16, process.HLT_DiPFJetAve40_v30, process.HLT_DiPFJetAve60_v30, process.HLT_DiPFJetAve80_v30, process.HLT_DiPFJetAve140_v29, process.HLT_DiPFJetAve200_v29, process.HLT_DiPFJetAve260_v30, process.HLT_DiPFJetAve320_v30, process.HLT_DiPFJetAve400_v30, process.HLT_DiPFJetAve500_v30, process.HLT_DiPFJetAve60_HFJEC_v31, process.HLT_DiPFJetAve80_HFJEC_v33, process.HLT_DiPFJetAve100_HFJEC_v33, process.HLT_DiPFJetAve160_HFJEC_v32, process.HLT_DiPFJetAve220_HFJEC_v32, process.HLT_DiPFJetAve260_HFJEC_v15, process.HLT_DiPFJetAve300_HFJEC_v32, process.HLT_DiPFJetAve180_PPSMatch_Xi0p3_QuadJet_Max2ProtPerRP_v10, process.HLT_AK8PFJet40_v32, process.HLT_AK8PFJet60_v31, process.HLT_AK8PFJet80_v32, process.HLT_AK8PFJet140_v31, process.HLT_AK8PFJet200_v31, process.HLT_AK8PFJet260_v32, process.HLT_AK8PFJet320_v32, process.HLT_AK8PFJet400_v32, process.HLT_AK8PFJet450_v32, process.HLT_AK8PFJet500_v32, process.HLT_AK8PFJet550_v27, process.HLT_PFJet40_v37, process.HLT_PFJet60_v37, process.HLT_PFJet80_v37, process.HLT_PFJet110_v16, process.HLT_PFJet140_v35, process.HLT_PFJet200_v35, process.HLT_PFJet260_v36, process.HLT_PFJet320_v36, process.HLT_PFJet400_v36, process.HLT_PFJet450_v37, process.HLT_PFJet500_v37, process.HLT_PFJet550_v27, process.HLT_PFJetFwd40_v35, process.HLT_PFJetFwd60_v35, process.HLT_PFJetFwd80_v34, process.HLT_PFJetFwd140_v34, process.HLT_PFJetFwd200_v34, process.HLT_PFJetFwd260_v35, process.HLT_PFJetFwd320_v35, process.HLT_PFJetFwd400_v35, process.HLT_PFJetFwd450_v35, process.HLT_PFJetFwd500_v35, process.HLT_AK8PFJetFwd40_v31, process.HLT_AK8PFJetFwd60_v30, process.HLT_AK8PFJetFwd80_v30, process.HLT_AK8PFJetFwd140_v30, process.HLT_AK8PFJetFwd200_v30, process.HLT_AK8PFJetFwd260_v31, process.HLT_AK8PFJetFwd320_v31, process.HLT_AK8PFJetFwd400_v31, process.HLT_AK8PFJetFwd450_v31, process.HLT_AK8PFJetFwd500_v31, process.HLT_PFHT180_v33, process.HLT_PFHT250_v33, process.HLT_PFHT370_v33, process.HLT_PFHT430_v33, process.HLT_PFHT510_v33, process.HLT_PFHT590_v33, process.HLT_PFHT680_v33, process.HLT_PFHT780_v33, process.HLT_PFHT890_v33, process.HLT_PFHT1050_v34, process.HLT_PFHT500_PFMET100_PFMHT100_IDTight_v28, process.HLT_PFHT500_PFMET110_PFMHT110_IDTight_v28, process.HLT_PFHT700_PFMET85_PFMHT85_IDTight_v28, process.HLT_PFHT800_PFMET75_PFMHT75_IDTight_v28, process.HLT_PFMET120_PFMHT120_IDTight_v36, process.HLT_PFMET130_PFMHT130_IDTight_v36, process.HLT_PFMET140_PFMHT140_IDTight_v36, process.HLT_PFMET120_PFMHT120_IDTight_PFHT60_v25, process.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_PFHT60_v25, process.HLT_PFMETTypeOne140_PFMHT140_IDTight_v27, process.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_v36, process.HLT_PFMETNoMu130_PFMHTNoMu130_IDTight_v35, process.HLT_PFMETNoMu140_PFMHTNoMu140_IDTight_v35, process.HLT_PFMETNoMu110_PFMHTNoMu110_IDTight_FilterHF_v16, process.HLT_PFMETNoMu120_PFMHTNoMu120_IDTight_FilterHF_v16, process.HLT_PFMETNoMu130_PFMHTNoMu130_IDTight_FilterHF_v16, process.HLT_PFMETNoMu140_PFMHTNoMu140_IDTight_FilterHF_v16, process.HLT_L1ETMHadSeeds_v11, process.HLT_CaloMHT90_v16, process.HLT_CaloMET90_NotCleaned_v16, process.HLT_CaloMET350_NotCleaned_v16, process.HLT_PFMET200_NotCleaned_v25, process.HLT_PFMET250_NotCleaned_v25, process.HLT_PFMET300_NotCleaned_v25, process.HLT_PFMET200_BeamHaloCleaned_v25, process.HLT_PFMETTypeOne200_BeamHaloCleaned_v25, process.HLT_MET105_IsoTrk50_v23, process.HLT_MET120_IsoTrk50_v23, process.HLT_Mu12eta2p3_v17, process.HLT_Mu12eta2p3_PFJet40_v17, process.HLT_Mu12_DoublePFJets40_PNetBTag_0p11_v10, process.HLT_Mu12_DoublePFJets100_PNetBTag_0p11_v10, process.HLT_Mu12_DoublePFJets200_PNetBTag_0p11_v10, process.HLT_Mu12_DoublePFJets350_PNetBTag_0p11_v10, process.HLT_Mu12_DoublePFJets40MaxDeta1p6_PNet2BTag_0p11_v10, process.HLT_Mu12_DoublePFJets54MaxDeta1p6_PNet2BTag_0p11_v10, process.HLT_DoublePFJets40_PNetBTag_0p11_v10, process.HLT_DoublePFJets100_PNetBTag_0p11_v10, process.HLT_DoublePFJets200_PNetBTag_0p11_v10, process.HLT_DoublePFJets350_PNetBTag_0p11_v10, process.HLT_DoublePFJets116MaxDeta1p6_PNet2BTag_0p11_v10, process.HLT_DoublePFJets128MaxDeta1p6_PNet2BTag_0p11_v10, process.HLT_Photon300_NoHE_v24, process.HLT_Mu8_TrkIsoVVL_v28, process.HLT_Mu8_DiEle12_CaloIdL_TrackIdL_DZ_v34, process.HLT_Mu8_DiEle12_CaloIdL_TrackIdL_v34, process.HLT_Mu8_Ele8_CaloIdM_TrackIdM_Mass8_PFHT350_DZ_v35, process.HLT_Mu8_Ele8_CaloIdM_TrackIdM_Mass8_PFHT350_v35, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_v29, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_v17, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v27, process.HLT_Mu17_TrkIsoVVL_v29, process.HLT_Mu19_TrkIsoVVL_v20, process.HLT_BTagMu_AK4DiJet20_Mu5_v29, process.HLT_BTagMu_AK4DiJet40_Mu5_v29, process.HLT_BTagMu_AK4DiJet70_Mu5_v29, process.HLT_BTagMu_AK4DiJet110_Mu5_v29, process.HLT_BTagMu_AK4DiJet170_Mu5_v28, process.HLT_BTagMu_AK4Jet300_Mu5_v28, process.HLT_BTagMu_AK8DiJet170_Mu5_v25, process.HLT_BTagMu_AK8Jet170_DoubleMu5_v18, process.HLT_BTagMu_AK8Jet300_Mu5_v28, process.HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v33, process.HLT_Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_v33, process.HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v31, process.HLT_Mu23_TrkIsoVVL_Ele12_CaloIdL_TrackIdL_IsoVL_v23, process.HLT_Mu12_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_v23, process.HLT_Mu12_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_v31, process.HLT_Mu12_IsoVVL_PFHT150_PNetBTag0p53_v9, process.HLT_Photon33_v16, process.HLT_Photon50_v24, process.HLT_Photon75_v24, process.HLT_Photon90_v24, process.HLT_Photon120_v24, process.HLT_Photon150_v18, process.HLT_Photon175_v26, process.HLT_Photon200_v25, process.HLT_Photon45EB_v4, process.HLT_Photon40EB_v4, process.HLT_Photon50EB_v5, process.HLT_Photon30EB_TightID_TightIso_v15, process.HLT_Photon40EB_TightID_TightIso_v6, process.HLT_Photon45EB_TightID_TightIso_v6, process.HLT_Photon50EB_TightID_TightIso_PFJet30_v10, process.HLT_Photon50EB_TightID_TightIso_CaloJet30_v6, process.HLT_Photon50EB_TightID_TightIso_AK8PFJet30_v9, process.HLT_Photon50EB_TightID_TightIso_AK8CaloJet30_v6, process.HLT_Photon50EB_TightID_TightIso_v11, process.HLT_Photon55EB_TightID_TightIso_v7, process.HLT_Photon75EB_TightID_TightIso_v11, process.HLT_Photon90EB_TightID_TightIso_v11, process.HLT_Photon110EB_TightID_TightIso_v15, process.HLT_Photon110EB_TightID_TightIso_PFJet30_v10, process.HLT_Photon110EB_TightID_TightIso_CaloJet30_v6, process.HLT_Photon110EB_TightID_TightIso_AK8PFJet30_v9, process.HLT_Photon110EB_TightID_TightIso_AK8CaloJet30_v6, process.HLT_Photon100EBHE10_v13, process.HLT_Photon50_R9Id90_HE10_IsoM_v27, process.HLT_Photon75_R9Id90_HE10_IsoM_v27, process.HLT_Photon90_R9Id90_HE10_IsoM_v27, process.HLT_Photon120_R9Id90_HE10_IsoM_v27, process.HLT_Photon165_R9Id90_HE10_IsoM_v28, process.HLT_Diphoton30_22_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass90_v26, process.HLT_Diphoton30_22_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass95_v26, process.HLT_Photon35_TwoProngs35_v17, process.HLT_IsoMu24_TwoProngs35_v17, process.HLT_Dimuon0_Jpsi_L1_NoOS_v23, process.HLT_Dimuon0_Jpsi_NoVertexing_NoOS_v23, process.HLT_Dimuon0_Jpsi_v24, process.HLT_Dimuon0_Jpsi_NoVertexing_v24, process.HLT_Dimuon0_Jpsi_L1_4R_0er1p5R_v23, process.HLT_Dimuon0_Jpsi_NoVertexing_L1_4R_0er1p5R_v23, process.HLT_Dimuon0_Jpsi3p5_Muon2_v21, process.HLT_Dimuon0_Upsilon_L1_4p5_v25, process.HLT_Dimuon0_Upsilon_L1_4p5er2p0_v25, process.HLT_Dimuon0_Upsilon_L1_4p5er2p0M_v23, process.HLT_Dimuon0_Upsilon_NoVertexing_v23, process.HLT_Dimuon0_LowMass_L1_0er1p5_v24, process.HLT_Dimuon0_LowMass_v24, process.HLT_Dimuon0_LowMass_L1_4_v24, process.HLT_Dimuon0_LowMass_Inclusive_v1, process.HLT_Dimuon0_LowMass_L1_TM530_v22, process.HLT_Dimuon0_Upsilon_Muon_NoL1Mass_v22, process.HLT_Dimuon0_Upsilon_v2, process.HLT_TripleMu_5_3_3_Mass3p8_DZ_v24, process.HLT_TripleMu_10_5_5_DZ_v26, process.HLT_TripleMu_12_10_5_v26, process.HLT_Tau3Mu_Mu7_Mu1_TkMu1_Tau15_v20, process.HLT_Tau3Mu_Mu7_Mu1_TkMu1_Tau15_Charge1_v20, process.HLT_Tau3Mu_Mu7_Mu1_TkMu1_IsoTau15_v20, process.HLT_Tau3Mu_Mu7_Mu1_TkMu1_IsoTau15_Charge1_v20, process.HLT_DoubleMu3_DZ_PFMET50_PFMHT60_v26, process.HLT_DoubleMu3_DZ_PFMET70_PFMHT70_v26, process.HLT_DoubleMu3_DZ_PFMET90_PFMHT90_v26, process.HLT_DoubleMu3_Trk_Tau3mu_NoL1Mass_v22, process.HLT_DoubleMu4_3_LowMass_SS_v10, process.HLT_DoubleMu4_Jpsi_Displaced_v23, process.HLT_DoubleMu4_Jpsi_NoVertexing_v23, process.HLT_DoubleMu4_JpsiTrkTrk_Displaced_v23, process.HLT_DoubleMu4_JpsiTrk_Bc_v16, process.HLT_DoubleMu43NoFiltersNoVtx_v17, process.HLT_DoubleMu48NoFiltersNoVtx_v17, process.HLT_Mu43NoFiltersNoVtx_Photon43_CaloIdL_v18, process.HLT_Mu48NoFiltersNoVtx_Photon48_CaloIdL_v18, process.HLT_Mu38NoFiltersNoVtxDisplaced_Photon38_CaloIdL_v14, process.HLT_Mu43NoFiltersNoVtxDisplaced_Photon43_CaloIdL_v14, process.HLT_Ele28_HighEta_SC20_Mass55_v27, process.HLT_Ele15_IsoVVVL_PFHT450_PFMET50_v32, process.HLT_Ele15_IsoVVVL_PFHT450_v32, process.HLT_Ele50_IsoVVVL_PFHT450_v32, process.HLT_Ele15_IsoVVVL_PFHT600_v36, process.HLT_Mu15_IsoVVVL_PFHT450_PFMET50_v31, process.HLT_Mu15_IsoVVVL_PFHT450_v31, process.HLT_Mu50_IsoVVVL_PFHT450_v31, process.HLT_Mu15_IsoVVVL_PFHT600_v35, process.HLT_Mu3er1p5_PFJet100er2p5_PFMET80_PFMHT80_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMET90_PFMHT90_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMET100_PFMHT100_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu80_PFMHTNoMu80_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu90_PFMHTNoMu90_IDTight_v18, process.HLT_Mu3er1p5_PFJet100er2p5_PFMETNoMu100_PFMHTNoMu100_IDTight_v18, process.HLT_Dimuon10_Upsilon_y1p4_v17, process.HLT_Dimuon12_Upsilon_y1p4_v18, process.HLT_Dimuon14_Phi_Barrel_Seagulls_v23, process.HLT_Dimuon25_Jpsi_v30, process.HLT_Dimuon14_PsiPrime_v29, process.HLT_Dimuon14_PsiPrime_noCorrL1_v21, process.HLT_Dimuon18_PsiPrime_v30, process.HLT_Dimuon18_PsiPrime_noCorrL1_v22, process.HLT_Dimuon24_Upsilon_noCorrL1_v22, process.HLT_Dimuon24_Phi_noCorrL1_v22, process.HLT_Dimuon25_Jpsi_noCorrL1_v22, process.HLT_DiMu4_Ele9_CaloIdL_TrackIdL_DZ_Mass3p8_v33, process.HLT_DiMu9_Ele9_CaloIdL_TrackIdL_DZ_v33, process.HLT_DiMu9_Ele9_CaloIdL_TrackIdL_v33, process.HLT_DoubleIsoMu20_eta2p1_v23, process.HLT_TrkMu12_DoubleTrkMu5NoFiltersNoVtx_v21, process.HLT_Mu8_v28, process.HLT_Mu17_v29, process.HLT_Mu19_v20, process.HLT_Mu17_Photon30_IsoCaloId_v22, process.HLT_Ele8_CaloIdL_TrackIdL_IsoVL_PFJet30_v32, process.HLT_Ele12_CaloIdL_TrackIdL_IsoVL_PFJet30_v34, process.HLT_Ele14_eta2p5_IsoVVVL_Gsf_PFHT200_PNetBTag0p53_v9, process.HLT_Ele23_CaloIdL_TrackIdL_IsoVL_PFJet30_v34, process.HLT_Ele8_CaloIdM_TrackIdM_PFJet30_v34, process.HLT_Ele17_CaloIdM_TrackIdM_PFJet30_v32, process.HLT_Ele23_CaloIdM_TrackIdM_PFJet30_v34, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_PFJet165_v34, process.HLT_Ele115_CaloIdVT_GsfTrkIdT_v28, process.HLT_Ele135_CaloIdVT_GsfTrkIdT_v21, process.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_v25, process.HLT_PFHT400_SixPFJet32_v25, process.HLT_PFHT400_SixPFJet32_PNet2BTagMean0p50_v13, process.HLT_PFHT450_SixPFJet36_v24, process.HLT_PFHT450_SixPFJet36_PNetBTag0p35_v13, process.HLT_PFHT400_FivePFJet_120_120_60_30_30_v10, process.HLT_PFHT350_v35, process.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT350_v14, process.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT380_v14, process.HLT_Photon60_R9Id90_CaloIdL_IsoL_DisplacedIdL_PFHT400_v14, process.HLT_ECALHT800_v22, process.HLT_DiSC30_18_EIso_AND_HE_Mass70_v25, process.HLT_Photon20_HoverELoose_v21, process.HLT_Photon30_HoverELoose_v21, process.HLT_L1_CDC_SingleMu_3_er1p2_TOP120_DPHI2p618_3p142_v10, process.HLT_CDC_L2cosmic_10_er1p0_v11, process.HLT_CDC_L2cosmic_5p5_er1p0_v11, process.HLT_Photon60_R9Id90_HE10_IsoM_EBOnly_PFJetsMJJ300DEta3_v13, process.HLT_Photon75_R9Id90_HE10_IsoM_EBOnly_PFJetsMJJ300DEta3_v21, process.HLT_Mu18_Mu9_SameSign_v20, process.HLT_DoubleMu2_Jpsi_DoubleTrk1_Phi1p05_v22, process.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_v26, process.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_Mass2p0_v10, process.HLT_DoubleMu3_DCA_PFMET50_PFMHT60_Mass2p0_noDCA_v10, process.HLT_TripleMu_5_3_3_Mass3p8_DCA_v19, process.HLT_QuadPFJet103_88_75_15_v21, process.HLT_QuadPFJet105_88_76_15_v21, process.HLT_QuadPFJet111_90_80_15_v21, process.HLT_Diphoton30_18_R9IdL_AND_HE_AND_IsoCaloId_v14, process.HLT_Diphoton30_18_R9IdL_AND_HE_AND_IsoCaloId_Mass55_v14, process.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Tight_eta2p3_CrossL1_v11, process.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Medium_eta2p3_CrossL1_v11, process.HLT_Ele24_eta2p1_WPTight_Gsf_PNetTauhPFJet30_Loose_eta2p3_CrossL1_v11, process.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_PNet3BTag_4p3_v9, process.HLT_PFHT330PT30_QuadPFJet_75_60_45_40_PNet3BTag_2p0_v9, process.HLT_PFHT400_FivePFJet_120_120_60_30_30_PNet2BTag_5p6_v10, process.HLT_PFHT400_FivePFJet_120_120_60_30_30_PNet2BTag_4p3_v10, process.HLT_QuadPFJet103_88_75_15_PNetBTag_0p4_VBF2_v10, process.HLT_QuadPFJet103_88_75_15_PNet2BTag_0p4_0p12_VBF1_v10, process.HLT_QuadPFJet105_88_76_15_PNetBTag_0p4_VBF2_v10, process.HLT_QuadPFJet105_88_76_15_PNet2BTag_0p4_0p12_VBF1_v10, process.HLT_QuadPFJet111_90_80_15_PNetBTag_0p4_VBF2_v10, process.HLT_QuadPFJet111_90_80_15_PNet2BTag_0p4_0p12_VBF1_v10, process.HLT_PFHT250_QuadPFJet25_v10, process.HLT_PFHT250_QuadPFJet25_PNet2BTagMean0p55_v10, process.HLT_PFHT250_QuadPFJet25_PNet1BTag0p20_PNet1Tauh0p50_v10, process.HLT_PFHT250_QuadPFJet30_PNet2BTagMean0p55_v10, process.HLT_PFHT250_QuadPFJet30_PNet1BTag0p20_PNet1Tauh0p50_v10, process.HLT_PFHT280_QuadPFJet30_PNet1BTag0p20_PNet1Tauh0p50_v10, process.HLT_PFHT280_QuadPFJet30_v13, process.HLT_PFHT280_QuadPFJet30_PNet2BTagMean0p55_v13, process.HLT_PFHT280_QuadPFJet30_PNet2BTagMean0p60_v13, process.HLT_PFHT280_QuadPFJet35_PNet2BTagMean0p60_v13, process.HLT_PFHT340_QuadPFJet70_50_40_40_PNet2BTagMean0p70_v14, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_v13, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_QuadPFJet30_v13, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT280_QuadPFJet30_PNet2BTagMean0p55_v13, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFDiJet30_PNet2BTagMean0p50_v13, process.HLT_QuadPFJet100_88_70_30_v14, process.HLT_QuadPFJet105_88_75_30_v13, process.HLT_QuadPFJet111_90_80_30_v13, process.HLT_QuadPFJet100_88_70_30_PNet1CvsAll0p5_VBF3Tight_v14, process.HLT_QuadPFJet105_88_75_30_PNet1CvsAll0p5_VBF3Tight_v14, process.HLT_QuadPFJet111_90_80_30_PNet1CvsAll0p6_VBF3Tight_v14, process.HLT_AK8PFJet220_SoftDropMass40_v17, process.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p50_v13, process.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p53_v13, process.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p55_v13, process.HLT_AK8PFJet220_SoftDropMass40_PNetBB0p06_DoubleAK4PFJet60_30_PNet2BTagMean0p60_v13, process.HLT_AK8PFJet230_SoftDropMass40_v17, process.HLT_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, process.HLT_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, process.HLT_AK8PFJet230_SoftDropMass40_PNetTauTau0p03_v13, process.HLT_AK8PFJet230_SoftDropMass40_PNetTauTau0p05_v13, process.HLT_AK8PFJet250_SoftDropMass40_PNetBB0p06_v13, process.HLT_AK8PFJet250_SoftDropMass40_PNetBB0p10_v13, process.HLT_AK8PFJet250_SoftDropMass40_PNetTauTau0p03_v13, process.HLT_AK8PFJet250_SoftDropMass40_PNetTauTau0p05_v13, process.HLT_AK8PFJet275_SoftDropMass40_PNetBB0p06_v13, process.HLT_AK8PFJet275_SoftDropMass40_PNetBB0p10_v13, process.HLT_AK8PFJet275_SoftDropMass40_PNetTauTau0p03_v13, process.HLT_AK8PFJet275_SoftDropMass40_PNetTauTau0p05_v13, process.HLT_AK8PFJet275_Nch45_v10, process.HLT_AK8PFJet275_Nch40_v10, process.HLT_IsoMu50_AK8PFJet220_SoftDropMass40_v16, process.HLT_IsoMu50_AK8PFJet220_SoftDropMass40_PNetBB0p06_v13, process.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_v16, process.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, process.HLT_IsoMu50_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet220_SoftDropMass40_v16, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet220_SoftDropMass40_PNetBB0p06_v13, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_v16, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_PNetBB0p06_v13, process.HLT_Ele50_CaloIdVT_GsfTrkIdT_AK8PFJet230_SoftDropMass40_PNetBB0p10_v13, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_DoubleAK4PFJet60_30_v14, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_DoubleAK4PFJet60_30_PNet2BTagMean0p50_v14, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_v10, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_v10, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_PNet2BTagMean0p55_v10, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_PFHT250_QuadPFJet25_PNet1BTag0p20_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Medium_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Tight_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_PFJet60_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet26_L2NN_eta2p3_CrossL1_PFJet75_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Tight_eta2p3_CrossL1_ETau_Monitoring_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Medium_eta2p3_CrossL1_ETau_Monitoring_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet30_Loose_eta2p3_CrossL1_ETau_Monitoring_v10, process.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Tight_eta2p3_CrossL1_v10, process.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Medium_eta2p3_CrossL1_v10, process.HLT_IsoMu20_eta2p1_PNetTauhPFJet27_Loose_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet20_eta2p2_SingleL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet45_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PFHT250_v10, process.HLT_IsoMu24_eta2p1_PFHT250_QuadPFJet25_v10, process.HLT_IsoMu24_eta2p1_PFHT250_QuadPFJet25_PNet1Tauh0p50_v10, process.HLT_IsoMu24_eta2p1_SinglePFJet25_PNet1Tauh0p50_v10, process.HLT_DoublePNetTauhPFJet30_Medium_L2NN_eta2p3_v10, process.HLT_DoublePNetTauhPFJet30_Tight_L2NN_eta2p3_v10, process.HLT_DoublePNetTauhPFJet26_L2NN_eta2p3_PFJet60_v10, process.HLT_DoublePNetTauhPFJet26_L2NN_eta2p3_PFJet75_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Loose_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Medium_L2NN_eta2p3_CrossL1_v10, process.HLT_IsoMu24_eta2p1_PNetTauhPFJet130_Tight_L2NN_eta2p3_CrossL1_v10, process.HLT_SinglePNetTauhPFJet130_Loose_L2NN_eta2p3_v10, process.HLT_SinglePNetTauhPFJet130_Medium_L2NN_eta2p3_v10, process.HLT_SinglePNetTauhPFJet130_Tight_L2NN_eta2p3_v10, process.HLT_DoubleL2Mu10NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v16, process.HLT_DoubleL2Mu12NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, process.HLT_DoubleL2Mu14NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, process.HLT_DoubleL3Mu16_10NoVtx_DxyMin0p01cm_v14, process.HLT_DoubleL3Mu18_10NoVtx_DxyMin0p01cm_v13, process.HLT_DoubleL3Mu20_10NoVtx_DxyMin0p01cm_v13, process.HLT_L2Mu10NoVtx_2Cha_v10, process.HLT_L2Mu10NoVtx_2Cha_VetoL3Mu0DxyMax1cm_v15, process.HLT_L3Mu10NoVtx_v13, process.HLT_L3Mu10NoVtx_DxyMin0p01cm_v13, process.HLT_DoubleL2Mu_L3Mu16NoVtx_VetoL3Mu0DxyMax0p1cm_v13, process.HLT_DoubleL2Mu_L3Mu18NoVtx_VetoL3Mu0DxyMax0p1cm_v13, process.HLT_DoubleL2Mu10NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, process.HLT_DoubleL2Mu12NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, process.HLT_L2Mu10NoVtx_2Cha_CosmicSeed_v10, process.HLT_L2Mu10NoVtx_2Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v15, process.HLT_DoubleL3dTksMu16_10NoVtx_DxyMin0p01cm_v14, process.HLT_L2Mu50NoVtx_3Cha_CosmicSeed_VetoL3Mu0DxyMax1cm_v8, process.HLT_L2Mu50NoVtx_3Cha_VetoL3Mu0DxyMax1cm_v8, process.HLT_L3Mu30NoVtx_DxyMin0p01cm_v6, process.HLT_L3Mu50NoVtx_DxyMin0p01cm_v6, process.HLT_L3dTksMu10_NoVtx_DxyMin0p01cm_v14, process.HLT_Mu20NoFiltersNoVtxDisplaced_Photon20_CaloCustomId_v14, process.HLT_DisplacedMu24_MediumChargedIsoDisplacedPFTauHPS24_v12, process.HLT_Photon34_R9Id90_CaloIdL_IsoL_DisplacedIdL_MediumChargedIsoDisplacedPFTauHPS34_v12, process.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS32_Trk1_eta2p1_v17, process.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS36_Trk1_eta2p1_v12, process.HLT_DoubleMediumChargedIsoDisplacedPFTauHPS32_Trk1_eta2p1_noDxy_v12, process.HLT_IsoMu27_MediumChargedIsoDisplacedPFTauHPS24_eta2p1_SingleL1_v12, process.HLT_HT350_DelayedJet40_SingleDelay1p5To3p5nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay1p6To3p5nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay1p75To3p5nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay3nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay3p25nsInclusive_v9, process.HLT_HT350_DelayedJet40_SingleDelay3p5nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay0p5nsInclusive_v11, process.HLT_HT430_DelayedJet40_SingleDelay1nsInclusive_v11, process.HLT_HT430_DelayedJet40_SingleDelay1To1p5nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay1p1To1p6nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay1p25To1p75nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay1p5nsInclusive_v11, process.HLT_HT430_DelayedJet40_SingleDelay2nsInclusive_v13, process.HLT_HT430_DelayedJet40_SingleDelay2p25nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay2p5nsInclusive_v9, process.HLT_HT430_DelayedJet40_SingleDelay0p5nsTrackless_v12, process.HLT_HT430_DelayedJet40_SingleDelay1nsTrackless_v14, process.HLT_HT430_DelayedJet40_SingleDelay1p25nsTrackless_v10, process.HLT_HT430_DelayedJet40_SingleDelay1p5nsTrackless_v10, process.HLT_HT430_DelayedJet40_DoubleDelay0p5nsInclusive_v12, process.HLT_HT430_DelayedJet40_DoubleDelay1nsInclusive_v13, process.HLT_HT430_DelayedJet40_DoubleDelay1p25nsInclusive_v9, process.HLT_HT430_DelayedJet40_DoubleDelay1p5nsInclusive_v9, process.HLT_HT430_DelayedJet40_DoubleDelay0p5nsTrackless_v14, process.HLT_HT430_DelayedJet40_DoubleDelay0p75nsTrackless_v10, process.HLT_HT430_DelayedJet40_DoubleDelay1nsTrackless_v10, process.HLT_L1Tau_DelayedJet40_SingleDelay2p5To4nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay2p6To4nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay2p75To4nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay3p5nsInclusive_v11, process.HLT_L1Tau_DelayedJet40_SingleDelay3p75nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay4nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_SingleDelay2p5nsTrackless_v12, process.HLT_L1Tau_DelayedJet40_SingleDelay2p75nsTrackless_v10, process.HLT_L1Tau_DelayedJet40_SingleDelay3nsTrackless_v10, process.HLT_L1Tau_DelayedJet40_DoubleDelay0p75nsInclusive_v11, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p25nsInclusive_v11, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p5nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p75nsInclusive_v9, process.HLT_L1Tau_DelayedJet40_DoubleDelay0p5nsTrackless_v12, process.HLT_L1Tau_DelayedJet40_DoubleDelay1nsTrackless_v12, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p25nsTrackless_v10, process.HLT_L1Tau_DelayedJet40_DoubleDelay1p5nsTrackless_v10, process.HLT_L1Mu6HT240_v10, process.HLT_Mu6HT240_DisplacedDijet30_Inclusive1PtrkShortSig5_DisplacedLoose_v14, process.HLT_Mu6HT240_DisplacedDijet35_Inclusive0PtrkShortSig5_v14, process.HLT_Mu6HT240_DisplacedDijet35_Inclusive1PtrkShortSig5_DisplacedLoose_v14, process.HLT_Mu6HT240_DisplacedDijet40_Inclusive0PtrkShortSig5_v14, process.HLT_Mu6HT240_DisplacedDijet40_Inclusive1PtrkShortSig5_DisplacedLoose_v14, process.HLT_Mu6HT240_DisplacedDijet45_Inclusive0PtrkShortSig5_v14, process.HLT_Mu6HT240_DisplacedDijet50_Inclusive0PtrkShortSig5_v14, process.HLT_HT350_v9, process.HLT_HT425_v21, process.HLT_HT360_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, process.HLT_HT360_DisplacedDijet45_Inclusive1PtrkShortSig5_v10, process.HLT_HT390_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, process.HLT_HT390_DisplacedDijet45_Inclusive1PtrkShortSig5_v10, process.HLT_HT390eta2p0_DisplacedDijet40_Inclusive1PtrkShortSig5_v10, process.HLT_HT430_DisplacedDijet40_Inclusive1PtrkShortSig5_v14, process.HLT_HT400_DisplacedDijet40_DisplacedTrack_v26, process.HLT_HT430_DisplacedDijet40_DisplacedTrack_v26, process.HLT_HT550_DisplacedDijet60_Inclusive_v26, process.HLT_HT650_DisplacedDijet60_Inclusive_v26, process.HLT_CaloMET60_DTCluster50_v13, process.HLT_CaloMET60_DTClusterNoMB1S50_v13, process.HLT_L1MET_DTCluster50_v13, process.HLT_L1MET_DTClusterNoMB1S50_v13, process.HLT_CscCluster_Loose_v11, process.HLT_CscCluster_Medium_v11, process.HLT_CscCluster_Tight_v11, process.HLT_CscCluster50_Photon20Unseeded_v5, process.HLT_CscCluster50_Photon30Unseeded_v5, process.HLT_CscCluster100_Ele5_v7, process.HLT_CscCluster100_Mu5_v10, process.HLT_CscCluster100_PNetTauhPFJet10_Loose_v10, process.HLT_CscCluster150_DisplacedSingleJet30_Inclusive1PtrkShortSig5_v3, process.HLT_CscCluster150_DisplacedSingleJet35_Inclusive1PtrkShortSig5_v3, process.HLT_CscCluster150_DisplacedSingleJet40_Inclusive1PtrkShortSig5_v3, process.HLT_DoubleCscCluster75_v8, process.HLT_IsoTrk200_L1SingleMuShower_v8, process.HLT_IsoTrk400_L1SingleMuShower_v8, process.HLT_DoubleCscCluster100_v8, process.HLT_L1CSCShower_DTCluster50_v11, process.HLT_L1CSCShower_DTCluster75_v11, process.HLT_PFMET105_IsoTrk50_v17, process.HLT_L1SingleLLPJet_v8, process.HLT_L1SingleMuShower_v1, process.HLT_HT170_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, process.HLT_HT200_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, process.HLT_HT200_L1SingleLLPJet_DisplacedDijet60_DisplacedTrack_v14, process.HLT_HT270_L1SingleLLPJet_DisplacedDijet40_DisplacedTrack_v14, process.HLT_HT200_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v14, process.HLT_HT240_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11, process.HLT_HT280_L1SingleLLPJet_DisplacedDijet40_Inclusive1PtrkShortSig5_v11, process.HLT_HT320_L1SingleLLPJet_DisplacedDijet60_Inclusive_v14, process.HLT_HT420_L1SingleLLPJet_DisplacedDijet60_Inclusive_v14, process.HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay1nsTrackless_v14, process.HLT_HT200_L1SingleLLPJet_DelayedJet40_SingleDelay2nsInclusive_v14, process.HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay0p5nsTrackless_v14, process.HLT_HT200_L1SingleLLPJet_DelayedJet40_DoubleDelay1nsInclusive_v14, process.HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p7_v10, process.HLT_HT200_L1SingleLLPJet_PFJet60_NeutralHadronFrac0p8_v10, process.HLT_DiPhoton10Time1ns_v11, process.HLT_DiPhoton10Time1p2ns_v11, process.HLT_DiPhoton10Time1p4ns_v11, process.HLT_DiPhoton10Time1p6ns_v11, process.HLT_DiPhoton10Time1p8ns_v11, process.HLT_DiPhoton10Time2ns_v11, process.HLT_DiPhoton10_CaloIdL_v11, process.HLT_DiphotonMVA14p25_Low_Mass60_v1, process.HLT_DiphotonMVA14p25_Medium_Mass60_v1, process.HLT_DiphotonMVA14p25_High_Mass60_v1, process.HLT_DiphotonMVA14p25_TightLow_Mass60_v1, process.HLT_DiphotonMVA14p25_TightMedium_Mass60_v1, process.HLT_DiphotonMVA14p25_TightHigh_Mass60_v1, process.HLT_Diphoton15_10_EBEB_TightID_ECALTrackIsoDr0p2_v3, process.HLT_Diphoton15_12_EBEB_TightID_ECALTrackIsoDr0p2_v3, process.HLT_Diphoton15_10_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v3, process.HLT_Diphoton15_12_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v3, process.HLT_Dielectron12_5_EBEB_TightID_ECALTrackIsoDr0p2_v4, process.HLT_Dielectron12_5_EBEB_TightID_ECALTrackIsoDr0p2to0p4_v4, process.HLT_DoubleEle6p5_eta1p22_mMax6_v13, process.HLT_DoubleEle8_eta1p22_mMax6_v13, process.HLT_DoubleEle10_eta1p22_mMax6_v13, process.HLT_SingleEle8_v12, process.HLT_SingleEle8_SingleEGL1_v12, process.HLT_Diphoton20_14_eta1p5_R9IdL_AND_HE_AND_IsoTCaloIdT_v13, process.HLT_Diphoton20_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, process.HLT_Diphoton22_14_eta1p5_R9IdL_AND_HE_AND_IsoTCaloIdT_v13, process.HLT_Diphoton22_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, process.HLT_Diphoton24_14_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, process.HLT_Diphoton24_16_eta1p5_R9IdL_AND_HET_AND_IsoTCaloIdT_v13, process.HLT_Mu50_L1SingleMuShower_v15, process.HLT_IsoMu24_OneProng32_v13, process.HLT_Photon32_OneProng32_M50To105_v14, process.HLT_VBF_DiPFJet125_45_Mjj1050_v12, process.HLT_VBF_DiPFJet125_45_Mjj1150_v4, process.HLT_VBF_DiPFJet125_45_Mjj1250_v4, process.HLT_VBF_DiPFJet75_45_Mjj800_DiPFJet60_v10, process.HLT_VBF_DiPFJet75_45_Mjj900_DiPFJet60_v4, process.HLT_VBF_DiPFJet75_45_Mjj1000_DiPFJet60_v4, process.HLT_VBF_DiPFJet80_45_Mjj650_PFMETNoMu85_v10, process.HLT_VBF_DiPFJet80_45_Mjj750_PFMETNoMu85_v10, process.HLT_VBF_DiPFJet80_45_Mjj850_PFMETNoMu85_v4, process.HLT_VBF_DiPFJet95_45_Mjj750_Mu3_TrkIsoVVL_v10, process.HLT_VBF_DiPFJet95_45_Mjj850_Mu3_TrkIsoVVL_v10, process.HLT_VBF_DiPFJet95_45_Mjj950_Mu3_TrkIsoVVL_v4, process.HLT_VBF_DiPFJet50_Mjj650_Photon22_v10, process.HLT_VBF_DiPFJet50_Mjj750_Photon22_v10, process.HLT_VBF_DiPFJet50_Mjj850_Photon22_v4, process.HLT_VBF_DiPFJet50_Mjj600_Ele22_eta2p1_WPTight_Gsf_v11, process.HLT_VBF_DiPFJet50_Mjj700_Ele22_eta2p1_WPTight_Gsf_v5, process.HLT_VBF_DiPFJet50_Mjj800_Ele22_eta2p1_WPTight_Gsf_v5, process.HLT_VBF_DiPFJet115_40_Mjj850_DoublePNetTauhPFJet20_eta2p3_v4, process.HLT_VBF_DiPFJet115_40_Mjj1000_DoublePNetTauhPFJet20_eta2p3_v4, process.HLT_VBF_DiPFJet115_40_Mjj1100_DoublePNetTauhPFJet20_eta2p3_v4, process.HLT_VBF_DiPFJet115_40_Mjj1200_DoublePNetTauhPFJet20_eta2p3_v4, process.HLT_VBF_DiPFJet45_Mjj650_PNetTauhPFJet45_L2NN_eta2p3_v10, process.HLT_VBF_DiPFJet45_Mjj750_PNetTauhPFJet45_L2NN_eta2p3_v10, process.HLT_VBF_DiPFJet45_Mjj850_PNetTauhPFJet45_L2NN_eta2p3_v4, process.HLT_L1HT200_QuadPFJet20_PNet1BTag0p50_PNet1Tauh0p50_v4, process.HLT_L1HT200_QuadPFJet25_PNet1BTag0p50_PNet1Tauh0p50_v4, process.HLT_IsoMu24_eta2p1_L1HT200_v4, process.HLT_IsoMu24_eta2p1_L1HT200_QuadPFJet25_v4, process.HLT_IsoMu24_eta2p1_L1HT200_QuadPFJet25_PNet1Tauh0p50_v4, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_v4, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet20_v4, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet25_v4, process.HLT_Mu8_TrkIsoVVL_Ele23_CaloIdL_TrackIdL_IsoVL_DZ_L1HT200_QuadPFJet25_PNet1BTag0p50_v4, process.HLT_PFJet200_TimeLtNeg2p5ns_v14, process.HLT_PFJet200_TimeGt2p5ns_v14, process.HLT_Photon50_TimeLtNeg2p5ns_v8, process.HLT_Photon50_TimeGt2p5ns_v8, process.HLT_PPSMaxTracksPerArm1_v10, process.HLT_PPSMaxTracksPerRP4_v10, process.HLT_PPSRandom_v1, process.HLT_TestData_v1, process.MC_ReducedIterativeTracking_v26, process.MC_AK4CaloJets_v21, process.MC_AK4CaloJetsFromPV_v21, process.MC_CaloHT_v20, process.MC_AK8CaloHT_v20, process.MC_CaloMHT_v20, process.MC_AK4PFJets_v33, process.MC_PFHT_v32, process.MC_AK8PFJets_v33, process.MC_AK8PFHT_v32, process.MC_CaloMET_v20, process.MC_CaloMET_JetIdCleaned_v21, process.MC_PFMET_v33, process.MC_PFMHT_v32, process.MC_AK4PFJetPNet_v9, process.MC_AK8PFJetPNet_v9, process.MC_Egamma_Open_v12, process.MC_Egamma_Open_Unseeded_v12, process.MC_Ele5_WPTight_Gsf_v23, process.MC_Ele15_Ele10_CaloIdL_TrackIdL_IsoVL_DZ_v29, process.MC_Diphoton10_10_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass10_v26, process.MC_DoubleEle5_CaloIdL_MW_v29, process.MC_IsoMu_v31, process.MC_DoubleMu_TrkIsoVVL_DZ_v27, process.MC_DoubleMuNoFiltersNoVtx_v20, process.MC_PFScouting_v10, process.HLT_L1AlwaysTrue_v1, process.HLT_L1AXOVVTight_v1, process.HLT_L1AXOVVVTight_v1, process.HLT_L1CICADA_VVTight_v1, process.HLT_L1CICADA_VVVTight_v1, process.HLT_L1CICADA_VVVVTight_v1, process.HLTriggerFinalPath, process.HLTAnalyzerEndpath, process.Dataset_AlCaHcalIsoTrk, process.Dataset_AlCaLowPtJet, process.Dataset_AlCaLumiPixelsCountsExpress, process.Dataset_AlCaLumiPixelsCountsPrompt, process.Dataset_AlCaP0, process.Dataset_AlCaPPSExpress, process.Dataset_AlCaPPSPrompt, process.Dataset_AlCaPhiSym, process.Dataset_BTagMu, process.Dataset_Commissioning, process.Dataset_Cosmics, process.Dataset_DQMGPUvsCPU, process.Dataset_DQMOnlineBeamspot, process.Dataset_DQMPPSRandom, process.Dataset_EGamma0, process.Dataset_EGamma1, process.Dataset_EGamma2, process.Dataset_EGamma3, process.Dataset_EcalLaser, process.Dataset_EphemeralHLTPhysics0, process.Dataset_EphemeralHLTPhysics1, process.Dataset_EphemeralHLTPhysics2, process.Dataset_EphemeralHLTPhysics3, process.Dataset_EphemeralHLTPhysics4, process.Dataset_EphemeralHLTPhysics5, process.Dataset_EphemeralHLTPhysics6, process.Dataset_EphemeralHLTPhysics7, process.Dataset_EphemeralZeroBias0, process.Dataset_EphemeralZeroBias1, process.Dataset_EphemeralZeroBias2, process.Dataset_EphemeralZeroBias3, process.Dataset_EphemeralZeroBias4, process.Dataset_EphemeralZeroBias5, process.Dataset_EphemeralZeroBias6, process.Dataset_EphemeralZeroBias7, process.Dataset_EventDisplay, process.Dataset_ExpressAlignment, process.Dataset_ExpressPhysics, process.Dataset_HLTMonitor, process.Dataset_HLTPhysics, process.Dataset_HcalNZS, process.Dataset_JetMET0, process.Dataset_JetMET1, process.Dataset_L1Accept, process.Dataset_MonteCarlo, process.Dataset_Muon0, process.Dataset_Muon1, process.Dataset_MuonEG, process.Dataset_NoBPTX, process.Dataset_OnlineMonitor, process.Dataset_ParkingDoubleMuonLowMass0, process.Dataset_ParkingDoubleMuonLowMass1, process.Dataset_ParkingDoubleMuonLowMass2, process.Dataset_ParkingDoubleMuonLowMass3, process.Dataset_ParkingDoubleMuonLowMass4, process.Dataset_ParkingDoubleMuonLowMass5, process.Dataset_ParkingDoubleMuonLowMass6, process.Dataset_ParkingDoubleMuonLowMass7, process.Dataset_ParkingHH0, process.Dataset_ParkingHH1, process.Dataset_ParkingLLP0, process.Dataset_ParkingLLP1, process.Dataset_ParkingSingleMuon0, process.Dataset_ParkingSingleMuon1, process.Dataset_ParkingSingleMuon2, process.Dataset_ParkingSingleMuon3, process.Dataset_ParkingSingleMuon4, process.Dataset_ParkingSingleMuon5, process.Dataset_ParkingSingleMuon6, process.Dataset_ParkingSingleMuon7, process.Dataset_ParkingSingleMuon8, process.Dataset_ParkingSingleMuon9, process.Dataset_ParkingSingleMuon10, process.Dataset_ParkingSingleMuon11, process.Dataset_ParkingSingleMuon12, process.Dataset_ParkingSingleMuon13, process.Dataset_ParkingSingleMuon14, process.Dataset_ParkingSingleMuon15, process.Dataset_ParkingVBF0, process.Dataset_ParkingVBF1, process.Dataset_ParkingVBF2, process.Dataset_ParkingVBF3, process.Dataset_ParkingVBF4, process.Dataset_ParkingVBF5, process.Dataset_ParkingVBF6, process.Dataset_ParkingVBF7, process.Dataset_ParkingAnomalyDetection, process.Dataset_RPCMonitor, process.Dataset_ScoutingPFMonitor, process.Dataset_ScoutingPF0, process.Dataset_ScoutingPF1, process.Dataset_Tau, process.Dataset_TestEnablesEcalHcal, process.Dataset_TestEnablesEcalHcalDQM, process.Dataset_ZeroBias, process.Dataset_TestDataRaw, process.Dataset_TestDataScouting, process.Dataset_EmittanceScan0, process.Dataset_EmittanceScan1, process.Dataset_EmittanceScan2, process.Dataset_EmittanceScan3, process.Dataset_EmittanceScan4, process.Dataset_EmittanceScan5, process.Dataset_DQMOnlineScouting, process.ALCAHcalIsoTrkOutput, process.ALCALowPtJetOutput, process.ALCALumiPixelsCountsExpressOutput, process.ALCALumiPixelsCountsPromptOutput, process.ALCAP0Output, process.ALCAPHISYMOutput, process.ALCAPPSExpressOutput, process.ALCAPPSPromptOutput, process.CalibrationOutput, process.DQMOutput, process.DQMCalibrationOutput, process.DQMEventDisplayOutput, process.DQMGPUvsCPUOutput, process.DQMOnlineBeamspotOutput, process.DQMOnlineScoutingOutput, process.DQMPPSRandomOutput, process.EcalCalibrationOutput, process.ExpressOutput, process.ExpressAlignmentOutput, process.HLTMonitorOutput, process.NanoDSTOutput, process.ParkingDoubleMuonLowMass0Output, process.ParkingDoubleMuonLowMass1Output, process.ParkingDoubleMuonLowMass2Output, process.ParkingDoubleMuonLowMass3Output, process.ParkingHHOutput, process.ParkingLLPOutput, process.ParkingSingleMuon0Output, process.ParkingSingleMuon1Output, process.ParkingSingleMuon10Output, process.ParkingSingleMuon11Output, process.ParkingSingleMuon12Output, process.ParkingSingleMuon13Output, process.ParkingSingleMuon14Output, process.ParkingSingleMuon15Output, process.ParkingSingleMuon2Output, process.ParkingSingleMuon3Output, process.ParkingSingleMuon4Output, process.ParkingSingleMuon5Output, process.ParkingSingleMuon6Output, process.ParkingSingleMuon7Output, process.ParkingSingleMuon8Output, process.ParkingSingleMuon9Output, process.ParkingVBF0Output, process.ParkingVBF1Output, process.ParkingVBF2Output, process.ParkingVBF3Output, process.ParkingAnomalyDetectionOutput, process.PhysicsCommissioningOutput, process.PhysicsBTagMuEGTauOutput, process.PhysicsEGamma0Output, process.PhysicsEGamma1Output, process.PhysicsEGamma2Output, process.PhysicsEGamma3Output, process.PhysicsHLTPhysics0Output, process.PhysicsHLTPhysics1Output, process.PhysicsHLTPhysics2Output, process.PhysicsHLTPhysics3Output, process.PhysicsJetMET0Output, process.PhysicsJetMET1Output, process.PhysicsMuon0Output, process.PhysicsMuon1Output, process.PhysicsScoutingPFMonitorOutput, process.PhysicsZeroBias0Output, process.PhysicsZeroBias1Output, process.PhysicsZeroBias2Output, process.PhysicsZeroBias3Output, process.PhysicsEmittanceScan0Output, process.PhysicsEmittanceScan1Output, process.PhysicsEmittanceScan2Output, process.RPCMONOutput, process.ScoutingPF0Output, process.ScoutingPF1Output, process.LocalTestDataRawOutput, process.LocalTestDataScoutingOutput, )) # source module (EDM inputs) diff --git a/HLTrigger/Configuration/test/OnLine_HLT_HIon.py b/HLTrigger/Configuration/test/OnLine_HLT_HIon.py index a524a71655f3c..f9c55504ae2c2 100644 --- a/HLTrigger/Configuration/test/OnLine_HLT_HIon.py +++ b/HLTrigger/Configuration/test/OnLine_HLT_HIon.py @@ -1,6 +1,6 @@ -# hltGetConfiguration /dev/CMSSW_15_0_0/HIon --full --data --type HIon --unprescale --process HLTHIon --globaltag auto:run3_hlt_HIon --input file:RelVal_Raw_HIon_DATA.root +# hltGetConfiguration /dev/CMSSW_15_1_0/HIon --full --data --type HIon --unprescale --process HLTHIon --globaltag auto:run3_hlt_HIon --input file:RelVal_Raw_HIon_DATA.root -# /dev/CMSSW_15_0_0/HIon/V114 (CMSSW_15_0_11) +# /dev/CMSSW_15_1_0/HIon/V10 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms @@ -9,7 +9,7 @@ process.load("Configuration.StandardSequences.Accelerators_cff") process.HLTConfigVersion = cms.PSet( - tableName = cms.string("/dev/CMSSW_15_0_0/HIon/V114") + tableName = cms.string("/dev/CMSSW_15_1_0/HIon/V10") ) process.HLTGroupedCkfTrajectoryBuilderP5 = cms.PSet( @@ -9491,7 +9491,9 @@ 'EcalPreshower', 'TOWER' ) ) -process.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder" ) +process.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder", + appendToDataLabel = cms.string( "" ) +) process.CaloTowerConstituentsMapBuilder = cms.ESProducer( "CaloTowerConstituentsMapBuilder", MapFile = cms.untracked.string( "Geometry/CaloTopology/data/CaloTowerEEGeometric.map.gz" ), MapAuto = cms.untracked.bool( False ), @@ -9590,67 +9592,81 @@ appendToDataLabel = cms.string( "" ) ) process.MaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterial" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.MaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.MaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMf" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOppositeForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositePropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStepOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) process.ParametrizedMagneticFieldProducer = cms.ESProducer( "AutoParametrizedMagneticFieldProducer", version = cms.string( "Parabolic" ), @@ -9658,22 +9674,26 @@ valueOverride = cms.int32( -1 ) ) process.PropagatorWithMaterialForLoopers = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 4.0 ), ComponentName = cms.string( "PropagatorWithMaterialForLoopers" ), Mass = cms.double( 0.1396 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 4.0 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.PropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStep" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) process.RPCGeometryESModule = cms.ESProducer( "RPCGeometryESModule", fromDDD = cms.untracked.bool( False ), @@ -9883,7 +9903,9 @@ ), timeThresh = cms.double( 2.0 ) ) -process.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP" ) +process.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP", + appendToDataLabel = cms.string( "" ) +) process.hcalDDDRecConstants = cms.ESProducer( "HcalDDDRecConstantsESModule", appendToDataLabel = cms.string( "" ) ) @@ -10185,13 +10207,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPBwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPBwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPChi2ChargeLooseMeasurementEstimator16 = cms.ESProducer( "Chi2ChargeMeasurementEstimatorESProducer", MaxChi2 = cms.double( 16.0 ), @@ -10570,13 +10594,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPFwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPFwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPGlobalDetLayerGeometry = cms.ESProducer( "GlobalDetLayerGeometryESProducer", ComponentName = cms.string( "hltESPGlobalDetLayerGeometry" ), @@ -11152,13 +11178,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPRungeKuttaTrackerPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPRungeKuttaTrackerPropagator" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( True ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPSiPixelCablingSoA = cms.ESProducer( "SiPixelCablingSoAESProducer@alpaka", CablingMapLabel = cms.string( "" ), @@ -11257,7 +11285,8 @@ mTIB_P0 = cms.double( -0.742 ), mTID_P1 = cms.double( 0.433 ), mTID_P0 = cms.double( -1.427 ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.hltESPTTRHBWithTrackAngle = cms.ESProducer( "TkTransientTrackingRecHitBuilderESProducer", ComponentName = cms.string( "hltESPTTRHBWithTrackAngle" ), @@ -11532,7 +11561,9 @@ UseQualityInfo = cms.bool( False ), appendToDataLabel = cms.string( "" ) ) -process.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer" ) +process.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer", + appendToDataLabel = cms.string( "" ) +) process.siStripBackPlaneCorrectionDepESProducer = cms.ESProducer( "SiStripBackPlaneCorrectionDepESProducer", LatencyRecord = cms.PSet( label = cms.untracked.string( "" ), @@ -11545,7 +11576,8 @@ BackPlaneCorrectionDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripBackPlaneCorrectionRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.siStripLorentzAngleDepESProducer = cms.ESProducer( "SiStripLorentzAngleDepESProducer", LatencyRecord = cms.PSet( @@ -11559,7 +11591,8 @@ LorentzAngleDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripLorentzAngleRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.sistripconn = cms.ESProducer( "SiStripConnectivity" ) process.trackerTopology = cms.ESProducer( "TrackerTopologyEP", @@ -11808,9 +11841,9 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -12475,14 +12508,22 @@ process.hltSiPixelClustersPPOnAASoA = cms.EDProducer( "SiPixelRawToClusterHIonPhase1@alpaka", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 1000 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) @@ -12512,6 +12553,7 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltSiPixelRecHitsPPOnAA = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaHIonPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsPPOnAASoA" ), src = cms.InputTag( "hltSiPixelClustersPPOnAA" ) ) @@ -12521,14 +12563,22 @@ process.hltSiPixelClustersPPOnAASoASerialSync = cms.EDProducer( "alpaka_serial_sync::SiPixelRawToClusterHIonPhase1", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 1000 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ) ) process.hltSiPixelClustersPPOnAASerialSync = cms.EDProducer( "SiPixelDigisClustersFromSoAAlpakaHIonPhase1", @@ -12556,50 +12606,59 @@ CPE = cms.string( "PixelCPEFastParamsHIonPhase1" ) ) process.hltSiPixelRecHitsPPOnAASerialSync = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaHIonPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsPPOnAASoASerialSync" ), src = cms.InputTag( "hltSiPixelClustersPPOnAASerialSync" ) ) process.hltPixelTracksPPOnAASoA = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaHIonPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsPPOnAASoA" ), - CPE = cms.string( "PixelCPEFastParamsHIonPhase1" ), - ptmin = cms.double( 0.8999999761581421 ), - CAThetaCutBarrel = cms.double( 0.0010000000949949026 ), - CAThetaCutForward = cms.double( 0.002000000026077032 ), - hardCurvCut = cms.double( 0.03284072249589491 ), - dcaCutInnerTriplet = cms.double( 0.05000000596046448 ), - dcaCutOuterTriplet = cms.double( 0.1 ), + cellZ0Cut = cms.double( 8.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 36 ), + minYsizeB2 = cms.int32( 28 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "3145728" ), + maxNumberOfTuples = cms.string( "262144" ), + avgHitsPerTrack = cms.double( 5.0 ), + avgCellsPerHit = cms.double( 40.0 ), + avgCellsPerCell = cms.double( 0.5 ), + avgTracksPerCell = cms.double( 0.5 ), + ptmin = cms.double( 0.899999976158 ), + hardCurvCut = cms.double( 0.0328407224959 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 4 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 3145728 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 8.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), - chi2Coeff = cms.vdouble( 0.9, 1.8 ), - chi2Scale = cms.double( 1.8 ), - tripletMinPt = cms.double( 0.1 ), tripletMaxTip = cms.double( 0.3 ), - tripletMaxZip = cms.double( 12.0 ), - quadrupletMinPt = cms.double( 0.1 ), + chi2Scale = cms.double( 1.8 ), quadrupletMaxTip = cms.double( 0.5 ), - quadrupletMaxZip = cms.double( 12.0 ) - ), - minYsizeB1 = cms.int32( 36 ), - minYsizeB2 = cms.int32( 28 ), - phiCuts = cms.vint32( 522, 730, 730, 522, 626, 626, 522, 522, 626, 626, 626, 522, 522, 522, 522, 522, 522, 522, 522 ) + quadrupletMinPt = cms.double( 0.1 ), + quadrupletMaxZip = cms.double( 12.0 ), + tripletMaxZip = cms.double( 12.0 ), + tripletMinPt = cms.double( 0.1 ), + chi2Coeff = cms.vdouble( 0.9, 1.8 ) + ), + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.001, 0.001, 0.001, 0.001, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.05, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 522, 730, 730, 522, 626, 626, 522, 522, 626, 626, 626, 522, 522, 522, 522, 522, 522, 522, 522 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) process.hltPixelTracksPPOnAA = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaHIonPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -12637,45 +12696,53 @@ ) process.hltPixelTracksPPOnAASoASerialSync = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaHIonPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsPPOnAASoASerialSync" ), - CPE = cms.string( "PixelCPEFastParamsHIonPhase1" ), - ptmin = cms.double( 0.8999999761581421 ), - CAThetaCutBarrel = cms.double( 0.0010000000949949026 ), - CAThetaCutForward = cms.double( 0.002000000026077032 ), - hardCurvCut = cms.double( 0.03284072249589491 ), - dcaCutInnerTriplet = cms.double( 0.05000000596046448 ), - dcaCutOuterTriplet = cms.double( 0.1 ), + cellZ0Cut = cms.double( 8.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 36 ), + minYsizeB2 = cms.int32( 28 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "3145728" ), + maxNumberOfTuples = cms.string( "262144" ), + avgHitsPerTrack = cms.double( 5.0 ), + avgCellsPerHit = cms.double( 40.0 ), + avgCellsPerCell = cms.double( 0.5 ), + avgTracksPerCell = cms.double( 0.5 ), + ptmin = cms.double( 0.899999976158 ), + hardCurvCut = cms.double( 0.0328407224959 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 4 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 3145728 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 8.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), - chi2Coeff = cms.vdouble( 0.9, 1.8 ), - chi2Scale = cms.double( 1.8 ), - tripletMinPt = cms.double( 0.1 ), tripletMaxTip = cms.double( 0.3 ), - tripletMaxZip = cms.double( 12.0 ), - quadrupletMinPt = cms.double( 0.1 ), + chi2Scale = cms.double( 1.8 ), quadrupletMaxTip = cms.double( 0.5 ), - quadrupletMaxZip = cms.double( 12.0 ) - ), - minYsizeB1 = cms.int32( 36 ), - minYsizeB2 = cms.int32( 28 ), - phiCuts = cms.vint32( 522, 730, 730, 522, 626, 626, 522, 522, 626, 626, 626, 522, 522, 522, 522, 522, 522, 522, 522 ) + quadrupletMinPt = cms.double( 0.1 ), + quadrupletMaxZip = cms.double( 12.0 ), + tripletMaxZip = cms.double( 12.0 ), + tripletMinPt = cms.double( 0.1 ), + chi2Coeff = cms.vdouble( 0.9, 1.8 ) + ), + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.001, 0.001, 0.001, 0.001, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.05, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 522, 730, 730, 522, 626, 626, 522, 522, 626, 626, 626, 522, 522, 522, 522, 522, 522, 522, 522 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) process.hltPixelTracksPPOnAASerialSync = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaHIonPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -12825,9 +12892,9 @@ shouldRunTimingComputation = cms.bool( True ) ) process.hltEcalUncalibRecHitSerialSync = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -13693,7 +13760,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 107 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( True ) ) process.hltPreHIPhysics = cms.EDFilter( "HLTPrescaler", @@ -13719,7 +13786,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 4096 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( False ) ) process.hltL1sHIHcalNZS = cms.EDFilter( "HLTL1TSeed", @@ -13899,74 +13966,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -18338,74 +18405,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0E-99 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.1 ), HBThreshold2 = cms.double( 0.2 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0E-99 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 11 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( True ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "" ), + hoInput = cms.InputTag( "" ), + ecalInputs = cms.VInputTag( ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 11 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -19928,7 +19995,7 @@ trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "" ), produceSeedingHitSets = cms.bool( True ), - produceIntermediateHitDoublets = cms.bool( True ), + produceIntermediateHitDoublets = cms.bool( False ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), putEmptyIfMaxElementReached = cms.bool( False ), @@ -19950,7 +20017,7 @@ trackingRegions = cms.InputTag( "hltEleSeedsTrackingRegionsPPOnAA" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -25874,7 +25941,7 @@ trackingRegions = cms.InputTag( "hltFullIter2PixelTrackingRegionsPPOnAAForDmeson" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter2PixelClusterCheckPPOnAAForDmeson" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -26078,7 +26145,7 @@ trackingRegions = cms.InputTag( "hltFullIter3PixelTrackingRegionsPPOnAA" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter3PixelClusterCheckPPOnAA" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -26277,7 +26344,7 @@ trackingRegions = cms.InputTag( "hltFullIter7MixedTrackingRegionsAPPOnAA" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter7MixedClusterCheckPPOnAA" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -26374,7 +26441,7 @@ trackingRegions = cms.InputTag( "hltFullIter7MixedTrackingRegionsBPPOnAA" ), trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter7MixedClusterCheckPPOnAA" ), - produceSeedingHitSets = cms.bool( True ), + produceSeedingHitSets = cms.bool( False ), produceIntermediateHitDoublets = cms.bool( True ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), @@ -26972,7 +27039,7 @@ trackingRegionsSeedingLayers = cms.InputTag( "" ), clusterCheck = cms.InputTag( "hltFullIter9TobTecClusterCheckPPOnAA" ), produceSeedingHitSets = cms.bool( True ), - produceIntermediateHitDoublets = cms.bool( True ), + produceIntermediateHitDoublets = cms.bool( False ), maxElement = cms.uint32( 0 ), maxElementTotal = cms.uint32( 50000000 ), putEmptyIfMaxElementReached = cms.bool( False ), diff --git a/HLTrigger/Configuration/test/OnLine_HLT_PIon.py b/HLTrigger/Configuration/test/OnLine_HLT_PIon.py index 6159298ba2cc3..78795ffd99c22 100644 --- a/HLTrigger/Configuration/test/OnLine_HLT_PIon.py +++ b/HLTrigger/Configuration/test/OnLine_HLT_PIon.py @@ -1,6 +1,6 @@ -# hltGetConfiguration /dev/CMSSW_15_0_0/PIon --full --data --type PIon --unprescale --process HLTPIon --globaltag auto:run3_hlt_PIon --input file:RelVal_Raw_PIon_DATA.root +# hltGetConfiguration /dev/CMSSW_15_1_0/PIon --full --data --type PIon --unprescale --process HLTPIon --globaltag auto:run3_hlt_PIon --input file:RelVal_Raw_PIon_DATA.root -# /dev/CMSSW_15_0_0/PIon/V114 (CMSSW_15_0_11) +# /dev/CMSSW_15_1_0/PIon/V10 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms @@ -9,7 +9,7 @@ process.load("Configuration.StandardSequences.Accelerators_cff") process.HLTConfigVersion = cms.PSet( - tableName = cms.string("/dev/CMSSW_15_0_0/PIon/V114") + tableName = cms.string("/dev/CMSSW_15_1_0/PIon/V10") ) process.HLTGroupedCkfTrajectoryBuilderP5 = cms.PSet( @@ -1623,7 +1623,9 @@ 'EcalPreshower', 'TOWER' ) ) -process.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder" ) +process.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder", + appendToDataLabel = cms.string( "" ) +) process.CaloTowerConstituentsMapBuilder = cms.ESProducer( "CaloTowerConstituentsMapBuilder", MapFile = cms.untracked.string( "Geometry/CaloTopology/data/CaloTowerEEGeometric.map.gz" ), MapAuto = cms.untracked.bool( False ), @@ -1722,67 +1724,81 @@ appendToDataLabel = cms.string( "" ) ) process.MaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterial" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.MaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.MaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMf" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOppositeForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositePropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStepOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) process.ParametrizedMagneticFieldProducer = cms.ESProducer( "AutoParametrizedMagneticFieldProducer", version = cms.string( "Parabolic" ), @@ -1790,22 +1806,26 @@ valueOverride = cms.int32( -1 ) ) process.PropagatorWithMaterialForLoopers = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 4.0 ), ComponentName = cms.string( "PropagatorWithMaterialForLoopers" ), Mass = cms.double( 0.1396 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 4.0 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.PropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStep" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) process.RPCGeometryESModule = cms.ESProducer( "RPCGeometryESModule", fromDDD = cms.untracked.bool( False ), @@ -2015,7 +2035,9 @@ ), timeThresh = cms.double( 2.0 ) ) -process.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP" ) +process.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP", + appendToDataLabel = cms.string( "" ) +) process.hcalDDDRecConstants = cms.ESProducer( "HcalDDDRecConstantsESModule", appendToDataLabel = cms.string( "" ) ) @@ -2317,13 +2339,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPBwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPBwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPChi2ChargeLooseMeasurementEstimator16 = cms.ESProducer( "Chi2ChargeMeasurementEstimatorESProducer", MaxChi2 = cms.double( 16.0 ), @@ -2702,13 +2726,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPFwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPFwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPGlobalDetLayerGeometry = cms.ESProducer( "GlobalDetLayerGeometryESProducer", ComponentName = cms.string( "hltESPGlobalDetLayerGeometry" ), @@ -3284,13 +3310,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPRungeKuttaTrackerPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPRungeKuttaTrackerPropagator" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( True ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPSiPixelCablingSoA = cms.ESProducer( "SiPixelCablingSoAESProducer@alpaka", CablingMapLabel = cms.string( "" ), @@ -3389,7 +3417,8 @@ mTIB_P0 = cms.double( -0.742 ), mTID_P1 = cms.double( 0.433 ), mTID_P0 = cms.double( -1.427 ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.hltESPTTRHBWithTrackAngle = cms.ESProducer( "TkTransientTrackingRecHitBuilderESProducer", ComponentName = cms.string( "hltESPTTRHBWithTrackAngle" ), @@ -3664,7 +3693,9 @@ UseQualityInfo = cms.bool( False ), appendToDataLabel = cms.string( "" ) ) -process.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer" ) +process.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer", + appendToDataLabel = cms.string( "" ) +) process.siStripBackPlaneCorrectionDepESProducer = cms.ESProducer( "SiStripBackPlaneCorrectionDepESProducer", LatencyRecord = cms.PSet( label = cms.untracked.string( "" ), @@ -3677,7 +3708,8 @@ BackPlaneCorrectionDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripBackPlaneCorrectionRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.siStripLorentzAngleDepESProducer = cms.ESProducer( "SiStripLorentzAngleDepESProducer", LatencyRecord = cms.PSet( @@ -3691,7 +3723,8 @@ LorentzAngleDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripLorentzAngleRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.sistripconn = cms.ESProducer( "SiStripConnectivity" ) process.trackerTopology = cms.ESProducer( "TrackerTopologyEP", @@ -3940,9 +3973,9 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -4604,14 +4637,22 @@ process.hltSiPixelClustersSoA = cms.EDProducer( "SiPixelRawToClusterPhase1@alpaka", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) @@ -4637,6 +4678,7 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltSiPixelRecHits = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), src = cms.InputTag( "hltSiPixelClusters" ) ) @@ -4685,14 +4727,22 @@ process.hltSiPixelClustersSoASerialSync = cms.EDProducer( "alpaka_serial_sync::SiPixelRawToClusterPhase1", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ) ) process.hltSiPixelClustersSerialSync = cms.EDProducer( "SiPixelDigisClustersFromSoAAlpakaPhase1", @@ -4716,36 +4766,38 @@ CPE = cms.string( "PixelCPEFastParams" ) ) process.hltSiPixelRecHitsSerialSync = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), src = cms.InputTag( "hltSiPixelClustersSerialSync" ) ) process.hltPixelTracksSoA = cms.EDProducer( "CAHitNtupletAlpakaPhase1@alpaka", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -4757,9 +4809,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltPixelTracks = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", @@ -4799,31 +4858,32 @@ ) process.hltPixelTracksSoASerialSync = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -4835,9 +4895,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ) + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) process.hltPixelTracksSerialSync = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -4987,9 +5054,9 @@ shouldRunTimingComputation = cms.bool( True ) ) process.hltEcalUncalibRecHitSerialSync = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -5672,7 +5739,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 4096 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( False ) ) process.hltL1sHcalNZS = cms.EDFilter( "HLTL1TSeed", @@ -5717,7 +5784,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 107 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( True ) ) process.hltPrePhysics = cms.EDFilter( "HLTPrescaler", @@ -5749,74 +5816,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) diff --git a/HLTrigger/Configuration/test/OnLine_HLT_PRef.py b/HLTrigger/Configuration/test/OnLine_HLT_PRef.py index 7cb58784a248d..707e779eb17e6 100644 --- a/HLTrigger/Configuration/test/OnLine_HLT_PRef.py +++ b/HLTrigger/Configuration/test/OnLine_HLT_PRef.py @@ -1,6 +1,6 @@ -# hltGetConfiguration /dev/CMSSW_15_0_0/PRef --full --data --type PRef --unprescale --process HLTPRef --globaltag auto:run3_hlt_PRef --input file:RelVal_Raw_PRef_DATA.root +# hltGetConfiguration /dev/CMSSW_15_1_0/PRef --full --data --type PRef --unprescale --process HLTPRef --globaltag auto:run3_hlt_PRef --input file:RelVal_Raw_PRef_DATA.root -# /dev/CMSSW_15_0_0/PRef/V114 (CMSSW_15_0_11) +# /dev/CMSSW_15_1_0/PRef/V10 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms @@ -9,7 +9,7 @@ process.load("Configuration.StandardSequences.Accelerators_cff") process.HLTConfigVersion = cms.PSet( - tableName = cms.string("/dev/CMSSW_15_0_0/PRef/V114") + tableName = cms.string("/dev/CMSSW_15_1_0/PRef/V10") ) process.HLTGroupedCkfTrajectoryBuilderP5 = cms.PSet( @@ -2386,7 +2386,9 @@ 'EcalPreshower', 'TOWER' ) ) -process.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder" ) +process.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder", + appendToDataLabel = cms.string( "" ) +) process.CaloTowerConstituentsMapBuilder = cms.ESProducer( "CaloTowerConstituentsMapBuilder", MapFile = cms.untracked.string( "Geometry/CaloTopology/data/CaloTowerEEGeometric.map.gz" ), MapAuto = cms.untracked.bool( False ), @@ -2485,67 +2487,81 @@ appendToDataLabel = cms.string( "" ) ) process.MaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterial" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.MaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.MaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMf" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOppositeForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositePropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStepOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) process.ParametrizedMagneticFieldProducer = cms.ESProducer( "AutoParametrizedMagneticFieldProducer", version = cms.string( "Parabolic" ), @@ -2553,22 +2569,26 @@ valueOverride = cms.int32( -1 ) ) process.PropagatorWithMaterialForLoopers = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 4.0 ), ComponentName = cms.string( "PropagatorWithMaterialForLoopers" ), Mass = cms.double( 0.1396 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 4.0 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.PropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStep" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) process.RPCGeometryESModule = cms.ESProducer( "RPCGeometryESModule", fromDDD = cms.untracked.bool( False ), @@ -2778,7 +2798,9 @@ ), timeThresh = cms.double( 2.0 ) ) -process.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP" ) +process.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP", + appendToDataLabel = cms.string( "" ) +) process.hcalDDDRecConstants = cms.ESProducer( "HcalDDDRecConstantsESModule", appendToDataLabel = cms.string( "" ) ) @@ -3080,13 +3102,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPBwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPBwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPChi2ChargeLooseMeasurementEstimator16 = cms.ESProducer( "Chi2ChargeMeasurementEstimatorESProducer", MaxChi2 = cms.double( 16.0 ), @@ -3465,13 +3489,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPFwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPFwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPGlobalDetLayerGeometry = cms.ESProducer( "GlobalDetLayerGeometryESProducer", ComponentName = cms.string( "hltESPGlobalDetLayerGeometry" ), @@ -4047,13 +4073,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPRungeKuttaTrackerPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPRungeKuttaTrackerPropagator" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( True ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPSiPixelCablingSoA = cms.ESProducer( "SiPixelCablingSoAESProducer@alpaka", CablingMapLabel = cms.string( "" ), @@ -4152,7 +4180,8 @@ mTIB_P0 = cms.double( -0.742 ), mTID_P1 = cms.double( 0.433 ), mTID_P0 = cms.double( -1.427 ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.hltESPTTRHBWithTrackAngle = cms.ESProducer( "TkTransientTrackingRecHitBuilderESProducer", ComponentName = cms.string( "hltESPTTRHBWithTrackAngle" ), @@ -4427,7 +4456,9 @@ UseQualityInfo = cms.bool( False ), appendToDataLabel = cms.string( "" ) ) -process.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer" ) +process.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer", + appendToDataLabel = cms.string( "" ) +) process.siStripBackPlaneCorrectionDepESProducer = cms.ESProducer( "SiStripBackPlaneCorrectionDepESProducer", LatencyRecord = cms.PSet( label = cms.untracked.string( "" ), @@ -4440,7 +4471,8 @@ BackPlaneCorrectionDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripBackPlaneCorrectionRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.siStripLorentzAngleDepESProducer = cms.ESProducer( "SiStripLorentzAngleDepESProducer", LatencyRecord = cms.PSet( @@ -4454,7 +4486,8 @@ LorentzAngleDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripLorentzAngleRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.sistripconn = cms.ESProducer( "SiStripConnectivity" ) process.trackerTopology = cms.ESProducer( "TrackerTopologyEP", @@ -4703,9 +4736,9 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -5367,14 +5400,22 @@ process.hltSiPixelClustersSoA = cms.EDProducer( "SiPixelRawToClusterPhase1@alpaka", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) @@ -5400,6 +5441,7 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltSiPixelRecHits = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), src = cms.InputTag( "hltSiPixelClusters" ) ) @@ -5448,14 +5490,22 @@ process.hltSiPixelClustersSoASerialSync = cms.EDProducer( "alpaka_serial_sync::SiPixelRawToClusterPhase1", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ) ) process.hltSiPixelClustersSerialSync = cms.EDProducer( "SiPixelDigisClustersFromSoAAlpakaPhase1", @@ -5479,36 +5529,38 @@ CPE = cms.string( "PixelCPEFastParams" ) ) process.hltSiPixelRecHitsSerialSync = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), src = cms.InputTag( "hltSiPixelClustersSerialSync" ) ) process.hltPixelTracksSoA = cms.EDProducer( "CAHitNtupletAlpakaPhase1@alpaka", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -5520,9 +5572,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltPixelTracks = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", @@ -5562,31 +5621,32 @@ ) process.hltPixelTracksSoASerialSync = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -5598,9 +5658,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ) + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) process.hltPixelTracksSerialSync = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -5750,9 +5817,9 @@ shouldRunTimingComputation = cms.bool( True ) ) process.hltEcalUncalibRecHitSerialSync = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -6435,7 +6502,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 4096 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( False ) ) process.hltL1sHcalNZS = cms.EDFilter( "HLTL1TSeed", @@ -6480,7 +6547,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 107 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( True ) ) process.hltPrePhysics = cms.EDFilter( "HLTPrescaler", @@ -6512,74 +6579,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) diff --git a/HLTrigger/Configuration/test/OnLine_HLT_Special.py b/HLTrigger/Configuration/test/OnLine_HLT_Special.py index 0a73d3ae28aa8..da27b1eb3ce6f 100644 --- a/HLTrigger/Configuration/test/OnLine_HLT_Special.py +++ b/HLTrigger/Configuration/test/OnLine_HLT_Special.py @@ -1,6 +1,6 @@ -# hltGetConfiguration /dev/CMSSW_15_0_0/Special --full --data --type Special --unprescale --process HLTSpecial --globaltag auto:run3_hlt_Special --input file:RelVal_Raw_Special_DATA.root +# hltGetConfiguration /dev/CMSSW_15_1_0/Special --full --data --type Special --unprescale --process HLTSpecial --globaltag auto:run3_hlt_Special --input file:RelVal_Raw_Special_DATA.root -# /dev/CMSSW_15_0_0/Special/V114 (CMSSW_15_0_11) +# /dev/CMSSW_15_1_0/Special/V10 (CMSSW_15_1_0) import FWCore.ParameterSet.Config as cms @@ -9,7 +9,7 @@ process.load("Configuration.StandardSequences.Accelerators_cff") process.HLTConfigVersion = cms.PSet( - tableName = cms.string("/dev/CMSSW_15_0_0/Special/V114") + tableName = cms.string("/dev/CMSSW_15_1_0/Special/V10") ) process.HLTGroupedCkfTrajectoryBuilderP5 = cms.PSet( @@ -1975,7 +1975,9 @@ 'EcalPreshower', 'TOWER' ) ) -process.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder" ) +process.CaloTopologyBuilder = cms.ESProducer( "CaloTopologyBuilder", + appendToDataLabel = cms.string( "" ) +) process.CaloTowerConstituentsMapBuilder = cms.ESProducer( "CaloTowerConstituentsMapBuilder", MapFile = cms.untracked.string( "Geometry/CaloTopology/data/CaloTowerEEGeometric.map.gz" ), MapAuto = cms.untracked.bool( False ), @@ -2074,67 +2076,81 @@ appendToDataLabel = cms.string( "" ) ) process.MaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterial" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.MaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.MaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMf" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagatorForHI = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialOppositeForHI" ), Mass = cms.double( 0.139 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositeMaterialPropagatorParabolicMF = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialParabolicMfOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.OppositePropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStepOpposite" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) process.ParametrizedMagneticFieldProducer = cms.ESProducer( "AutoParametrizedMagneticFieldProducer", version = cms.string( "Parabolic" ), @@ -2142,22 +2158,26 @@ valueOverride = cms.int32( -1 ) ) process.PropagatorWithMaterialForLoopers = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 4.0 ), ComponentName = cms.string( "PropagatorWithMaterialForLoopers" ), Mass = cms.double( 0.1396 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 4.0 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.PropagatorWithMaterialForMixedStep = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "ParabolicMf" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "PropagatorWithMaterialForMixedStep" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( 0.1 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( 0.1 ), + appendToDataLabel = cms.string( "" ) ) process.RPCGeometryESModule = cms.ESProducer( "RPCGeometryESModule", fromDDD = cms.untracked.bool( False ), @@ -2367,7 +2387,9 @@ ), timeThresh = cms.double( 2.0 ) ) -process.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP" ) +process.hcalChannelPropertiesESProd = cms.ESProducer( "HcalChannelPropertiesEP", + appendToDataLabel = cms.string( "" ) +) process.hcalDDDRecConstants = cms.ESProducer( "HcalDDDRecConstantsESModule", appendToDataLabel = cms.string( "" ) ) @@ -2669,13 +2691,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPBwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "oppositeToMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPBwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "oppositeToMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPChi2ChargeLooseMeasurementEstimator16 = cms.ESProducer( "Chi2ChargeMeasurementEstimatorESProducer", MaxChi2 = cms.double( 16.0 ), @@ -3054,13 +3078,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPFwdElectronPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPFwdElectronPropagator" ), Mass = cms.double( 5.11E-4 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( False ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPGlobalDetLayerGeometry = cms.ESProducer( "GlobalDetLayerGeometryESProducer", ComponentName = cms.string( "hltESPGlobalDetLayerGeometry" ), @@ -3636,13 +3662,15 @@ appendToDataLabel = cms.string( "" ) ) process.hltESPRungeKuttaTrackerPropagator = cms.ESProducer( "PropagatorWithMaterialESProducer", + PropagationDirection = cms.string( "alongMomentum" ), SimpleMagneticField = cms.string( "" ), - MaxDPhi = cms.double( 1.6 ), ComponentName = cms.string( "hltESPRungeKuttaTrackerPropagator" ), Mass = cms.double( 0.105 ), - PropagationDirection = cms.string( "alongMomentum" ), + MaxDPhi = cms.double( 1.6 ), useRungeKutta = cms.bool( True ), - ptMin = cms.double( -1.0 ) + useOldAnalPropLogic = cms.bool( True ), + ptMin = cms.double( -1.0 ), + appendToDataLabel = cms.string( "" ) ) process.hltESPSiPixelCablingSoA = cms.ESProducer( "SiPixelCablingSoAESProducer@alpaka", CablingMapLabel = cms.string( "" ), @@ -3741,7 +3769,8 @@ mTIB_P0 = cms.double( -0.742 ), mTID_P1 = cms.double( 0.433 ), mTID_P0 = cms.double( -1.427 ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.hltESPTTRHBWithTrackAngle = cms.ESProducer( "TkTransientTrackingRecHitBuilderESProducer", ComponentName = cms.string( "hltESPTTRHBWithTrackAngle" ), @@ -4016,7 +4045,9 @@ UseQualityInfo = cms.bool( False ), appendToDataLabel = cms.string( "" ) ) -process.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer" ) +process.siPixelTemplateDBObjectESProducer = cms.ESProducer( "SiPixelTemplateDBObjectESProducer", + appendToDataLabel = cms.string( "" ) +) process.siStripBackPlaneCorrectionDepESProducer = cms.ESProducer( "SiStripBackPlaneCorrectionDepESProducer", LatencyRecord = cms.PSet( label = cms.untracked.string( "" ), @@ -4029,7 +4060,8 @@ BackPlaneCorrectionDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripBackPlaneCorrectionRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.siStripLorentzAngleDepESProducer = cms.ESProducer( "SiStripLorentzAngleDepESProducer", LatencyRecord = cms.PSet( @@ -4043,7 +4075,8 @@ LorentzAngleDeconvMode = cms.PSet( label = cms.untracked.string( "deconvolution" ), record = cms.string( "SiStripLorentzAngleRcd" ) - ) + ), + appendToDataLabel = cms.string( "" ) ) process.sistripconn = cms.ESProducer( "SiStripConnectivity" ) process.trackerTopology = cms.ESProducer( "TrackerTopologyEP", @@ -4292,9 +4325,9 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltEcalUncalibRecHit = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoA','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -4895,14 +4928,22 @@ process.hltSiPixelClustersSoA = cms.EDProducer( "SiPixelRawToClusterPhase1@alpaka", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) @@ -4928,36 +4969,38 @@ alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltSiPixelRecHits = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), src = cms.InputTag( "hltSiPixelClusters" ) ) process.hltPixelTracksSoA = cms.EDProducer( "CAHitNtupletAlpakaPhase1@alpaka", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoA" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -4969,9 +5012,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ), alpaka = cms.untracked.PSet( backend = cms.untracked.string( "" ) ) ) process.hltPixelTracks = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", @@ -7818,14 +7868,22 @@ process.hltSiPixelClustersSoASerialSync = cms.EDProducer( "alpaka_serial_sync::SiPixelRawToClusterPhase1", IncludeErrors = cms.bool( True ), UseQualityInfo = cms.bool( False ), + verbose = cms.bool( False ), clusterThreshold_layer1 = cms.int32( 2000 ), clusterThreshold_otherLayers = cms.int32( 4000 ), VCaltoElectronGain = cms.double( 1.0 ), VCaltoElectronGain_L1 = cms.double( 1.0 ), VCaltoElectronOffset = cms.double( 0.0 ), VCaltoElectronOffset_L1 = cms.double( 0.0 ), + DoDigiMorphing = cms.bool( False ), + MaxFakesInModule = cms.uint32( 2400 ), InputLabel = cms.InputTag( "rawDataCollector" ), Regions = cms.PSet( ), + barrelRegions = cms.vstring( '1,1-12,1-2', + '1,1-12,7-8', + '2,1-28,1', + '2,1-28,8' ), + endcapRegions = cms.vstring( ), CablingMapLabel = cms.string( "" ) ) process.hltSiPixelClustersSerialSync = cms.EDProducer( "SiPixelDigisClustersFromSoAAlpakaPhase1", @@ -7849,36 +7907,38 @@ CPE = cms.string( "PixelCPEFastParams" ) ) process.hltSiPixelRecHitsSerialSync = cms.EDProducer( "SiPixelRecHitFromSoAAlpakaPhase1", + maxHitsInModules = cms.uint32( 1024 ), pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), src = cms.InputTag( "hltSiPixelClustersSerialSync" ) ) process.hltPixelTracksSoASerialSync = cms.EDProducer( "alpaka_serial_sync::CAHitNtupletAlpakaPhase1", pixelRecHitSrc = cms.InputTag( "hltSiPixelRecHitsSoASerialSync" ), - CPE = cms.string( "PixelCPEFastParams" ), + cellZ0Cut = cms.double( 12.0 ), + cellPtCut = cms.double( 0.5 ), + dzdrFact = cms.double( 15.2 ), + minYsizeB1 = cms.int32( 1 ), + minYsizeB2 = cms.int32( 1 ), + maxDYsize12 = cms.int32( 28 ), + maxDYsize = cms.int32( 20 ), + maxDYPred = cms.int32( 20 ), + maxNumberOfDoublets = cms.string( "524288" ), + maxNumberOfTuples = cms.string( "32768" ), + avgHitsPerTrack = cms.double( 4.5 ), + avgCellsPerHit = cms.double( 27.0 ), + avgCellsPerCell = cms.double( 0.071 ), + avgTracksPerCell = cms.double( 0.127 ), ptmin = cms.double( 0.9 ), - CAThetaCutBarrel = cms.double( 0.00123302705499 ), - CAThetaCutForward = cms.double( 0.00355691321774 ), hardCurvCut = cms.double( 0.0328407225 ), - dcaCutInnerTriplet = cms.double( 0.0918113099491 ), - dcaCutOuterTriplet = cms.double( 0.420724617835 ), earlyFishbone = cms.bool( True ), lateFishbone = cms.bool( False ), fillStatistics = cms.bool( False ), minHitsPerNtuplet = cms.uint32( 3 ), minHitsForSharingCut = cms.uint32( 10 ), fitNas4 = cms.bool( False ), - doClusterCut = cms.bool( True ), - doZ0Cut = cms.bool( True ), - doPtCut = cms.bool( True ), useRiemannFit = cms.bool( False ), doSharedHitCut = cms.bool( True ), dupPassThrough = cms.bool( False ), useSimpleTripletCleaner = cms.bool( True ), - maxNumberOfDoublets = cms.uint32( 524288 ), - idealConditions = cms.bool( False ), - includeJumpingForwardDoublets = cms.bool( True ), - cellZ0Cut = cms.double( 12.0 ), - cellPtCut = cms.double( 0.5 ), trackQualityCuts = cms.PSet( chi2MaxPt = cms.double( 10.0 ), tripletMaxTip = cms.double( 0.3 ), @@ -7890,9 +7950,16 @@ tripletMinPt = cms.double( 0.5 ), chi2Coeff = cms.vdouble( 0.9, 1.8 ) ), - minYsizeB1 = cms.int32( 1 ), - minYsizeB2 = cms.int32( 1 ), - phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ) + geometry = cms.PSet( + caThetaCuts = cms.vdouble( 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00123302705499, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774, 0.00355691321774 ), + pairGraph = cms.vuint32( 0, 1, 0, 4, 0, 7, 1, 2, 1, 4, 1, 7, 4, 5, 7, 8, 2, 3, 2, 4, 2, 7, 5, 6, 8, 9, 0, 2, 1, 3, 0, 5, 0, 8, 4, 6, 7, 9 ), + startingPairs = cms.vuint32( 0, 1, 2, 3, 4, 5, 6, 7, 13, 14, 15, 16, 17, 18, 19 ), + maxZ = cms.vdouble( 20.0, 30.0, 0.0, 22.0, 30.0, -10.0, 70.0, 70.0, 22.0, 30.0, -15.0, 70.0, 70.0, 20.0, 22.0, 30.0, 0.0, 70.0, 70.0 ), + caDCACuts = cms.vdouble( 0.0918113099491, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835, 0.420724617835 ), + minZ = cms.vdouble( -20.0, 0.0, -30.0, -22.0, 10.0, -30.0, -70.0, -70.0, -22.0, 15.0, -30.0, -70.0, -70.0, -20.0, -22.0, 0.0, -30.0, -70.0, -70.0 ), + phiCuts = cms.vint32( 965, 1241, 395, 698, 1058, 1211, 348, 782, 1016, 810, 463, 755, 694, 531, 770, 471, 592, 750, 348 ), + maxR = cms.vdouble( 20.0, 9.0, 9.0, 20.0, 7.0, 7.0, 5.0, 5.0, 20.0, 6.0, 6.0, 5.0, 5.0, 20.0, 20.0, 9.0, 9.0, 9.0, 9.0 ) + ) ) process.hltPixelTracksSerialSync = cms.EDProducer( "PixelTrackProducerFromSoAAlpakaPhase1", beamSpot = cms.InputTag( "hltOnlineBeamSpot" ), @@ -8042,9 +8109,9 @@ shouldRunTimingComputation = cms.bool( True ) ) process.hltEcalUncalibRecHitSerialSync = cms.EDProducer( "EcalUncalibRecHitSoAToLegacy", - inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), outputLabelEB = cms.string( "EcalUncalibRecHitsEB" ), isPhase2 = cms.bool( False ), + inputCollectionEB = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEB' ), inputCollectionEE = cms.InputTag( 'hltEcalUncalibRecHitSoASerialSync','EcalUncalibRecHitsEE' ), outputLabelEE = cms.string( "EcalUncalibRecHitsEE" ) ) @@ -8680,74 +8747,74 @@ EBSumThreshold = cms.double( 0.2 ), HF2Weight = cms.double( 1.0 ), EBWeight = cms.double( 1.0 ), - hfInput = cms.InputTag( "hltHfreco" ), EESumThreshold = cms.double( 0.45 ), HOThreshold0 = cms.double( 3.5 ), HOThresholdPlus1 = cms.double( 3.5 ), HOThresholdMinus1 = cms.double( 3.5 ), HOThresholdPlus2 = cms.double( 3.5 ), HOThresholdMinus2 = cms.double( 3.5 ), - HBGrid = cms.vdouble( ), + HBThreshold = cms.double( 0.3 ), HBThreshold1 = cms.double( 0.4 ), HBThreshold2 = cms.double( 0.3 ), - HBThreshold = cms.double( 0.3 ), - EEWeights = cms.vdouble( ), HF1Threshold = cms.double( 0.5 ), - HF2Weights = cms.vdouble( ), - HOWeights = cms.vdouble( ), - EEGrid = cms.vdouble( ), HEDWeight = cms.double( 1.0 ), EEWeight = cms.double( 1.0 ), - UseHO = cms.bool( False ), - HBWeights = cms.vdouble( ), HESWeight = cms.double( 1.0 ), HF1Weight = cms.double( 1.0 ), - HF2Grid = cms.vdouble( ), - HEDWeights = cms.vdouble( ), - HF1Grid = cms.vdouble( ), - EBWeights = cms.vdouble( ), HOWeight = cms.double( 1.0E-99 ), EBThreshold = cms.double( 0.07 ), EEThreshold = cms.double( 0.3 ), - UseEtEBTreshold = cms.bool( False ), - UseSymEBTreshold = cms.bool( False ), - UseEtEETreshold = cms.bool( False ), - UseSymEETreshold = cms.bool( False ), - hbheInput = cms.InputTag( "hltHbhereco" ), HcalThreshold = cms.double( -1000.0 ), HF2Threshold = cms.double( 0.85 ), - HESThreshold1 = cms.double( 0.1 ), HESThreshold = cms.double( 0.2 ), - HF1Weights = cms.vdouble( ), - hoInput = cms.InputTag( "hltHoreco" ), - HESGrid = cms.vdouble( ), - HESWeights = cms.vdouble( ), - HEDThreshold1 = cms.double( 0.1 ), + HESThreshold1 = cms.double( 0.1 ), HEDThreshold = cms.double( 0.2 ), + HEDThreshold1 = cms.double( 0.1 ), EcutTower = cms.double( -1000.0 ), - HEDGrid = cms.vdouble( ), - ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), HBWeight = cms.double( 1.0 ), - HOGrid = cms.vdouble( ), - EBGrid = cms.vdouble( ), - MomConstrMethod = cms.int32( 1 ), MomHBDepth = cms.double( 0.2 ), MomHEDepth = cms.double( 0.4 ), MomEBDepth = cms.double( 0.3 ), MomEEDepth = cms.double( 0.0 ), - HcalAcceptSeverityLevel = cms.uint32( 9 ), - EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', - 'kWeird', - 'kBad' ), + UseHO = cms.bool( False ), + UseEtEBTreshold = cms.bool( False ), + UseSymEBTreshold = cms.bool( False ), + UseEtEETreshold = cms.bool( False ), + UseSymEETreshold = cms.bool( False ), UseHcalRecoveredHits = cms.bool( False ), UseEcalRecoveredHits = cms.bool( False ), UseRejectedHitsOnly = cms.bool( False ), - HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), - EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), UseRejectedRecoveredHcalHits = cms.bool( False ), UseRejectedRecoveredEcalHits = cms.bool( False ), missingHcalRescaleFactorForEcal = cms.double( 0.0 ), AllowMissingInputs = cms.bool( False ), + HBGrid = cms.vdouble( ), + EEWeights = cms.vdouble( ), + HF2Weights = cms.vdouble( ), + HOWeights = cms.vdouble( ), + EEGrid = cms.vdouble( ), + HBWeights = cms.vdouble( ), + HF2Grid = cms.vdouble( ), + HEDWeights = cms.vdouble( ), + HF1Grid = cms.vdouble( ), + EBWeights = cms.vdouble( ), + HF1Weights = cms.vdouble( ), + HESGrid = cms.vdouble( ), + HESWeights = cms.vdouble( ), + HEDGrid = cms.vdouble( ), + HOGrid = cms.vdouble( ), + EBGrid = cms.vdouble( ), + hfInput = cms.InputTag( "hltHfreco" ), + hbheInput = cms.InputTag( "hltHbhereco" ), + hoInput = cms.InputTag( "hltHoreco" ), + ecalInputs = cms.VInputTag( 'hltEcalRecHit:EcalRecHitsEB','hltEcalRecHit:EcalRecHitsEE' ), + MomConstrMethod = cms.int32( 1 ), + HcalAcceptSeverityLevel = cms.uint32( 9 ), + EcalRecHitSeveritiesToBeExcluded = cms.vstring( 'kTime', + 'kWeird', + 'kBad' ), + HcalAcceptSeverityLevelForRejectedHit = cms.uint32( 9999 ), + EcalSeveritiesToBeUsedInBadTowers = cms.vstring( ), HcalPhase = cms.int32( 1 ), usePFThresholdsFromDB = cms.bool( True ), EcalRecHitThresh = cms.bool( True ) @@ -12573,7 +12640,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 4096 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( False ) ) process.hltL1sHcalNZS = cms.EDFilter( "HLTL1TSeed", @@ -12618,7 +12685,7 @@ rawInput = cms.InputTag( "rawDataCollector" ), period = cms.uint32( 107 ), invert = cms.bool( False ), - fedId = cms.int32( 1024 ), + fedIds = cms.vint32( 1024 ), useTCDSEventNumber = cms.bool( True ) ) process.hltPrePhysics = cms.EDFilter( "HLTPrescaler", diff --git a/HLTrigger/Configuration/test/getEventContent.py b/HLTrigger/Configuration/test/getEventContent.py index 6e2f917b3e512..0076bfe341550 100755 --- a/HLTrigger/Configuration/test/getEventContent.py +++ b/HLTrigger/Configuration/test/getEventContent.py @@ -119,6 +119,7 @@ def printHLTriggerEventContentCff(process): 'hltOutputA', 'hltOutputPhysicsCommissioning', 'hltOutputDQM', + 'hltOutputDQMGPUvsCPU', 'hltOutputHLTMonitor', 'hltOutputReleaseValidation', ], @@ -138,6 +139,8 @@ def printHLTriggerEventContentCff(process): hltOutputMON_cff.block_hltOutputA = hltOutputMON_cff.block_hltOutputPhysicsCommissioning if not hasattr(hltOutputMON_cff,'block_hltOutputDQM'): hltOutputMON_cff.block_hltOutputDQM = cms.PSet(outputCommands = cms.untracked.vstring( 'drop *' )) + if not hasattr(hltOutputMON_cff,'block_hltOutputDQMGPUvsCPU'): + hltOutputMON_cff.block_hltOutputDQMGPUvsCPU = cms.PSet(outputCommands = cms.untracked.vstring( 'drop *' )) if not hasattr(hltOutputMON_cff,'block_hltOutputHLTMonitor'): hltOutputMON_cff.block_hltOutputHLTMonitor = cms.PSet(outputCommands = cms.untracked.vstring( 'drop *_hlt*_*_*' )) if not hasattr(hltOutputMON_cff,'block_hltOutputReleaseValidation'): @@ -147,6 +150,7 @@ def printHLTriggerEventContentCff(process): # the DQM and HLTMON streams have the HLT debug outputs used online hltOutputMON_cff.block_hltOutputA.outputCommands, hltOutputMON_cff.block_hltOutputDQM.outputCommands, + hltOutputMON_cff.block_hltOutputDQMGPUvsCPU.outputCommands, hltOutputMON_cff.block_hltOutputHLTMonitor.outputCommands, hltOutputMON_cff.block_hltOutputReleaseValidation.outputCommands, ) @@ -175,6 +179,7 @@ def printHLTriggerEventContentCff(process): # the DQM and HLTMON streams have the HLT debug outputs used online hltOutputMON_cff.block_hltOutputA.outputCommands, hltOutputMON_cff.block_hltOutputDQM.outputCommands, + hltOutputMON_cff.block_hltOutputDQMGPUvsCPU.outputCommands, hltOutputMON_cff.block_hltOutputHLTMonitor.outputCommands, hltOutputMON_cff.block_hltOutputReleaseValidation.outputCommands, # the ALCA streams have the AlCa outputs diff --git a/HLTrigger/Configuration/test/getFrozenHLT.sh b/HLTrigger/Configuration/test/getFrozenHLT.sh index 2745a1d58936e..e52c2b00f22ac 100755 --- a/HLTrigger/Configuration/test/getFrozenHLT.sh +++ b/HLTrigger/Configuration/test/getFrozenHLT.sh @@ -9,10 +9,10 @@ # Configuration/HLT/python/autoCondHLT.py , and # HLTrigger/Configuration/python/Tools/options.py declare -A TABLES=( - ["Fake"]="/dev/CMSSW_15_0_0/Fake" - ["Fake1"]="/dev/CMSSW_15_0_0/Fake1" - ["Fake2"]="/dev/CMSSW_15_0_0/Fake2" - ["2025v13"]="/frozen/2025/2e34/v1.3/HLT" + ["Fake"]="/dev/CMSSW_15_1_0/Fake" + ["Fake1"]="/dev/CMSSW_15_1_0/Fake1" + ["Fake2"]="/dev/CMSSW_15_1_0/Fake2" + ["2025v13"]="/frozen/2025/2e34/v1.3/CMSSW_15_1_X/HLT" ) # command-line arguments diff --git a/HLTrigger/Configuration/test/getHLT.sh b/HLTrigger/Configuration/test/getHLT.sh index e571e9ab2c79c..a2be4f5141f88 100755 --- a/HLTrigger/Configuration/test/getHLT.sh +++ b/HLTrigger/Configuration/test/getHLT.sh @@ -1,7 +1,7 @@ #!/bin/bash # ConfDB directory hosting the HLT configurations -CONFDBDIR="/dev/CMSSW_15_0_0" +CONFDBDIR="/dev/CMSSW_15_1_0" # ConfDB configurations to use # - if no explicit version, the most recent one is taken diff --git a/HLTrigger/NGTScouting/plugins/LayerClustersExtraTableProducer.cc b/HLTrigger/NGTScouting/plugins/LayerClustersExtraTableProducer.cc new file mode 100644 index 0000000000000..0c497cdfbb5cf --- /dev/null +++ b/HLTrigger/NGTScouting/plugins/LayerClustersExtraTableProducer.cc @@ -0,0 +1,62 @@ +#include "PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h" +#include "DataFormats/CaloRecHit/interface/CaloCluster.h" + +class LayerClustersExtraTableProducer : public edm::stream::EDProducer<> { +public: + LayerClustersExtraTableProducer(edm::ParameterSet const& params) + : skipNonExistingSrc_(params.getParameter("skipNonExistingSrc")), + tableName_(params.getParameter("tableName")), + precision_(params.getParameter("precision")), + clustersTime_token_(consumes>>( + params.getParameter("time_layerclusters"))) { + produces(tableName_); + } + + void produce(edm::Event& iEvent, const edm::EventSetup&) override { + //Layer Clusters time value map + auto clustersTime_h = iEvent.getHandle(clustersTime_token_); + const auto nClusters = clustersTime_h.isValid() ? clustersTime_h->size() : 0; + + static constexpr float default_value = std::numeric_limits::quiet_NaN(); + + std::vector time(nClusters, default_value); + std::vector timeError(nClusters, default_value); + + // initialize to quiet Nans + if (clustersTime_h.isValid() or !(skipNonExistingSrc_)) { + const auto& clustersTime = *clustersTime_h; + for (size_t i = 0; i < clustersTime.size(); ++i) { + float t = clustersTime.get(i).first; + float tE = clustersTime.get(i).first; + time[i] = t; + timeError[i] = tE; + } + } + + auto layerClustersTable = + std::make_unique(nClusters, tableName_, /*singleton*/ false, /*extension*/ true); + layerClustersTable->addColumn("time", time, "LayerCluster time [ns]", precision_); + layerClustersTable->addColumn("timeError", timeError, "LayerCluster timeError [ns]", precision_); + iEvent.put(std::move(layerClustersTable), tableName_); + } + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + desc.add("skipNonExistingSrc", false) + ->setComment("whether or not to skip producing the table on absent input product"); + desc.add("tableName", "hltMergeLayerClusters")->setComment("name of the flat table ouput"); + desc.add("time_layerclusters", edm::InputTag("hltMergeLayerClusters", "timeLayerCluster")); + desc.add("precision", 7); + descriptions.addWithDefaultLabel(desc); + } + +private: + const bool skipNonExistingSrc_; + const std::string tableName_; + const unsigned int precision_; + const edm::EDGetTokenT> layerClusters_token_; + const edm::EDGetTokenT>> clustersTime_token_; +}; + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(LayerClustersExtraTableProducer); diff --git a/HLTrigger/NGTScouting/plugins/LayerClustersTableProducer.cc b/HLTrigger/NGTScouting/plugins/LayerClustersTableProducer.cc new file mode 100644 index 0000000000000..2925243f97b4b --- /dev/null +++ b/HLTrigger/NGTScouting/plugins/LayerClustersTableProducer.cc @@ -0,0 +1,7 @@ +#include "PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h" + +#include "DataFormats/CaloRecHit/interface/CaloCluster.h" +typedef SimpleCollectionFlatTableProducer LayerClustersCollectionTableProducer; + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(LayerClustersCollectionTableProducer); diff --git a/HLTrigger/NGTScouting/plugins/TICLCandidateExtraTableProducer.cc b/HLTrigger/NGTScouting/plugins/TICLCandidateExtraTableProducer.cc index 301f0cd18e04d..83e1f60ce6e96 100644 --- a/HLTrigger/NGTScouting/plugins/TICLCandidateExtraTableProducer.cc +++ b/HLTrigger/NGTScouting/plugins/TICLCandidateExtraTableProducer.cc @@ -1,6 +1,3 @@ -#ifndef HLTrigger_HLTUpgradeNano_TICLCandidateExtraTableProducer_h -#define HLTrigger_HLTUpgradeNano_TICLCandidateExtraTableProducer_h - #include "PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h" #include "DataFormats/HGCalReco/interface/TICLCandidate.h" #include "DataFormats/HGCalReco/interface/Trackster.h" @@ -123,5 +120,3 @@ class TICLCandidateExtraTableProducer : public SimpleFlatTableProducerBasesetCacheReadTemporarily(treeCache_.get(), tree_); + auto guard = filePtr_->setCacheReadTemporarily(rawTreeCache_.get(), tree_); tree_->GetEntry(entryNumber_); }); } diff --git a/PerfTools/AllocMonitor/scripts/edmModuleAllocJsonToCircles.py b/PerfTools/AllocMonitor/scripts/edmModuleAllocJsonToCircles.py index 03be4bb31f65a..d1a9175fa1b98 100755 --- a/PerfTools/AllocMonitor/scripts/edmModuleAllocJsonToCircles.py +++ b/PerfTools/AllocMonitor/scripts/edmModuleAllocJsonToCircles.py @@ -1,5 +1,15 @@ #!/usr/bin/env python3 import json +import sys +from collections import namedtuple + +# Constants +BYTES_TO_KB = 1024 +EVENTSETUP_TRANSITION = "event setup" + +# Named tuple for unique module identification +UniqueKey = namedtuple('UniqueKey', ['moduleLabel', 'moduleType', 'recordName']) + transitionTypes = [ "construction", "begin job", @@ -9,15 +19,62 @@ "global begin luminosity block", "stream begin luminosity block", "event", + EVENTSETUP_TRANSITION, ] allocTypes = ["added", "nAlloc", "nDealloc", "maxTemp", "max1Alloc"] def processModuleTransition(moduleLabel, moduleType, moduleInfo, transitionType, moduleTransition): - moduleTransition[moduleLabel] = {"cpptype": moduleType, "allocs": []} - for entry in moduleInfo: - if entry["transition"] == transitionType: - moduleTransition[moduleLabel]["allocs"].append(entry.get("alloc",{})) - moduleTransition[moduleLabel]["nTransitions"] = len(moduleTransition[moduleLabel]["allocs"]) + """ + Processes module transitions for a given transition type. + + The expected schema for each 'alloc' dictionary is: + { + "added": int, # Bytes added during transition + "nAlloc": int, # Number of allocations + "nDealloc": int, # Number of deallocations + "maxTemp": int, # Maximum temporary memory (bytes) + "max1Alloc": int # Largest single allocation (bytes) + } + Any missing field defaults to 0. + + Note: Entries with record names are excluded as they belong to EventSetup transition only. + """ + moduleKey = UniqueKey(moduleLabel, moduleType, "") + moduleTransition[moduleKey] = {"cpptype": moduleType, "allocs": []} + for entry in moduleInfo: + # Only process entries that match the transition type AND don't have record names + # (entries with record names are EventSetup only) + if (entry.get("transition", None) == transitionType and + not ("record" in entry and "name" in entry["record"])): + moduleTransition[moduleKey]["allocs"].append(entry.get("alloc", {})) + moduleTransition[moduleKey]["nTransitions"] = len(moduleTransition[moduleKey]["allocs"]) + +def processESModuleTransition(moduleLabel, moduleType, moduleInfo, moduleTransition): + """Process EventSetup transitions - entries with record names + + Creates unique entries for each module+type+record combination. + """ + # Group allocations by record name + recordAllocations = {} + for entry in moduleInfo: + # EventSetup entries are those with a "record" field containing "name" + if "record" in entry and "name" in entry["record"]: + recordName = entry["record"]["name"] + if recordName not in recordAllocations: + recordAllocations[recordName] = [] + recordAllocations[recordName].append(entry.get("alloc", {})) + + # Create separate entries for each record + for recordName, allocs in recordAllocations.items(): + # Create unique key: module + type + record + uniqueKey = UniqueKey(moduleLabel, moduleType, recordName) + moduleTransition[uniqueKey] = { + "cpptype": moduleType, + "allocs": allocs, + "nTransitions": len(allocs), + "moduleLabel": moduleLabel, + "recordName": recordName + } def formatToCircles(moduleTransitions): modules_dict = {} @@ -62,67 +119,128 @@ def formatToCircles(moduleTransitions): ] # The circles code uses the "events" field to normalize the values between files with different number of events # Here we set it to 1 for the total events because the total is already normalized per transition - doc["total"]["events"] = 1 - doc["total"]["label"] = "Job" - doc["total"]["type"] = "Job" + doc["total"]["events"] = 1 + doc["total"]["label"] = "Job" + doc["total"]["type"] = "Job" + # Initialize totals for all transition types and allocation types + for transType in transitionTypes: for allocType in allocTypes: - doc["total"][f"{allocType} {transitionType}"] = 0 + doc["total"][f"{allocType} {transType}"] = 0 + # First pass: collect all unique module keys across all transitions + all_module_keys = set() for transitionType, moduleTransition in moduleTransitions.items(): - for label, info in moduleTransition.items(): + for uniqueKey in moduleTransition.keys(): + all_module_keys.add(uniqueKey) + + # Initialize all modules with default values for all transitions + for displayKey in all_module_keys: + if displayKey not in modules_dict: + # UniqueKey namedtuple provides direct access to fields + modules_dict[displayKey] = { + "label": displayKey.moduleLabel, + "type": displayKey.moduleType, + "record": displayKey.recordName + } + + # Initialize all transition metrics to zero + for transType in transitionTypes: + for allocType in allocTypes: + modules_dict[displayKey][f"{allocType} {transType}"] = 0.0 + + # Second pass: populate actual values + for transitionType, moduleTransition in moduleTransitions.items(): + for uniqueKey, info in moduleTransition.items(): allocs = info.get("allocs", []) - if not label in modules_dict: - modules_dict[label] = { - "label": info.get("label", label), - "type": info.get("cpptype", "unknown") - } - added = 0 - nAlloc = 0 - nDealloc = 0 - maxTemp = 0 - max1Alloc = 0 - for alloc in allocs: - added += alloc.get("added", 0) - nAlloc += alloc.get("nAlloc", 0) - nDealloc += alloc.get("nDealloc", 0) - maxTemp += alloc.get("maxTemp", 0) - max1Alloc += alloc.get("max1Alloc", 0) - ntransitions = moduleTransitions[transitionType][label]["nTransitions"] - if ntransitions > 0: - modules_dict[label][f"nAlloc {transitionType}"] = nAlloc/ntransitions - modules_dict[label][f"added {transitionType}"] = (added/ntransitions)/1024 - modules_dict[label][f"maxTemp {transitionType}"] = (maxTemp/ntransitions)/1024 - modules_dict[label][f"nDealloc {transitionType}"] = nDealloc/ntransitions - modules_dict[label][f"max1Alloc {transitionType}"] = (max1Alloc/ntransitions)/1024 - else: - modules_dict[label][f"nAlloc {transitionType}"] = nAlloc - modules_dict[label][f"added {transitionType}"] = (added)/1024 - modules_dict[label][f"maxTemp {transitionType}"] = (maxTemp)/1024 - modules_dict[label][f"nDealloc {transitionType}"] = nDealloc - modules_dict[label][f"max1Alloc {transitionType}"] = max1Alloc/1024 - doc["total"][f"nAlloc {transitionType}"] += modules_dict[label][f"nAlloc {transitionType}"] - doc["total"][f"nDealloc {transitionType}"] += modules_dict[label][f"nDealloc {transitionType}"] - doc["total"][f"maxTemp {transitionType}"] += modules_dict[label][f"maxTemp {transitionType}"] - doc["total"][f"added {transitionType}"] += modules_dict[label][f"added {transitionType}"] - doc["total"][f"max1Alloc {transitionType}"] += modules_dict[label][f"max1Alloc {transitionType}"] + # Only update metrics if this module actually has data for this transition + if uniqueKey in modules_dict: + added = 0 + nAlloc = 0 + nDealloc = 0 + maxTemp = 0 + max1Alloc = 0 + for alloc in allocs: + added += alloc.get("added", 0) + nAlloc += alloc.get("nAlloc", 0) + nDealloc += alloc.get("nDealloc", 0) + maxTemp += alloc.get("maxTemp", 0) + max1Alloc += alloc.get("max1Alloc", 0) + ntransitions = moduleTransitions[transitionType][uniqueKey].get("nTransitions", 0) + # Normalize by number of transitions if > 0, otherwise use raw values + divisor = max(ntransitions, 1) # Avoid division by zero + + modules_dict[uniqueKey][f"nAlloc {transitionType}"] = nAlloc / divisor + modules_dict[uniqueKey][f"nDealloc {transitionType}"] = nDealloc / divisor + modules_dict[uniqueKey][f"added {transitionType}"] = (added / divisor) / BYTES_TO_KB + modules_dict[uniqueKey][f"maxTemp {transitionType}"] = (maxTemp / divisor) / BYTES_TO_KB + modules_dict[uniqueKey][f"max1Alloc {transitionType}"] = (max1Alloc / divisor) / BYTES_TO_KB + doc["total"][f"nAlloc {transitionType}"] += modules_dict[uniqueKey][f"nAlloc {transitionType}"] + doc["total"][f"nDealloc {transitionType}"] += modules_dict[uniqueKey][f"nDealloc {transitionType}"] + doc["total"][f"maxTemp {transitionType}"] += modules_dict[uniqueKey][f"maxTemp {transitionType}"] + doc["total"][f"added {transitionType}"] += modules_dict[uniqueKey][f"added {transitionType}"] + doc["total"][f"max1Alloc {transitionType}"] += modules_dict[uniqueKey][f"max1Alloc {transitionType}"] for key in sorted(modules_dict.keys()): module = modules_dict[key] - module["events"] = moduleTransitions['event'][key].get("nTransitions") + + # Check if this is an empty entry (record="" and all allocations are zero) + if module["record"] == "": + # Check if all allocation metrics are zero across all transition types + hasNonZeroAllocations = False + for transType in transitionTypes: + for allocType in allocTypes: + if module.get(f"{allocType} {transType}", 0) != 0: + hasNonZeroAllocations = True + break + if hasNonZeroAllocations: + break + + # Skip this entry if no allocations and empty record + if not hasNonZeroAllocations: + continue + + # Use the module label from the UniqueKey namedtuple for event count lookup + moduleLabel = key.moduleLabel + # Look for the corresponding regular module key for event transitions + eventKey = UniqueKey(moduleLabel, key.moduleType, "") + eventCount = moduleTransitions['event'].get(eventKey, {}).get("nTransitions", 0) + # Set events to 1 if it's 0 to prevent NaNs in Circles visualization + module["events"] = max(eventCount, 1) doc["modules"].append(module) return doc def main(args): - import sys - doc = json.load(args.filename) + try: + doc = json.load(args.filename) + except json.JSONDecodeError as e: + print(f"Error parsing JSON: {e}", file=sys.stderr) + sys.exit(1) + except Exception as e: + print(f"Error reading file: {e}", file=sys.stderr) + sys.exit(1) + + # Validate required fields + if 'cpptypes' not in doc: + print("Error: Missing 'cpptypes' field in input JSON", file=sys.stderr) + sys.exit(1) + if 'modules' not in doc: + print("Error: Missing 'modules' field in input JSON", file=sys.stderr) + sys.exit(1) + moduleTypes = doc['cpptypes'] moduleTransitions = dict() for transition in transitionTypes: moduleTransition = dict() - processModuleTransition("source", "PoolSource", doc["source"], transition, moduleTransition) - for moduleLabel, moduleInfo in doc["modules"].items(): - processModuleTransition(moduleLabel, moduleTypes[moduleLabel], moduleInfo, transition, moduleTransition) + if transition == EVENTSETUP_TRANSITION: + # EventSetup transitions are handled differently - look for records with names + for moduleLabel, moduleInfo in doc["modules"].items(): + processESModuleTransition(moduleLabel, moduleTypes[moduleLabel], moduleInfo, moduleTransition) + else: + # Regular transition processing + processModuleTransition("source", "PoolSource", doc["source"], transition, moduleTransition) + for moduleLabel, moduleInfo in doc["modules"].items(): + processModuleTransition(moduleLabel, moduleTypes[moduleLabel], moduleInfo, transition, moduleTransition) moduleTransitions[transition] = moduleTransition json.dump(formatToCircles(moduleTransitions), sys.stdout, indent=2) diff --git a/PhysicsTools/NanoAOD/python/custom_run3scouting_cff.py b/PhysicsTools/NanoAOD/python/custom_run3scouting_cff.py index d4a428be8f156..d4a124b367e46 100644 --- a/PhysicsTools/NanoAOD/python/custom_run3scouting_cff.py +++ b/PhysicsTools/NanoAOD/python/custom_run3scouting_cff.py @@ -20,7 +20,7 @@ scoutingMuonDisplacedVertexTableTask = cms.Task(scoutingMuonDisplacedVertexTable) # from 2024, there are two muon collections (https://its.cern.ch/jira/browse/CMSHLT-3089) -run3_scouting_nanoAOD_2024.toReplaceWith(scoutingMuonTableTask, cms.Task(scoutingMuonVtxTable, scoutingMuonNoVtxTable))\ +(run3_scouting_2024 | run3_scouting_2025).toReplaceWith(scoutingMuonTableTask, cms.Task(scoutingMuonVtxTable, scoutingMuonNoVtxTable))\ .toReplaceWith(scoutingMuonDisplacedVertexTableTask, cms.Task(scoutingMuonVtxDisplacedVertexTable, scoutingMuonNoVtxDisplacedVertexTable)) # Scouting Electron @@ -28,7 +28,7 @@ # from 2023, scouting electron's tracks are added as std::vector since multiple tracks can be associated to a scouting electron # plugin to select the best track to reduce to a single track per scouting electron is added -(run3_scouting_nanoAOD_2023 | run3_scouting_nanoAOD_2024).toReplaceWith( +(run3_scouting_2023 | run3_scouting_2024 | run3_scouting_2025).toReplaceWith( scoutingElectronTableTask, cms.Task(scoutingElectronBestTrack, scoutingElectronTable) ) @@ -149,6 +149,18 @@ def customiseScoutingNano(process): return process +############## +### Filter ### +############## + +# this filter selects only events triggered by scouting paths by checking scouting primary dataset bit(s) +# if scouting paths are triggered, scouting objects will be reconstructed, so this gurantees that scouting objects exist +import HLTrigger.HLTfilters.hltHighLevel_cfi +scoutingTriggerPathFilter = HLTrigger.HLTfilters.hltHighLevel_cfi.hltHighLevel.clone( + HLTPaths = cms.vstring("Dataset_ScoutingPFRun3", "Dataset_ScoutingPF0", "Dataset_ScoutingPF1"), + throw = cms.bool(False) +) + ##################### ### Customisation ### ##################### @@ -160,7 +172,7 @@ def customiseScoutingNano(process): # this is suitable when ScoutingPFMonitor/RAW is involved, e.g. RAW, RAW-MiniAOD two-file solution, full chain RAW-MiniAOD-NanoAOD # when running full chain RAW-MiniAOD-NanoAOD, this ensures that gtStage2Digis, gmtStage2Digis, and caloStage2Digis are run def customiseScoutingNanoForScoutingPFMonitor(process): - process = skipEventsWithoutScouting(process) + process = skipEventsWithoutScoutingByEra(process) # replace gtStage2DigisScouting with standard gtStage2Digis process.scoutingTriggerTask.remove(process.gtStage2DigisScouting) @@ -194,7 +206,7 @@ def customiseScoutingNanoFromMini(process): # when running on data, assume ScoutingPFMonitor/MiniAOD dataset as inputs runOnData = hasattr(process,"NANOAODSIMoutput") or hasattr(process,"NANOAODoutput") if runOnData: - process = skipEventsWithoutScouting(process) + process = skipEventsWithoutScoutingByEra(process) # remove gtStage2Digis since they are already run for Mini process.scoutingTriggerTask.remove(process.gtStage2DigisScouting) @@ -213,29 +225,50 @@ def customiseScoutingNanoFromMini(process): return process # skip events without scouting object products -# this may be needed since for there are some events which do not contain scouting object products in 2022-24 +# this may be useful since ScoutingPFMonitor dataset contains some events which do not contain scouting object products in 2022-24 # this is fixed for 2025: https://its.cern.ch/jira/browse/CMSHLT-3331 def skipEventsWithoutScouting(process): - # if scouting paths are triggered, scouting objects will be reconstructed - # so we select events passing scouting paths - import HLTrigger.HLTfilters.hltHighLevel_cfi + # add filter/skim path to the process + process.scoutingNanoSkim_step = cms.Path(process.scoutingTriggerPathFilter) + + # schedule filter/skim path to run + process.schedule.extend([process.scoutingNanoSkim_step]) + + if hasattr(process, "NANOAODoutput"): + process.NANOAODoutput.SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring("scoutingNanoSkim_step")) - process.scoutingTriggerPathFilter = HLTrigger.HLTfilters.hltHighLevel_cfi.hltHighLevel.clone( - HLTPaths = cms.vstring("Dataset_ScoutingPFRun3", "Dataset_ScoutingPF0", "Dataset_ScoutingPF1"), - throw = cms.bool(False) - ) + if hasattr(process, "NANOEDMAODoutput"): + process.NANOEDMAODoutput.SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring("scoutingNanoSkim_step")) - process.nanoSkim_step = cms.Path(process.scoutingTriggerPathFilter) - process.schedule.extend([process.nanoSkim_step]) + if hasattr(process, "write_NANOAOD"): # PromptReco + process.write_NANOAOD.SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring("scoutingNanoSkim_step")) + + return process + +# skip events without scouting object products by era +# this may be useful since ScoutingPFMonitor dataset contains some events which do not contain scouting object products in 2022-24 +# this is fixed for 2025: https://its.cern.ch/jira/browse/CMSHLT-3331 +def skipEventsWithoutScoutingByEra(process): + # add filter/skim path to the process + process.scoutingNanoSkim_step = cms.Path(process.scoutingTriggerPathFilter) if hasattr(process, "NANOAODoutput"): - process.NANOAODoutput.SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring("nanoSkim_step")) + (~run3_scouting_2025).toModify(process.NANOAODoutput, SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring("scoutingNanoSkim_step"))) + if hasattr(process.NANOAODoutput, "SelectEvents") and "scoutingNanoSkim_step" in process.NANOAODoutput.SelectEvents.SelectEvents: + # schedule filter/skim path to run + process.schedule.extend([process.scoutingNanoSkim_step]) - if hasattr(process, "NANOAODEDMoutput"): - process.NANOEDMAODoutput.SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring("nanoSkim_step")) + if hasattr(process, "NANOEDMAODoutput"): + (~run3_scouting_2025).toModify(process.NANOEDMAODoutput, SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring("scoutingNanoSkim_step"))) + if hasattr(process.NANOEDMAODoutput, "SelectEvents") and "scoutingNanoSkim_step" in process.NANOEDMAODoutput.SelectEvents.SelectEvents: + # schedule filter/skim path to run + process.schedule.extend([process.scoutingNanoSkim_step]) if hasattr(process, "write_NANOAOD"): # PromptReco - process.write_NANOAOD.SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring("nanoSkim_step")) + (~run3_scouting_2025).toModify(process.write_NANOAOD, SelectEvents = cms.untracked.PSet(SelectEvents = cms.vstring("scoutingNanoSkim_step"))) + if hasattr(process.write_NANOAOD, "SelectEvents") and "scoutingNanoSkim_step" in process.write_NANOAOD.SelectEvents.SelectEvents: + # schedule filter/skim path to run + process.schedule.extend([process.scoutingNanoSkim_step]) return process @@ -278,7 +311,7 @@ def addScoutingElectronTrack(process): ) # additional electron track variables added in 2024 in https://github.com/cms-sw/cmssw/pull/43744 - run3_scouting_nanoAOD_2024.toModify( + (run3_scouting_2024 | run3_scouting_2025).toModify( process.scoutingElectronTable.collectionVariables.variables, pMode = Var("trkpMode", "float", doc="track pMode"), etaMode = Var("trketaMode", "float", doc="track etaMode"), diff --git a/PhysicsTools/NanoAOD/python/run3scouting_cff.py b/PhysicsTools/NanoAOD/python/run3scouting_cff.py index ee64a9296e701..0c241d35e765c 100644 --- a/PhysicsTools/NanoAOD/python/run3scouting_cff.py +++ b/PhysicsTools/NanoAOD/python/run3scouting_cff.py @@ -1,8 +1,9 @@ import FWCore.ParameterSet.Config as cms from PhysicsTools.NanoAOD.common_cff import * from PhysicsTools.NanoAOD.simpleCandidateFlatTableProducer_cfi import simpleCandidateFlatTableProducer -from Configuration.Eras.Modifier_run3_scouting_nanoAOD_2023_cff import run3_scouting_nanoAOD_2023 -from Configuration.Eras.Modifier_run3_scouting_nanoAOD_2024_cff import run3_scouting_nanoAOD_2024 +from Configuration.Eras.Modifier_run3_scouting_2023_cff import run3_scouting_2023 +from Configuration.Eras.Modifier_run3_scouting_2024_cff import run3_scouting_2024 +from Configuration.Eras.Modifier_run3_scouting_2025_cff import run3_scouting_2025 ##################################### ##### Scouting Original Objects ##### @@ -125,7 +126,7 @@ # used for both primary vertex and dimuon displaced vertex # https://github.com/cms-sw/cmssw/blob/CMSSW_14_0_X/DataFormats/Scouting/interface/Run3ScoutingVertex.h -run3_scouting_nanoAOD_2024.toModify( +(run3_scouting_2024 | run3_scouting_2025).toModify( scoutingVertexVariables, xyCov = Var('xyCov', 'float', precision=10, doc='xy covariance'), xzCov = Var('xzCov', 'float', precision=10, doc='xz covariance'), @@ -234,7 +235,7 @@ DeltaPhiMax = cms.vdouble(0.06, 0.06) ) -(run3_scouting_nanoAOD_2023 | run3_scouting_nanoAOD_2024).toModify( +(run3_scouting_2023 | run3_scouting_2024 | run3_scouting_2025).toModify( scoutingElectronTable.variables, d0 = None, # replaced with trkd0 (std::vector) dz = None, # replaced with trkdz (std::vector) @@ -253,7 +254,7 @@ # scouting electron format changed for 2024 data-taking in https://github.com/cms-sw/cmssw/pull/43744 # https://github.com/cms-sw/cmssw/blob/CMSSW_14_0_X/DataFormats/Scouting/interface/Run3ScoutingElectron.h -run3_scouting_nanoAOD_2024.toModify( +(run3_scouting_2024 | run3_scouting_2025).toModify( scoutingElectronTable.variables, rawEnergy = Var("rawEnergy", "float", precision=10, doc="raw energy"), preshowerEnergy = Var("preshowerEnergy", "float", precision=10, doc='preshower energy'), @@ -301,7 +302,7 @@ # scouting photon format changed for 2024 data-taking in https://github.com/cms-sw/cmssw/pull/43744 # https://github.com/cms-sw/cmssw/blob/CMSSW_14_0_X/DataFormats/Scouting/interface/Run3ScoutingPhoton.h -run3_scouting_nanoAOD_2024.toModify( +(run3_scouting_2024 | run3_scouting_2025).toModify( scoutingPhotonTable.variables, rawEnergy = Var("rawEnergy", "float", precision=10, doc="raw energy"), preshowerEnergy = Var("preshowerEnergy", "float", precision=10, doc='preshower energy'), @@ -702,7 +703,7 @@ debugMode = cms.untracked.bool(False), ) -run3_scouting_nanoAOD_2024.toModify( +(run3_scouting_2024 | run3_scouting_2025).toModify( scoutingFatPFJetReclusterGlobalParticleTransformerJetTags, model_path = cms.FileInPath("RecoBTag/Combined/data/Run3Scouting/GlobalParticleTransformerAK8/General/V00/global-part_2024.onnx") ) diff --git a/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc new file mode 100644 index 0000000000000..975615a429b9b --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATElectronCandidatesRekeyer.cc @@ -0,0 +1,75 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/PatCandidates/interface/Electron.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + class PATElectronCandidatesRekeyer : public edm::stream::EDProducer<> { + public: + explicit PATElectronCandidatesRekeyer(const edm::ParameterSet &iConfig); + ~PATElectronCandidatesRekeyer() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT> src_; + edm::EDGetTokenT pcNewCandViewToken_; + edm::EDGetTokenT pcNewToken_; + }; + +} // namespace pat + +using namespace pat; + +PATElectronCandidatesRekeyer::PATElectronCandidatesRekeyer(const edm::ParameterSet &iConfig) + : + + src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_( + consumes(iConfig.getParameter("packedPFCandidatesNew"))) { + produces>(); +} + +PATElectronCandidatesRekeyer::~PATElectronCandidatesRekeyer() {} + +void PATElectronCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle> src; + iEvent.getByToken(src_, src); + + edm::Handle pcNewCandViewHandle; + iEvent.getByToken(pcNewCandViewToken_, pcNewCandViewHandle); + + edm::Handle pcNewHandle; + iEvent.getByToken(pcNewToken_, pcNewHandle); + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(src->size()); + + for (const auto &obj : *src) { + // copy original pat object and append to vector + outPtrP->emplace_back(obj); + + std::vector keys; + for (const edm::Ref &ref : outPtrP->back().associatedPackedPFCandidates()) { + keys.push_back(ref.key()); + }; + outPtrP->back().setAssociatedPackedPFCandidates( + edm::RefProd(pcNewHandle), keys.begin(), keys.end()); + outPtrP->back().refToOrig_ = + (keys.size() == 1) ? outPtrP->back().sourceCandidatePtr(0) : reco::CandidatePtr(pcNewHandle.id()); + } + iEvent.put(std::move(outPtrP)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PATElectronCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc new file mode 100644 index 0000000000000..7f15584816700 --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATJetCandidatesRekeyer.cc @@ -0,0 +1,105 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/PatCandidates/interface/Jet.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + class PATJetCandidatesRekeyer : public edm::stream::EDProducer<> { + public: + explicit PATJetCandidatesRekeyer(const edm::ParameterSet &iConfig); + ~PATJetCandidatesRekeyer() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT> src_; + edm::EDGetTokenT pcNewCandViewToken_; + edm::EDGetTokenT pcNewToken_; + // std::string subjetLabel_; + }; +} // namespace pat + +using namespace pat; + +PATJetCandidatesRekeyer::PATJetCandidatesRekeyer(const edm::ParameterSet &iConfig) + : src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_( + consumes(iConfig.getParameter("packedPFCandidatesNew"))) { + produces>(); + produces>("tagInfos"); +} + +PATJetCandidatesRekeyer::~PATJetCandidatesRekeyer() {} + +void PATJetCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle> src; + iEvent.getByToken(src_, src); + + edm::Handle pcNewCandViewHandle; + iEvent.getByToken(pcNewCandViewToken_, pcNewCandViewHandle); + + edm::Handle pcNewHandle; + iEvent.getByToken(pcNewToken_, pcNewHandle); + + edm::RefProd> h_tagInfosOut = + iEvent.getRefBeforePut>("tagInfos"); + auto tagInfosOut = std::make_unique>(); + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(src->size()); + + // + // + // + for (const auto &jet : *src) { + for (const auto &info : jet.tagInfosFwdPtr()) { + tagInfosOut->push_back(*info); + } + } + + edm::OrphanHandle> oh_tagInfosOut = iEvent.put(std::move(tagInfosOut), "tagInfos"); + + // + // + // + unsigned int tagInfoIndex = 0; + + for (const auto &obj : *src) { + // copy original pat object and append to vector + outPtrP->emplace_back(obj); + + reco::CompositePtrCandidate::daughters old = outPtrP->back().daughterPtrVector(); + outPtrP->back().clearDaughters(); + for (const auto &dauItr : old) { + outPtrP->back().addDaughter(edm::Ptr(pcNewHandle, dauItr.key())); + } + + // Copy the tag infos + for (TagInfoFwdPtrCollection::const_iterator iinfoBegin = outPtrP->back().tagInfosFwdPtr().begin(), + iinfoEnd = outPtrP->back().tagInfosFwdPtr().end(), + iinfo = iinfoBegin; + iinfo != iinfoEnd; + ++iinfo) { + // Update the "forward" bit of the FwdPtr to point at the new collection. + // ptr to "this" info in the global list + edm::Ptr outPtr(oh_tagInfosOut, tagInfoIndex); + outPtrP->back().updateFwdTagInfoFwdPtr(iinfo - iinfoBegin, outPtr); + ++tagInfoIndex; + } + } + + iEvent.put(std::move(outPtrP)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PATJetCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc new file mode 100644 index 0000000000000..618819d397416 --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATMuonCandidatesRekeyer.cc @@ -0,0 +1,77 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/PatCandidates/interface/Muon.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + class PATMuonCandidatesRekeyer : public edm::stream::EDProducer<> { + public: + explicit PATMuonCandidatesRekeyer(const edm::ParameterSet &iConfig); + ~PATMuonCandidatesRekeyer() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT> src_; + edm::EDGetTokenT pcNewCandViewToken_; + edm::EDGetTokenT pcNewToken_; + }; + +} // namespace pat + +using namespace pat; + +PATMuonCandidatesRekeyer::PATMuonCandidatesRekeyer(const edm::ParameterSet &iConfig) + : src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_( + consumes(iConfig.getParameter("packedPFCandidatesNew"))) { + produces>(); +} + +PATMuonCandidatesRekeyer::~PATMuonCandidatesRekeyer() {} + +void PATMuonCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle> src; + iEvent.getByToken(src_, src); + + edm::Handle pcNewCandViewHandle; + iEvent.getByToken(pcNewCandViewToken_, pcNewCandViewHandle); + + edm::Handle pcNewHandle; + iEvent.getByToken(pcNewToken_, pcNewHandle); + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(src->size()); + + for (const auto &obj : *src) { + // copy original pat object and append to vector + outPtrP->emplace_back(obj); + + // + std::vector keys; + for (size_t ic = 0; ic < outPtrP->back().numberOfSourceCandidatePtrs(); ++ic) { + const reco::CandidatePtr &candPtr = outPtrP->back().sourceCandidatePtr(ic); + if (candPtr.isNonnull()) { + keys.push_back(candPtr.key()); + } + } + if (keys.size() == 1) { + outPtrP->back().refToOrig_ = reco::CandidatePtr(pcNewCandViewHandle, keys[0]); + } + } + + iEvent.put(std::move(outPtrP)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PATMuonCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/PATObjectPuppiIsolationUpdater.cc b/PhysicsTools/PatAlgos/plugins/PATObjectPuppiIsolationUpdater.cc new file mode 100644 index 0000000000000..3358cd8bfc2ca --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATObjectPuppiIsolationUpdater.cc @@ -0,0 +1,119 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/PatCandidates/interface/Electron.h" +#include "DataFormats/PatCandidates/interface/Photon.h" +#include "DataFormats/PatCandidates/interface/Muon.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + template + class PATObjectPuppiIsolationUpdater : public edm::stream::EDProducer<> { + public: + explicit PATObjectPuppiIsolationUpdater(const edm::ParameterSet &iConfig); + ~PATObjectPuppiIsolationUpdater() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT> src_; + //PUPPI isolation tokens + edm::EDGetTokenT> PUPPIIsolation_charged_hadrons_; + edm::EDGetTokenT> PUPPIIsolation_neutral_hadrons_; + edm::EDGetTokenT> PUPPIIsolation_photons_; + //PUPPINoLeptons isolation tokens + edm::EDGetTokenT> PUPPINoLeptonsIsolation_charged_hadrons_; + edm::EDGetTokenT> PUPPINoLeptonsIsolation_neutral_hadrons_; + edm::EDGetTokenT> PUPPINoLeptonsIsolation_photons_; + }; +} // namespace pat + +using namespace pat; + +template +PATObjectPuppiIsolationUpdater::PATObjectPuppiIsolationUpdater(const edm::ParameterSet &iConfig) + : src_(consumes>(iConfig.getParameter("src"))) { + PUPPIIsolation_charged_hadrons_ = + consumes>(iConfig.getParameter("puppiIsolationChargedHadrons")); + PUPPIIsolation_neutral_hadrons_ = + consumes>(iConfig.getParameter("puppiIsolationNeutralHadrons")); + PUPPIIsolation_photons_ = + consumes>(iConfig.getParameter("puppiIsolationPhotons")); + if constexpr (std::is_same::value || std::is_same::value) { + PUPPINoLeptonsIsolation_charged_hadrons_ = + consumes>(iConfig.getParameter("puppiNoLeptonsIsolationChargedHadrons")); + PUPPINoLeptonsIsolation_neutral_hadrons_ = + consumes>(iConfig.getParameter("puppiNoLeptonsIsolationNeutralHadrons")); + PUPPINoLeptonsIsolation_photons_ = + consumes>(iConfig.getParameter("puppiNoLeptonsIsolationPhotons")); + } + produces>(); +} + +template +PATObjectPuppiIsolationUpdater::~PATObjectPuppiIsolationUpdater() {} + +template +void PATObjectPuppiIsolationUpdater::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle> src; + iEvent.getByToken(src_, src); + + //value maps for puppi isolation + edm::Handle> PUPPIIsolation_charged_hadrons; + edm::Handle> PUPPIIsolation_neutral_hadrons; + edm::Handle> PUPPIIsolation_photons; + //value maps for puppiNoLeptons isolation + edm::Handle> PUPPINoLeptonsIsolation_charged_hadrons; + edm::Handle> PUPPINoLeptonsIsolation_neutral_hadrons; + edm::Handle> PUPPINoLeptonsIsolation_photons; + + //puppi + iEvent.getByToken(PUPPIIsolation_charged_hadrons_, PUPPIIsolation_charged_hadrons); + iEvent.getByToken(PUPPIIsolation_neutral_hadrons_, PUPPIIsolation_neutral_hadrons); + iEvent.getByToken(PUPPIIsolation_photons_, PUPPIIsolation_photons); + //puppiNoLeptons + + if constexpr (std::is_same::value || std::is_same::value) { + iEvent.getByToken(PUPPINoLeptonsIsolation_charged_hadrons_, PUPPINoLeptonsIsolation_charged_hadrons); + iEvent.getByToken(PUPPINoLeptonsIsolation_neutral_hadrons_, PUPPINoLeptonsIsolation_neutral_hadrons); + iEvent.getByToken(PUPPINoLeptonsIsolation_photons_, PUPPINoLeptonsIsolation_photons); + } + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(src->size()); + + for (size_t i = 0; i < src->size(); ++i) { + // copy original pat object and append to vector + outPtrP->emplace_back((*src)[i]); + + edm::Ptr objPtr(src, i); + + outPtrP->back().setIsolationPUPPI((*PUPPIIsolation_charged_hadrons)[objPtr], + (*PUPPIIsolation_neutral_hadrons)[objPtr], + (*PUPPIIsolation_photons)[objPtr]); + + if constexpr (std::is_same::value || std::is_same::value) { + outPtrP->back().setIsolationPUPPINoLeptons((*PUPPINoLeptonsIsolation_charged_hadrons)[objPtr], + (*PUPPINoLeptonsIsolation_neutral_hadrons)[objPtr], + (*PUPPINoLeptonsIsolation_photons)[objPtr]); + } + } + iEvent.put(std::move(outPtrP)); +} + +typedef PATObjectPuppiIsolationUpdater PATElectronPuppiIsolationUpdater; +typedef PATObjectPuppiIsolationUpdater PATPhotonPuppiIsolationUpdater; +typedef PATObjectPuppiIsolationUpdater PATMuonPuppiIsolationUpdater; + +#include "FWCore/Framework/interface/MakerMacros.h" + +DEFINE_FWK_MODULE(PATElectronPuppiIsolationUpdater); +DEFINE_FWK_MODULE(PATPhotonPuppiIsolationUpdater); +DEFINE_FWK_MODULE(PATMuonPuppiIsolationUpdater); diff --git a/PhysicsTools/PatAlgos/plugins/PATPackedCandidateUpdater.cc b/PhysicsTools/PatAlgos/plugins/PATPackedCandidateUpdater.cc new file mode 100644 index 0000000000000..a81ca166b133f --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATPackedCandidateUpdater.cc @@ -0,0 +1,68 @@ +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" +#include "DataFormats/Common/interface/ValueMap.h" + +namespace pat { + class PATPackedCandidateUpdater : public edm::stream::EDProducer<> { + public: + explicit PATPackedCandidateUpdater(const edm::ParameterSet&); + ~PATPackedCandidateUpdater() override {} + + void produce(edm::Event&, const edm::EventSetup&) override; + + private: + edm::EDGetTokenT> candsToken_; + + bool updatePuppiWeights_; + edm::EDGetTokenT> puppiWeightToken_; + edm::EDGetTokenT> puppiWeightNoLepToken_; + }; +} // namespace pat + +using namespace pat; + +PATPackedCandidateUpdater::PATPackedCandidateUpdater(const edm::ParameterSet& iConfig) + : candsToken_(consumes>(iConfig.getParameter("src"))), + updatePuppiWeights_(iConfig.getParameter("updatePuppiWeights")), + puppiWeightToken_(consumes>(iConfig.getParameter("puppiWeight"))), + puppiWeightNoLepToken_(consumes>(iConfig.getParameter("puppiWeightNoLep"))) { + produces>(); +} + +void PATPackedCandidateUpdater::produce(edm::Event& iEvent, const edm::EventSetup&) { + edm::Handle> cands; + iEvent.getByToken(candsToken_, cands); + + edm::Handle> puppiWeight; + edm::Handle> puppiWeightNoLep; + if (updatePuppiWeights_) { + iEvent.getByToken(puppiWeightToken_, puppiWeight); + iEvent.getByToken(puppiWeightNoLepToken_, puppiWeightNoLep); + } + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(cands->size()); + + for (size_t ic = 0; ic < cands->size(); ++ic) { + // copy original pat::PackedCandidate and append to vector + outPtrP->emplace_back((*cands)[ic]); + + // Retrieve puppi weights from edm::ValueMap + pat::PackedCandidateRef pkref(cands, ic); + + if (updatePuppiWeights_) { + float puppiWeightVal = (*puppiWeight)[pkref]; + float puppiWeightNoLepVal = (*puppiWeightNoLep)[pkref]; + outPtrP->back().setPuppiWeight(puppiWeightVal, puppiWeightNoLepVal); + } + } + + iEvent.put(std::move(outPtrP)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PATPackedCandidateUpdater); diff --git a/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc new file mode 100644 index 0000000000000..9ff9da5d8d96e --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATPhotonCandidatesRekeyer.cc @@ -0,0 +1,76 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/PatCandidates/interface/Photon.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + class PATPhotonCandidatesRekeyer : public edm::stream::EDProducer<> { + public: + explicit PATPhotonCandidatesRekeyer(const edm::ParameterSet &iConfig); + ~PATPhotonCandidatesRekeyer() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT> src_; + edm::EDGetTokenT pcNewCandViewToken_; + edm::EDGetTokenT pcNewToken_; + }; + +} // namespace pat + +using namespace pat; + +PATPhotonCandidatesRekeyer::PATPhotonCandidatesRekeyer(const edm::ParameterSet &iConfig) + : src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_( + consumes(iConfig.getParameter("packedPFCandidatesNew"))) { + produces>(); +} + +PATPhotonCandidatesRekeyer::~PATPhotonCandidatesRekeyer() {} + +void PATPhotonCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle> src; + iEvent.getByToken(src_, src); + + edm::Handle pcNewCandViewHandle; + iEvent.getByToken(pcNewCandViewToken_, pcNewCandViewHandle); + + edm::Handle pcNewHandle; + iEvent.getByToken(pcNewToken_, pcNewHandle); + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(src->size()); + + for (const auto &obj : *src) { + // copy original pat object and append to vector + outPtrP->emplace_back(obj); + + std::vector keys; + for (const edm::Ref &ref : outPtrP->back().associatedPackedPFCandidates()) { + keys.push_back(ref.key()); + }; + outPtrP->back().setAssociatedPackedPFCandidates( + edm::RefProd(pcNewHandle), keys.begin(), keys.end()); + if (keys.size() == 1) { + outPtrP->back().refToOrig_ = outPtrP->back().sourceCandidatePtr(0); + } else { + outPtrP->back().refToOrig_ = reco::CandidatePtr(pcNewHandle.id()); + } + } + iEvent.put(std::move(outPtrP)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PATPhotonCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc b/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc new file mode 100644 index 0000000000000..4e24987bf7efb --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/PATTauCandidatesRekeyer.cc @@ -0,0 +1,101 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/PatCandidates/interface/Tau.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + class PATTauCandidatesRekeyer : public edm::stream::EDProducer<> { + public: + explicit PATTauCandidatesRekeyer(const edm::ParameterSet &iConfig); + ~PATTauCandidatesRekeyer() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT> src_; + edm::EDGetTokenT pcNewCandViewToken_; + edm::EDGetTokenT pcNewToken_; + }; + +} // namespace pat + +using namespace pat; + +PATTauCandidatesRekeyer::PATTauCandidatesRekeyer(const edm::ParameterSet &iConfig) + : src_(consumes>(iConfig.getParameter("src"))), + pcNewCandViewToken_(consumes(iConfig.getParameter("packedPFCandidatesNew"))), + pcNewToken_( + consumes(iConfig.getParameter("packedPFCandidatesNew"))) { + produces>(); +} + +PATTauCandidatesRekeyer::~PATTauCandidatesRekeyer() {} + +void PATTauCandidatesRekeyer::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle> src; + iEvent.getByToken(src_, src); + + edm::Handle pcNewCandViewHandle; + iEvent.getByToken(pcNewCandViewToken_, pcNewCandViewHandle); + + edm::Handle pcNewHandle; + iEvent.getByToken(pcNewToken_, pcNewHandle); + + auto outPtrP = std::make_unique>(); + outPtrP->reserve(src->size()); + + for (const auto &obj : *src) { + // copy original pat object and append to vector + outPtrP->emplace_back(obj); + + reco::CandidatePtrVector signalChHPtrs; + for (const reco::CandidatePtr &p : outPtrP->back().signalChargedHadrCands()) { + signalChHPtrs.push_back(edm::Ptr(pcNewHandle, p.key())); + } + outPtrP->back().setSignalChargedHadrCands(signalChHPtrs); + + reco::CandidatePtrVector signalNHPtrs; + for (const reco::CandidatePtr &p : outPtrP->back().signalNeutrHadrCands()) { + signalNHPtrs.push_back(edm::Ptr(pcNewHandle, p.key())); + } + outPtrP->back().setSignalNeutralHadrCands(signalNHPtrs); + + reco::CandidatePtrVector signalGammaPtrs; + for (const reco::CandidatePtr &p : outPtrP->back().signalGammaCands()) { + signalGammaPtrs.push_back(edm::Ptr(pcNewHandle, p.key())); + } + outPtrP->back().setSignalGammaCands(signalGammaPtrs); + + reco::CandidatePtrVector isolationChHPtrs; + for (const reco::CandidatePtr &p : outPtrP->back().isolationChargedHadrCands()) { + isolationChHPtrs.push_back(edm::Ptr(pcNewHandle, p.key())); + } + outPtrP->back().setIsolationChargedHadrCands(isolationChHPtrs); + + reco::CandidatePtrVector isolationNHPtrs; + + for (const reco::CandidatePtr &p : outPtrP->back().isolationNeutrHadrCands()) { + isolationNHPtrs.push_back(edm::Ptr(pcNewHandle, p.key())); + } + outPtrP->back().setIsolationNeutralHadrCands(isolationNHPtrs); + + reco::CandidatePtrVector isolationGammaPtrs; + for (const reco::CandidatePtr &p : outPtrP->back().isolationGammaCands()) { + isolationGammaPtrs.push_back(edm::Ptr(pcNewHandle, p.key())); + } + outPtrP->back().setIsolationGammaCands(isolationGammaPtrs); + } + iEvent.put(std::move(outPtrP)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(PATTauCandidatesRekeyer); diff --git a/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc b/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc new file mode 100644 index 0000000000000..ae06de789e168 --- /dev/null +++ b/PhysicsTools/PatAlgos/plugins/VertexCompositeCandidateDaughtersRekeyer.cc @@ -0,0 +1,79 @@ +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/Common/interface/View.h" + +#include "DataFormats/Candidate/interface/VertexCompositePtrCandidate.h" +#include "DataFormats/Candidate/interface/VertexCompositeCandidate.h" +#include "DataFormats/Candidate/interface/VertexCompositeCandidateFwd.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/Candidate/interface/CandidateFwd.h" + +namespace pat { + class VertexCompositeCandidateDaughtersRekeyer : public edm::stream::EDProducer<> { + public: + explicit VertexCompositeCandidateDaughtersRekeyer(const edm::ParameterSet &iConfig); + ~VertexCompositeCandidateDaughtersRekeyer() override; + + void produce(edm::Event &, const edm::EventSetup &) override; + + private: + // configurables + edm::EDGetTokenT src_; + edm::EDGetTokenT pcOriToken_; + edm::EDGetTokenT pcNewToken_; + }; + +} // namespace pat + +using namespace pat; + +VertexCompositeCandidateDaughtersRekeyer::VertexCompositeCandidateDaughtersRekeyer(const edm::ParameterSet &iConfig) + : src_(consumes(iConfig.getParameter("src"))), + pcOriToken_( + consumes(iConfig.getParameter("packedPFCandidatesOri"))), + pcNewToken_( + consumes(iConfig.getParameter("packedPFCandidatesNew"))) { + produces(); +} + +VertexCompositeCandidateDaughtersRekeyer::~VertexCompositeCandidateDaughtersRekeyer() {} + +void VertexCompositeCandidateDaughtersRekeyer::produce(edm::Event &iEvent, edm::EventSetup const &) { + edm::Handle src; + iEvent.getByToken(src_, src); + + edm::Handle pcOriHandle; + iEvent.getByToken(pcOriToken_, pcOriHandle); + + edm::Handle pcNewHandle; + iEvent.getByToken(pcNewToken_, pcNewHandle); + + auto outPtrP = std::make_unique(); + outPtrP->reserve(src->size()); + + for (const auto &obj : *src) { + // copy original object and append to vector + outPtrP->emplace_back(obj); + + std::vector daughters = outPtrP->back().daughterPtrVector(); + outPtrP->back().clearDaughters(); + + for (const reco::CandidatePtr &dau : daughters) { + // + // We check if this CandidatePtr points to a candidate in the original packedPFCandidates collection + // This is needed because the CandidatePtr can point to a candidate in lostTracks collection + // + outPtrP->back().addDaughter((dau.id() == pcOriHandle.id()) ? edm::Ptr(pcNewHandle, dau.key()) + : dau); + } + } + iEvent.put(std::move(outPtrP)); +} + +#include "FWCore/Framework/interface/MakerMacros.h" +DEFINE_FWK_MODULE(VertexCompositeCandidateDaughtersRekeyer); diff --git a/PhysicsTools/PatAlgos/python/slimming/isolatedTracks_cfi.py b/PhysicsTools/PatAlgos/python/slimming/isolatedTracks_cfi.py index 11d9c9b6ba500..79aad38a83734 100644 --- a/PhysicsTools/PatAlgos/python/slimming/isolatedTracks_cfi.py +++ b/PhysicsTools/PatAlgos/python/slimming/isolatedTracks_cfi.py @@ -76,7 +76,5 @@ from Configuration.ProcessModifiers.pp_on_AA_cff import pp_on_AA pp_on_AA.toModify(isolatedTracks, useHighPurity = True) -def miniAOD_customizeIsolatedTracksFastSim(process): - """Switch off dE/dx hit info on fast sim, as it's not available""" - process.isolatedTracks.saveDeDxHitInfo = False - return process +from Configuration.Eras.Modifier_fastSim_cff import fastSim +fastSim.toModify(isolatedTracks, saveDeDxHitInfo = False) diff --git a/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py b/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py index 12a44d34a4f97..177a21b731b78 100644 --- a/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/metFilterPaths_cff.py @@ -44,19 +44,23 @@ Flag_trkPOG_logErrorTooManyClusters = cms.Path(~logErrorTooManyClusters) #add your new path here!! -allMetFilterPaths=['HBHENoiseFilter','HBHENoiseIsoFilter','CSCTightHaloFilter','CSCTightHaloTrkMuUnvetoFilter','CSCTightHalo2015Filter','globalTightHalo2016Filter','globalSuperTightHalo2016Filter','HcalStripHaloFilter','hcalLaserEventFilter','EcalDeadCellTriggerPrimitiveFilter','EcalDeadCellBoundaryEnergyFilter','ecalBadCalibFilter','goodVertices','eeBadScFilter', - 'ecalLaserCorrFilter','trkPOGFilters','chargedHadronTrackResolutionFilter','muonBadTrackFilter', - 'BadChargedCandidateFilter','BadPFMuonFilter', 'BadPFMuonDzFilter', 'hfNoisyHitsFilter', 'BadChargedCandidateSummer16Filter','BadPFMuonSummer16Filter', - 'trkPOG_manystripclus53X','trkPOG_toomanystripclus53X','trkPOG_logErrorTooManyClusters'] +#allMetFilterPaths=['HBHENoiseFilter','HBHENoiseIsoFilter','CSCTightHaloFilter','CSCTightHaloTrkMuUnvetoFilter','CSCTightHalo2015Filter','globalTightHalo2016Filter','globalSuperTightHalo2016Filter','HcalStripHaloFilter','hcalLaserEventFilter','EcalDeadCellTriggerPrimitiveFilter','EcalDeadCellBoundaryEnergyFilter','ecalBadCalibFilter','goodVertices','eeBadScFilter', +# 'ecalLaserCorrFilter','trkPOGFilters','chargedHadronTrackResolutionFilter','muonBadTrackFilter', +# 'BadChargedCandidateFilter','BadPFMuonFilter', 'BadPFMuonDzFilter', 'hfNoisyHitsFilter', 'BadChargedCandidateSummer16Filter','BadPFMuonSummer16Filter', +# 'trkPOG_manystripclus53X','trkPOG_toomanystripclus53X','trkPOG_logErrorTooManyClusters'] - -def miniAOD_customizeMETFiltersFastSim(process): - """Replace some MET filters that don't work in FastSim with trivial bools""" - for X in 'CSCTightHaloFilter', 'CSCTightHaloTrkMuUnvetoFilter','CSCTightHalo2015Filter','globalTightHalo2016Filter','globalSuperTightHalo2016Filter','HcalStripHaloFilter': - process.globalReplace(X, cms.EDFilter("HLTBool", result=cms.bool(True))) - for X in 'manystripclus53X', 'toomanystripclus53X', 'logErrorTooManyClusters': - process.globalReplace(X, cms.EDFilter("HLTBool", result=cms.bool(False))) - return process +"""Replace some MET filters that don't work in FastSim with trivial bools""" +_fake_bool = cms.EDFilter("HLTBool", result=cms.bool(True)) +from Configuration.Eras.Modifier_fastSim_cff import fastSim +fastSim.toReplaceWith( CSCTightHaloFilter, _fake_bool.clone( result = True)) +fastSim.toReplaceWith( CSCTightHaloTrkMuUnvetoFilter, _fake_bool.clone( result = True)) +fastSim.toReplaceWith( CSCTightHalo2015Filter, _fake_bool.clone( result = True)) +fastSim.toReplaceWith( globalTightHalo2016Filter, _fake_bool.clone( result = True)) +fastSim.toReplaceWith( globalSuperTightHalo2016Filter, _fake_bool.clone( result = True)) +fastSim.toReplaceWith( HcalStripHaloFilter, _fake_bool.clone( result = True)) +fastSim.toReplaceWith( manystripclus53X, _fake_bool.clone( result = False)) +fastSim.toReplaceWith( toomanystripclus53X, _fake_bool.clone( result = False)) +fastSim.toReplaceWith( logErrorTooManyClusters, _fake_bool.clone( result = False)) from Configuration.Eras.Modifier_phase2_common_cff import phase2_common phase2_common.toReplaceWith( Flag_trkPOG_manystripclus53X, cms.Path() ) diff --git a/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py b/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py new file mode 100644 index 0000000000000..e31901239dfd4 --- /dev/null +++ b/PhysicsTools/PatAlgos/python/slimming/miniAODFromMiniAOD_tools.py @@ -0,0 +1,330 @@ +import FWCore.ParameterSet.Config as cms +from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask, addToProcessAndTask + +def miniAODFromMiniAOD_customizeCommon(process): + + task = getPatAlgosToolsTask(process) + + ########################################################################### + # Set puppi producers to use the original packedPFCandidate collection + ########################################################################### + process.packedpuppi.candName = 'packedPFCandidates::@skipCurrentProcess' + process.packedpuppiNoLep.candName = 'packedPFCandidates::@skipCurrentProcess' + + ########################################################################### + # Update packedPFCandidates with the recomputed puppi weights + ########################################################################### + addToProcessAndTask("packedPFCandidates", cms.EDProducer("PATPackedCandidateUpdater", + src = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + updatePuppiWeights = cms.bool(True), + puppiWeight = cms.InputTag("packedpuppi"), + puppiWeightNoLep = cms.InputTag("packedpuppiNoLep"), + ), + process, task + ) + + ########################################################################### + # Recompute Puppi Isolation for muons, electrons and photons + ########################################################################### + from RecoMuon.MuonIsolation.muonIsolationPUPPI_cff import muonIsolationMiniAODPUPPI as _muonIsolationMiniAODPUPPI + from RecoMuon.MuonIsolation.muonIsolationPUPPI_cff import muonIsolationMiniAODPUPPINoLeptons as _muonIsolationMiniAODPUPPINoLeptons + + addToProcessAndTask('muonPUPPIIsolation', _muonIsolationMiniAODPUPPI.clone( + srcToIsolate = cms.InputTag('slimmedMuons', processName=cms.InputTag.skipCurrentProcess()), + srcForIsolationCone = cms.InputTag('packedPFCandidates', processName=cms.InputTag.skipCurrentProcess()), + puppiValueMap = cms.InputTag('packedpuppi'), + ), + process, task + ) + + addToProcessAndTask('muonPUPPINoLeptonsIsolation', _muonIsolationMiniAODPUPPINoLeptons.clone( + srcToIsolate = cms.InputTag('slimmedMuons', processName=cms.InputTag.skipCurrentProcess()), + srcForIsolationCone = cms.InputTag('packedPFCandidates', processName=cms.InputTag.skipCurrentProcess()), + puppiValueMap = cms.InputTag('packedpuppiNoLep'), + ), + process, task + ) + + addToProcessAndTask('slimmedMuonsUpdatedPuppiIsolation', cms.EDProducer('PATMuonPuppiIsolationUpdater', + src = cms.InputTag('slimmedMuons', processName=cms.InputTag.skipCurrentProcess()), + puppiIsolationChargedHadrons = cms.InputTag("muonPUPPIIsolation","h+-DR040-ThresholdVeto000-ConeVeto000"), + puppiIsolationNeutralHadrons = cms.InputTag("muonPUPPIIsolation","h0-DR040-ThresholdVeto000-ConeVeto001"), + puppiIsolationPhotons = cms.InputTag("muonPUPPIIsolation","gamma-DR040-ThresholdVeto000-ConeVeto001"), + puppiNoLeptonsIsolationChargedHadrons = cms.InputTag("muonPUPPINoLeptonsIsolation","h+-DR040-ThresholdVeto000-ConeVeto000"), + puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag("muonPUPPINoLeptonsIsolation","h0-DR040-ThresholdVeto000-ConeVeto001"), + puppiNoLeptonsIsolationPhotons = cms.InputTag("muonPUPPINoLeptonsIsolation","gamma-DR040-ThresholdVeto000-ConeVeto001"), + ), + process, task + ) + + from RecoEgamma.EgammaIsolationAlgos.egmPhotonIsolationPUPPI_cff import egmPhotonIsolationMiniAODPUPPI as _egmPhotonPUPPIIsolationForPhotons + from RecoEgamma.EgammaIsolationAlgos.egmElectronIsolationPUPPI_cff import egmElectronIsolationMiniAODPUPPI as _egmElectronIsolationMiniAODPUPPI + from RecoEgamma.EgammaIsolationAlgos.egmElectronIsolationPUPPI_cff import egmElectronIsolationMiniAODPUPPINoLeptons as _egmElectronIsolationMiniAODPUPPINoLeptons + + addToProcessAndTask('egmPhotonPUPPIIsolation', _egmPhotonPUPPIIsolationForPhotons.clone( + srcToIsolate = cms.InputTag('slimmedPhotons', processName=cms.InputTag.skipCurrentProcess()), + srcForIsolationCone = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + puppiValueMap = cms.InputTag('packedpuppi'), + ), + process, task + ) + + addToProcessAndTask('egmElectronPUPPIIsolation', _egmElectronIsolationMiniAODPUPPI.clone( + srcToIsolate = cms.InputTag('slimmedElectrons', processName=cms.InputTag.skipCurrentProcess()), + srcForIsolationCone = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + puppiValueMap = cms.InputTag('packedpuppi'), + ), + process, task + ) + + addToProcessAndTask('egmElectronPUPPINoLeptonsIsolation', _egmElectronIsolationMiniAODPUPPI.clone( + srcToIsolate = cms.InputTag('slimmedElectrons', processName=cms.InputTag.skipCurrentProcess()), + srcForIsolationCone = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + puppiValueMap = cms.InputTag('packedpuppiNoLep'), + ), + process, task + ) + + addToProcessAndTask('slimmedPhotonsUpdatedPuppiIsolation', cms.EDProducer('PATPhotonPuppiIsolationUpdater', + src = cms.InputTag('slimmedPhotons', processName=cms.InputTag.skipCurrentProcess()), + puppiIsolationChargedHadrons = cms.InputTag("egmPhotonPUPPIIsolation","h+-DR030-"), + puppiIsolationNeutralHadrons = cms.InputTag("egmPhotonPUPPIIsolation","h0-DR030-"), + puppiIsolationPhotons = cms.InputTag("egmPhotonPUPPIIsolation","gamma-DR030-"), + ), + process, task + ) + + addToProcessAndTask('slimmedElectronsUpdatedPuppiIsolation', cms.EDProducer('PATElectronPuppiIsolationUpdater', + src = cms.InputTag('slimmedElectrons', processName=cms.InputTag.skipCurrentProcess()), + puppiIsolationChargedHadrons = cms.InputTag("egmElectronPUPPIIsolation","h+-DR030-BarVeto000-EndVeto001"), + puppiIsolationNeutralHadrons = cms.InputTag("egmElectronPUPPIIsolation","h0-DR030-BarVeto000-EndVeto000"), + puppiIsolationPhotons = cms.InputTag("egmElectronPUPPIIsolation","gamma-DR030-BarVeto000-EndVeto008"), + puppiNoLeptonsIsolationChargedHadrons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","h+-DR030-BarVeto000-EndVeto001"), + puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","h0-DR030-BarVeto000-EndVeto000"), + puppiNoLeptonsIsolationPhotons = cms.InputTag("egmElectronPUPPINoLeptonsIsolation","gamma-DR030-BarVeto000-EndVeto008"), + ), + process, task + ) + + ########################################################################### + # Rekey jet constituents + ########################################################################### + addToProcessAndTask("slimmedJets", cms.EDProducer("PATJetCandidatesRekeyer", + src = cms.InputTag("slimmedJets", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedJetsPuppiPreRekey", process.slimmedJetsPuppi.clone(), process, task) + del process.slimmedJetsPuppi + + addToProcessAndTask("slimmedJetsPuppi", cms.EDProducer("PATJetCandidatesRekeyer", + src = cms.InputTag("slimmedJetsPuppiPreRekey"), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedJetsAK8PreRekey", process.slimmedJetsAK8.clone(), process, task) + del process.slimmedJetsAK8 + + addToProcessAndTask("slimmedJetsAK8", cms.EDProducer("PATJetCandidatesRekeyer", + src = cms.InputTag("slimmedJetsAK8PreRekey"), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("selectedUpdatedPatJetsAK8PFPuppiSoftDropSubjetsSlimmedDeepFlavourPreRekey", + process.selectedUpdatedPatJetsAK8PFPuppiSoftDropSubjetsSlimmedDeepFlavour.clone(), + process, + task + ) + del process.selectedUpdatedPatJetsAK8PFPuppiSoftDropSubjetsSlimmedDeepFlavour + + addToProcessAndTask("selectedUpdatedPatJetsAK8PFPuppiSoftDropSubjetsSlimmedDeepFlavour", cms.EDProducer("PATJetCandidatesRekeyer", + src = cms.InputTag("selectedUpdatedPatJetsAK8PFPuppiSoftDropSubjetsSlimmedDeepFlavourPreRekey"), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + ########################################################################### + # Rekey tau constituents + ########################################################################### + from Configuration.ProcessModifiers.run2_miniAOD_miniAODUL_cff import run2_miniAOD_miniAODUL + from Configuration.ProcessModifiers.run3_miniAOD_miniAODpre142X_cff import run3_miniAOD_miniAODpre142X + import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig + taus_to_use = 'slimmedTaus::@skipCurrentProcess' + idsToRun_for_taus = cms.PSet(idsToAdd=cms.vstring()) + run2_miniAOD_miniAODUL.toModify( + idsToRun_for_taus, idsToAdd=["deepTau2018v2p5"]) + if idsToRun_for_taus.idsToAdd: + if not hasattr(process,'tauTask'): process.tauTask = cms.Task() + taus_from_mini = taus_to_use + taus_to_use = 'slimmedTausUpdated' + tauIdEmbedder = tauIdConfig.TauIDEmbedder(process, debug=False, + originalTauName=taus_from_mini, + updatedTauName=taus_to_use, + postfix="M2M", + toKeep=idsToRun_for_taus.idsToAdd) + tauIdEmbedder.runTauID() + task.add(process.rerunMvaIsolationTaskM2M, getattr(process, taus_to_use)) + + addToProcessAndTask("slimmedTaus", cms.EDProducer("PATTauCandidatesRekeyer", + src = cms.InputTag(taus_to_use), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + boosted_taus_to_use = 'slimmedTausBoosted::@skipCurrentProcess' + idsToRun_for_boosted_taus = cms.PSet(idsToAdd=cms.vstring()) + run2_miniAOD_miniAODUL.toModify( + idsToRun_for_boosted_taus, idsToAdd=["mvaIso", "mvaIsoNewDM", "mvaIsoDR0p3", "againstEle", "boostedDeepTauRunIIv2p0"]) + run3_miniAOD_miniAODpre142X.toModify( + idsToRun_for_boosted_taus, idsToAdd=["boostedDeepTauRunIIv2p0"]) + if idsToRun_for_boosted_taus.idsToAdd: + if not hasattr(process,'tauTask'): process.tauTask = cms.Task() + boosted_taus_from_mini = boosted_taus_to_use + boosted_taus_to_use = 'slimmedTausBoostedUpdated' + tauIdEmbedder = tauIdConfig.TauIDEmbedder(process, debug=False, + originalTauName=boosted_taus_from_mini, + updatedTauName=boosted_taus_to_use, + postfix="BoostedM2M", + toKeep=idsToRun_for_boosted_taus.idsToAdd) + tauIdEmbedder.runTauID() + task.add(process.rerunMvaIsolationTaskBoostedM2M, getattr(process, boosted_taus_to_use)) + + addToProcessAndTask("slimmedTausBoosted", cms.EDProducer("PATTauCandidatesRekeyer", + src = cms.InputTag(boosted_taus_to_use), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates",processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + ########################################################################### + # Rekey candidates in electrons, photons and muons + ########################################################################### + addToProcessAndTask("slimmedElectrons", cms.EDProducer("PATElectronCandidatesRekeyer", + src = cms.InputTag("slimmedElectronsUpdatedPuppiIsolation"), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedLowPtElectrons", cms.EDProducer("PATElectronCandidatesRekeyer", + src = cms.InputTag("slimmedLowPtElectrons", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedPhotons", cms.EDProducer("PATPhotonCandidatesRekeyer", + src = cms.InputTag("slimmedPhotonsUpdatedPuppiIsolation"), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + + addToProcessAndTask("slimmedMuons", cms.EDProducer("PATMuonCandidatesRekeyer", + src = cms.InputTag("slimmedMuonsUpdatedPuppiIsolation"), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedDisplacedMuons", cms.EDProducer("PATMuonCandidatesRekeyer", + src = cms.InputTag("slimmedDisplacedMuons", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + ########################################################################### + # Rekey daughters of secondary vertices + ########################################################################### + addToProcessAndTask("slimmedKshortVertices", cms.EDProducer("VertexCompositeCandidateDaughtersRekeyer", + src = cms.InputTag("slimmedKshortVertices", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesOri = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedLambdaVertices", cms.EDProducer("VertexCompositeCandidateDaughtersRekeyer", + src = cms.InputTag("slimmedLambdaVertices", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesOri = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + addToProcessAndTask("slimmedSecondaryVertices", cms.EDProducer("VertexCompositeCandidateDaughtersRekeyer", + src = cms.InputTag("slimmedSecondaryVertices", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesOri = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()), + packedPFCandidatesNew = cms.InputTag("packedPFCandidates", processName=cms.InputTag.currentProcess()), + ), + process, task + ) + + + _modified_run2_task = task.copyAndExclude([getattr(process,thisone) for thisone in ['slimmedDisplacedMuons']]) + from PhysicsTools.PatAlgos.patRefitVertexProducer_cfi import patRefitVertexProducer + process.offlineSlimmedPrimaryVerticesWithBS = patRefitVertexProducer.clone( + srcVertices = "offlineSlimmedPrimaryVertices", + ) + + _modified_run2_task.add( process.offlineSlimmedPrimaryVerticesWithBS ) + run2_miniAOD_miniAODUL.toReplaceWith( + task, _modified_run2_task) + + mini_output = None + for out_name in process.outputModules_().keys(): + if out_name.startswith('MINIAOD'): + mini_output = getattr(process, out_name) + break + if mini_output: + for new_collection_to_keep in ['packedPFCandidates', + 'slimmedJets', + 'slimmedJetsPuppi', + 'slimmedJetsAK8', + 'slimmedJetsAK8PFPuppiSoftDropPacked_SubJets', + 'slimmedMETsPuppi', + 'slimmedTaus', + 'slimmedTausBoosted', + 'slimmedElectrons', + 'slimmedMuons', + 'slimmedPhotons', + 'slimmedLowPtElectrons', + 'slimmedKshortVertices', + 'slimmedLambdaVertices', + 'slimmedSecondaryVertices']: + new_collection_to_keep += '_*' if not '_' in new_collection_to_keep else '' + mini_output.outputCommands += [ + f'drop *_{new_collection_to_keep}_*', + f'keep *_{new_collection_to_keep}_{process.name_()}'] + + return process + +def miniAODFromMiniAOD_customizeData(process): + from PhysicsTools.PatAlgos.tools.puppiJetMETReclusteringFromMiniAOD_cff import puppiJetMETReclusterFromMiniAOD_Data + process = puppiJetMETReclusterFromMiniAOD_Data(process) + return process + +def miniAODFromMiniAOD_customizeMC(process): + from PhysicsTools.PatAlgos.tools.puppiJetMETReclusteringFromMiniAOD_cff import puppiJetMETReclusterFromMiniAOD_MC + process = puppiJetMETReclusterFromMiniAOD_MC(process) + return process + +def miniAODFromMiniAOD_customizeAllData(process): + process = miniAODFromMiniAOD_customizeData(process) + process = miniAODFromMiniAOD_customizeCommon(process) + return process + +def miniAODFromMiniAOD_customizeAllMC(process): + process = miniAODFromMiniAOD_customizeMC(process) + process = miniAODFromMiniAOD_customizeCommon(process) + return process diff --git a/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py b/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py index f2bb6cb2316ce..bd50695a3e77d 100644 --- a/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py +++ b/PhysicsTools/PatAlgos/python/slimming/miniAOD_tools.py @@ -655,6 +655,17 @@ def miniAOD_customizeMC(process): pp_on_AA.toModify(process, removeJECsForMC) pp_on_AA.toReplaceWith(task,task.copyAndExclude([process.slimmedGenJetsFlavourInfos])) + from Configuration.Eras.Modifier_fastSim_cff import fastSim + if hasattr(process, 'patMuons'): + fastSim.toModify(process.patMuons, addTriggerMatching = False) + if hasattr(process, 'patJets'): + fastSim.toModify(process.patJets, addTagInfos = cms.bool(False) ) + if hasattr(process, 'slimmedJetsNoDeepFlavour'): + fastSim.toModify(process.slimmedJetsNoDeepFlavour, dropTagInfos = cms.string('1') ) + if hasattr(process, 'updatedPatJetsSlimmedDeepFlavour'): + fastSim.toModify(process.updatedPatJetsSlimmedDeepFlavour, addTagInfos = cms.bool(False) ) + if hasattr(process, "updatedPatJetsTransientCorrectedSlimmedDeepFlavour"): + fastSim.toModify(process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour, addTagInfos = cms.bool(False) ) def miniAOD_customizeOutput(out): from PhysicsTools.PatAlgos.slimming.MicroEventContent_cff import MiniAODOverrideBranchesSplitLevel @@ -704,20 +715,3 @@ def miniAOD_customizeAllMC(process): miniAOD_customizeCommon(process) miniAOD_customizeMC(process) return process - -def miniAOD_customizeAllMCFastSim(process): - miniAOD_customizeCommon(process) - miniAOD_customizeMC(process) - from PhysicsTools.PatAlgos.slimming.metFilterPaths_cff import miniAOD_customizeMETFiltersFastSim - process = miniAOD_customizeMETFiltersFastSim(process) - from PhysicsTools.PatAlgos.slimming.isolatedTracks_cfi import miniAOD_customizeIsolatedTracksFastSim - process = miniAOD_customizeIsolatedTracksFastSim(process) - process.patMuons.addTriggerMatching = False - # Disable pixelClusterTagInfos in FastSim (no siPixelCluster available) - from Configuration.Eras.Modifier_fastSim_cff import fastSim - fastSim.toModify(process.patJets, addTagInfos = cms.bool(False) ) - fastSim.toModify(process.slimmedJetsNoDeepFlavour, dropTagInfos = cms.string('1') ) - fastSim.toModify(process.updatedPatJetsSlimmedDeepFlavour, addTagInfos = cms.bool(False) ) - fastSim.toModify(process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour, addTagInfos = cms.bool(False) ) - - return process diff --git a/PhysicsTools/PatAlgos/python/tools/jetTools.py b/PhysicsTools/PatAlgos/python/tools/jetTools.py index 9ae1075dc9cba..a38c70840397a 100644 --- a/PhysicsTools/PatAlgos/python/tools/jetTools.py +++ b/PhysicsTools/PatAlgos/python/tools/jetTools.py @@ -408,7 +408,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou # Setup the PUPPI ValueMap that will consumed by the TagInfo producers. puppi_value_map = "puppi" - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): puppi_value_map = setupPuppiForPackedPF(process)[0] acceptedTagInfos = list() @@ -651,7 +651,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou # use right input tags when running with RECO PF candidates, which actually # depends of whether jets use "particleFlow" - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): vertex_associator = cms.InputTag("") else: vertex_associator = cms.InputTag("primaryVertexAssociation","original") @@ -680,7 +680,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou svUsed, flip, max_sip3dsig_for_flip = svSource, False, -1. # use right input tags when running with RECO PF candidates, which actually # depends of whether jets use "particleFlow" - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): vertex_associator = cms.InputTag("") else: vertex_associator = cms.InputTag("primaryVertexAssociation","original") @@ -710,7 +710,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou flip = False # use right input tags when running with RECO PF candidates, which actually # depends of whether jets use "particleFlow" - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): vertex_associator = cms.InputTag("") else: vertex_associator = cms.InputTag("primaryVertexAssociation","original") @@ -739,7 +739,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou flip = False # use right input tags when running with RECO PF candidates, which actually # depends of whether jets use "particleFlow" - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): puppi_value_map = setupPuppiForPackedPF(process)[0] vertex_associator = cms.InputTag("") else: @@ -786,7 +786,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou process, task) if btagInfo == 'pfDeepBoostedJetTagInfos': - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): # case 1: running over jets whose daughters are PackedCandidates (only via updateJetCollection for now) if 'updated' not in jetSource.value().lower(): raise ValueError("Invalid jet collection: %s. pfDeepBoostedJetTagInfos only supports running via updateJetCollection." % jetSource.value()) @@ -811,7 +811,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou process, task) if btagInfo == 'pfParticleNetTagInfos' or btagInfo == 'pfGlobalParticleTransformerAK8TagInfos': - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): # case 1: running over jets whose daughters are PackedCandidates (only via updateJetCollection for now) vertex_associator = "" elif pfCandidates.value() == 'particleFlow': @@ -841,7 +841,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou secondary_vertices = svSource flip_ip_sign = False sip3dSigMax = -1 - if pfCandidates.value() == 'packedPFCandidates': + if 'packedPFCandidates' in pfCandidates.value(): # case 1: running over jets whose daughters are PackedCandidates (only via updateJetCollection for now) vertex_associator = "" elif pfCandidates.value() == 'particleFlow': @@ -877,7 +877,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou svUsed, flip_ip_sign, max_sip3dsig_for_flip = cms.InputTag(btagPrefix+'inclusiveCandidateNegativeSecondaryVertices'+labelName+postfix), True, 10. else: svUsed, flip_ip_sign, max_sip3dsig_for_flip = svSource, False, -1. - if pfCandidates.value() != 'packedPFCandidates': + if 'packedPFCandidates' not in pfCandidates.value(): raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, pfParticleNetFromMiniAODAK4PuppiCentralTagInfos.clone( @@ -893,7 +893,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou acceptedTagInfos.append(btagInfo) elif btagInfo == 'pfParticleNetFromMiniAODAK4PuppiForwardTagInfos': # ParticleNetFromMiniAOD cannot be run on RECO inputs, so need a workaround - if pfCandidates.value() != 'packedPFCandidates': + if 'packedPFCandidates' not in pfCandidates.value(): raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, pfParticleNetFromMiniAODAK4PuppiForwardTagInfos.clone( @@ -911,7 +911,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou svUsed, flip_ip_sign, max_sip3dsig_for_flip = cms.InputTag(btagPrefix+'inclusiveCandidateNegativeSecondaryVertices'+labelName+postfix), True, 10. else: svUsed, flip_ip_sign, max_sip3dsig_for_flip = svSource, False, -1. - if pfCandidates.value() != 'packedPFCandidates': + if 'packedPFCandidates' not in pfCandidates.value(): raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, pfParticleNetFromMiniAODAK4CHSCentralTagInfos.clone( @@ -927,7 +927,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou acceptedTagInfos.append(btagInfo) elif btagInfo == 'pfParticleNetFromMiniAODAK4CHSForwardTagInfos': # ParticleNetFromMiniAOD cannot be run on RECO inputs, so need a workaround - if pfCandidates.value() != 'packedPFCandidates': + if 'packedPFCandidates' not in pfCandidates.value(): raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, pfParticleNetFromMiniAODAK4CHSForwardTagInfos.clone( @@ -941,7 +941,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou acceptedTagInfos.append(btagInfo) elif btagInfo == 'pfParticleNetFromMiniAODAK8TagInfos': # ParticleNetFromMiniAOD cannot be run on RECO inputs, so need a workaround - if pfCandidates.value() != 'packedPFCandidates': + if 'packedPFCandidates' not in pfCandidates.value(): raise ValueError("Invalid pfCandidates collection: %s." % pfCandidates.value()) addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, pfParticleNetFromMiniAODAK8TagInfos.clone( diff --git a/PhysicsTools/PatAlgos/python/tools/puppiJetMETReclusteringTools.py b/PhysicsTools/PatAlgos/python/tools/puppiJetMETReclusteringTools.py index fa04c124df112..71e13f349d319 100644 --- a/PhysicsTools/PatAlgos/python/tools/puppiJetMETReclusteringTools.py +++ b/PhysicsTools/PatAlgos/python/tools/puppiJetMETReclusteringTools.py @@ -8,7 +8,7 @@ def puppiAK4METReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDi task = getPatAlgosToolsTask(process) - pfLabel = "packedPFCandidates" + pfInputTag = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()) pvLabel = "offlineSlimmedPrimaryVertices" svLabel = "slimmedSecondaryVertices" muLabel = "slimmedMuons" @@ -37,7 +37,7 @@ def puppiAK4METReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDi # process.load("RecoJets.JetProducers.ak4PFJets_cfi") task.add(process.ak4PFJetsPuppi) - process.ak4PFJetsPuppi.src = pfLabel + process.ak4PFJetsPuppi.src = pfInputTag process.ak4PFJetsPuppi.srcWeights = puppiLabel from RecoJets.JetAssociationProducers.j2tParametersVX_cfi import j2tParametersVX @@ -62,7 +62,7 @@ def puppiAK4METReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDi jetSource = cms.InputTag("ak4PFJetsPuppi"), algo = "ak", rParam = 0.4, - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), @@ -96,7 +96,7 @@ def puppiAK4METReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDi from PhysicsTools.PatAlgos.slimming.slimmedJets_cfi import slimmedJets addToProcessAndTask('slimmedJetsPuppiNoDeepTags', slimmedJets.clone( src = "selectedPatJetsPuppi", - packedPFCandidates = pfLabel, + packedPFCandidates = pfInputTag, dropDaughters = "0", rekeyDaughters = "0", ), @@ -108,7 +108,7 @@ def puppiAK4METReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDi jetSource = cms.InputTag("slimmedJetsPuppiNoDeepTags"), # updateJetCollection defaults to MiniAOD inputs but # here it is made explicit (as in training or MINIAOD redoing) - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), @@ -131,6 +131,7 @@ def puppiAK4METReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDi runMetCorAndUncFromMiniAOD(process, isData=not(runOnMC), jetCollUnskimmed="slimmedJetsPuppi", + pfCandColl=pfInputTag, metType="Puppi", postfix="Puppi", jetFlavor="AK4PFPuppi", @@ -155,7 +156,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr task = getPatAlgosToolsTask(process) - pfLabel = "packedPFCandidates" + pfInputTag = cms.InputTag("packedPFCandidates", processName=cms.InputTag.skipCurrentProcess()) pvLabel = "offlineSlimmedPrimaryVertices" svLabel = "slimmedSecondaryVertices" muLabel = "slimmedMuons" @@ -188,7 +189,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr task.add(process.ak8PFJetsPuppiSoftDrop) # AK8 jet constituents for softdrop - process.ak8PFJetsPuppi.src = pfLabel + process.ak8PFJetsPuppi.src = pfInputTag process.ak8PFJetsPuppi.srcWeights = puppiLabel # AK8 jet constituents for softdrop @@ -223,7 +224,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr jetSource = cms.InputTag("ak8PFJetsPuppi"), algo = "ak", rParam = 0.8, - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), @@ -269,7 +270,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr labelName = "AK8PFPuppiSoftDrop", jetSource = cms.InputTag("ak8PFJetsPuppiSoftDrop"), btagDiscriminators = ["None"], - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), @@ -291,7 +292,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr rParam = 0.8, # needed for subjet flavor clustering explicitJTA = True, # needed for subjet b tagging svClustering = True, # needed for subjet b tagging - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), @@ -381,7 +382,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr addToProcessAndTask("slimmedJetsAK8PFPuppiSoftDropSubjetsNoDeepTags", cms.EDProducer("PATJetSlimmer", src = cms.InputTag("selectedPatJetsAK8PFPuppiSoftDropSubjets"), - packedPFCandidates = cms.InputTag(pfLabel), + packedPFCandidates = pfInputTag, dropJetVars = cms.string("1"), dropDaughters = cms.string("0"), rekeyDaughters = cms.string("0"), @@ -402,7 +403,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr jetSource = cms.InputTag("slimmedJetsAK8PFPuppiSoftDropSubjetsNoDeepTags"), # updateJetCollection defaults to MiniAOD inputs but # here it is made explicit (as in training or MINIAOD redoing) - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), @@ -430,7 +431,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr 'SoftDropPuppi' ), fixDaughters = cms.bool(False), - packedPFCandidates = cms.InputTag(pfLabel), + packedPFCandidates = pfInputTag, ), process, task ) @@ -455,7 +456,7 @@ def puppiAK8ReclusterFromMiniAOD(process, runOnMC, useExistingWeights, btagDiscr jetSource = cms.InputTag("slimmedJetsAK8NoDeepTags"), # updateJetCollection defaults to MiniAOD inputs but # here it is made explicit (as in training or MINIAOD redoing) - pfCandidates = cms.InputTag(pfLabel), + pfCandidates = pfInputTag, pvSource = cms.InputTag(pvLabel), svSource = cms.InputTag(svLabel), muSource = cms.InputTag(muLabel), diff --git a/PhysicsTools/TagAndProbe/src/TagProbeFitter.cc b/PhysicsTools/TagAndProbe/src/TagProbeFitter.cc index 95e152dbe40c8..4fa531c59dbdb 100644 --- a/PhysicsTools/TagAndProbe/src/TagProbeFitter.cc +++ b/PhysicsTools/TagAndProbe/src/TagProbeFitter.cc @@ -31,6 +31,8 @@ #include "RooThresholdCategory.h" #include "RooWorkspace.h" #include "RooTreeDataStore.h" +#include "RooAbsPdf.h" +#include "RooAbsArg.h" using namespace std; using namespace RooFit; diff --git a/RecoHGCal/TICL/plugins/SimTrackstersProducer.cc b/RecoHGCal/TICL/plugins/SimTrackstersProducer.cc index 3380afe11d1e6..346d867a17c5d 100644 --- a/RecoHGCal/TICL/plugins/SimTrackstersProducer.cc +++ b/RecoHGCal/TICL/plugins/SimTrackstersProducer.cc @@ -90,8 +90,9 @@ class SimTrackstersProducer : public edm::stream::EDProducer<> { const edm::EDGetTokenT> caloparticles_token_; const edm::EDGetTokenT MTDSimTrackstersToken_; - const edm::EDGetTokenT associatorMapSimClusterToReco_token_; - const edm::EDGetTokenT associatorMapCaloParticleToReco_token_; + const edm::EDGetTokenT> + associatorMapSimClusterToReco_token_; + const edm::EDGetTokenT> associatorMapCaloParticleToReco_token_; const edm::ESGetToken geom_token_; hgcal::RecHitTools rhtools_; const float fractionCut_; diff --git a/RecoLocalCalo/HGCalRecProducers/plugins/RecHitMapProducer.cc b/RecoLocalCalo/HGCalRecProducers/plugins/RecHitMapProducer.cc index 741d1614bc508..a7380435bef18 100644 --- a/RecoLocalCalo/HGCalRecProducers/plugins/RecHitMapProducer.cc +++ b/RecoLocalCalo/HGCalRecProducers/plugins/RecHitMapProducer.cc @@ -67,34 +67,41 @@ void RecHitMapProducer::produce(edm::StreamID, edm::Event& evt, const edm::Event const auto& bh_hits = evt.getHandle(hgcal_hits_token_[2]); // Check validity of all handles - if (!ee_hits.isValid() || !fh_hits.isValid() || !bh_hits.isValid()) { + if ((ee_hits.isValid()) && (fh_hits.isValid()) && (bh_hits.isValid())) { + // TODO may be worth to avoid dependency on the order + // of the collections, maybe using a map + edm::MultiSpan rechitSpan; + rechitSpan.add(*ee_hits); + rechitSpan.add(*fh_hits); + rechitSpan.add(*bh_hits); + + for (unsigned int i = 0; i < rechitSpan.size(); ++i) { + const auto recHitDetId = rechitSpan[i].detid(); + hitMapHGCal->emplace(recHitDetId, i); + } + } else { edm::LogWarning("HGCalRecHitMapProducer") << "One or more hit collections are unavailable. Returning an empty map."; - evt.put(std::move(hitMapHGCal), "hgcalRecHitMap"); - return; - } - - // TODO may be worth to avoid dependency on the order - // of the collections, maybe using a map - edm::MultiSpan rechitSpan; - rechitSpan.add(*ee_hits); - rechitSpan.add(*fh_hits); - rechitSpan.add(*bh_hits); - - for (unsigned int i = 0; i < rechitSpan.size(); ++i) { - const auto recHitDetId = rechitSpan[i].detid(); - hitMapHGCal->emplace(recHitDetId, i); } - evt.put(std::move(hitMapHGCal), "hgcalRecHitMap"); if (!hgcalOnly_) { auto hitMapBarrel = std::make_unique(); - edm::MultiSpan barrelRechitSpan; - barrelRechitSpan.add(evt.get(barrel_hits_token_[0])); - barrelRechitSpan.add(evt.get(barrel_hits_token_[1])); - for (unsigned int i = 0; i < barrelRechitSpan.size(); ++i) { - const auto recHitDetId = barrelRechitSpan[i].detId(); - hitMapBarrel->emplace(recHitDetId, i); + + // Retrieve collections + const auto& ecal_hits = evt.getHandle(barrel_hits_token_[0]); + const auto& hbhe_hits = evt.getHandle(barrel_hits_token_[1]); + + if ((ecal_hits.isValid()) && (hbhe_hits.isValid())) { + edm::MultiSpan barrelRechitSpan; + barrelRechitSpan.add(*ecal_hits); + barrelRechitSpan.add(*hbhe_hits); + for (unsigned int i = 0; i < barrelRechitSpan.size(); ++i) { + const auto recHitDetId = barrelRechitSpan[i].detId(); + hitMapBarrel->emplace(recHitDetId, i); + } + } else { + edm::LogWarning("RecHitMapProducer") + << "One or more barrel hit collections are unavailable. Returning an empty map."; } evt.put(std::move(hitMapBarrel), "barrelRecHitMap"); } diff --git a/RecoLocalCalo/HGCalRecProducers/python/HGCalRecHit_cfi.py b/RecoLocalCalo/HGCalRecProducers/python/HGCalRecHit_cfi.py index 9b18c144faeb4..32e1330999abe 100644 --- a/RecoLocalCalo/HGCalRecProducers/python/HGCalRecHit_cfi.py +++ b/RecoLocalCalo/HGCalRecProducers/python/HGCalRecHit_cfi.py @@ -59,6 +59,55 @@ def calcWeights(weightsPerLayer): res = [sum(wei)/2. for wei in zip(weightsPerLa 83.61, 83.61) +weightsPerLayer_V19 = cms.vdouble(dummy_weight, + 4.25, # MeV + 12.86, + 6.98, + 12.86, + 6.98, + 12.86, + 6.98, + 12.86, + 6.98, + 12.86, + 6.98, + 12.86, + 6.98, + 12.86, + 6.98, + 12.86, + 6.98, + 12.86, + 11.18, + 12.86, + 11.18, + 12.86, + 11.18, + 12.86, + 11.18, + 12.86, + 55.47, + 60.07, + 60.07, + 60.07, + 60.07, + 60.07, + 60.07, + 60.07, + 60.07, + 60.07, + 60.07, + 82.45, + 82.45, + 82.45, + 82.45, + 82.45, + 82.45, + 82.45, + 82.45, + 82.45, + 82.45) + dEdX = cms.PSet( # for v10 geometry @@ -141,6 +190,22 @@ def calcWeights(weightsPerLayer): res = [sum(wei)/2. for wei in zip(weightsPerLa 92.283895) ) +# for v19 geometry +dEdX_v19 = cms.PSet( + weights = cms.vdouble(calcWeights(weightsPerLayer_V19)), + + weightsNose = cms.vdouble(0.0, # there is no layer zero + 39.500245, # MeV + 39.756638, + 39.756638, + 39.756638, + 39.756638, + 66.020266, + 92.283895, + 92.283895) +) + + # HGCAL rechit producer HGCalRecHit = cms.EDProducer( "HGCalRecHitProducer", @@ -216,4 +281,4 @@ def calcWeights(weightsPerLayer): res = [sum(wei)/2. for wei in zip(weightsPerLa phase2_hgcalV19.toModify(HGCalRecHit, thicknessCorrection = [0.75, 0.76, 0.75, 0.76, 0.85, 0.85, 0.84, 0.85] , sciThicknessCorrection = 0.69, - layerWeights = dEdX_v16.weights) + layerWeights = dEdX_v19.weights) diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreImpl.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreImpl.cc index d1c062807f081..5fb52e52df071 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreImpl.cc +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreImpl.cc @@ -2,17 +2,18 @@ // #include "LCToCPAssociatorByEnergyScoreImpl.h" +#include #include "FWCore/MessageLogger/interface/MessageLogger.h" #include "SimDataFormats/CaloAnalysis/interface/CaloParticle.h" #include "SimDataFormats/CaloAnalysis/interface/SimCluster.h" #include "DataFormats/CaloRecHit/interface/CaloCluster.h" - +#include "DataFormats/ParticleFlowReco/interface/PFCluster.h" #include "SimCalorimetry/HGCalAssociatorProducers/interface/AssociatorTools.h" #include "DataFormats/EcalDetId/interface/EBDetId.h" -template -LCToCPAssociatorByEnergyScoreImpl::LCToCPAssociatorByEnergyScoreImpl( +template +LCToCPAssociatorByEnergyScoreImplT::LCToCPAssociatorByEnergyScoreImplT( edm::EDProductGetter const& productGetter, bool hardScatterOnly, std::shared_ptr recHitTools, @@ -29,9 +30,9 @@ LCToCPAssociatorByEnergyScoreImpl::LCToCPAssociatorByEnergyScoreImpl( layers_ = recHitTools_->lastLayerBarrel() + 1; } -template -ticl::association LCToCPAssociatorByEnergyScoreImpl::makeConnections( - const edm::Handle& cCCH, const edm::Handle& cPCH) const { +template +ticl::association LCToCPAssociatorByEnergyScoreImplT::makeConnections( + const edm::Handle& cCCH, const edm::Handle& cPCH) const { // Get collections const auto& clusters = *cCCH.product(); const auto& caloParticles = *cPCH.product(); @@ -121,39 +122,39 @@ ticl::association LCToCPAssociatorByEnergyScoreImpl::makeConnections( } #ifdef EDM_ML_DEBUG - LogDebug("LCToCPAssociatorByEnergyScoreImpl") << "cPOnLayer INFO" << std::endl; + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "cPOnLayer INFO" << std::endl; for (size_t cp = 0; cp < cPOnLayer.size(); ++cp) { - LogDebug("LCToCPAssociatorByEnergyScoreImpl") << "For CaloParticle Idx: " << cp << " we have: " << std::endl; + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "For CaloParticle Idx: " << cp << " we have: " << std::endl; for (size_t cpp = 0; cpp < cPOnLayer[cp].size(); ++cpp) { - LogDebug("LCToCPAssociatorByEnergyScoreImpl") << " On Layer: " << cpp << " we have:" << std::endl; - LogDebug("LCToCPAssociatorByEnergyScoreImpl") + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " On Layer: " << cpp << " we have:" << std::endl; + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " CaloParticleIdx: " << cPOnLayer[cp][cpp].caloParticleId << std::endl; - LogDebug("LCToCPAssociatorByEnergyScoreImpl") + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " Energy: " << cPOnLayer[cp][cpp].energy << std::endl; double tot_energy = 0.; for (auto const& haf : cPOnLayer[cp][cpp].hits_and_fractions) { //const HIT* hit = &(hits_[hitMap_->at(DetId(haf.first))]); const HIT* hit = hits_[hitMap_->at(haf.first)]; - LogDebug("LCToCPAssociatorByEnergyScoreImpl") << " Hits/fraction/energy: " << (uint32_t)haf.first << "/" - << haf.second << "/" << haf.second * hit->energy() << std::endl; + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " Hits/fraction/energy: " << (uint32_t)haf.first << "/" + << haf.second << "/" << haf.second * hit->energy() << std::endl; tot_energy += haf.second * hit->energy(); } - LogDebug("LCToCPAssociatorByEnergyScoreImpl") << " Tot Sum haf: " << tot_energy << std::endl; + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " Tot Sum haf: " << tot_energy << std::endl; for (auto const& lc : cPOnLayer[cp][cpp].layerClusterIdToEnergyAndScore) { - LogDebug("LCToCPAssociatorByEnergyScoreImpl") << " lcIdx/energy/score: " << lc.first << "/" - << lc.second.first << "/" << lc.second.second << std::endl; + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " lcIdx/energy/score: " << lc.first << "/" + << lc.second.first << "/" << lc.second.second << std::endl; } } } - LogDebug("LCToCPAssociatorByEnergyScoreImpl") << "detIdToCaloParticleId_Map INFO" << std::endl; + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "detIdToCaloParticleId_Map INFO" << std::endl; for (auto const& cp : detIdToCaloParticleId_Map) { - LogDebug("LCToCPAssociatorByEnergyScoreImpl") + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "For detId: " << (uint32_t)cp.first << " we have found the following connections with CaloParticles:" << std::endl; const HIT* hit = hits_[hitMap_->at(cp.first)]; for (auto const& cpp : cp.second) { - LogDebug("LCToCPAssociatorByEnergyScoreImpl") + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " CaloParticle Id: " << cpp.clusterId << " with fraction: " << cpp.fraction << " and energy: " << cpp.fraction * hit->energy() << std::endl; } @@ -295,14 +296,14 @@ ticl::association LCToCPAssociatorByEnergyScoreImpl::makeConnections( } } - LogDebug("LCToCPAssociatorByEnergyScoreImpl") + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << std::setw(10) << "LayerId:\t" << std::setw(12) << "layerCluster\t" << std::setw(10) << "lc energy\t" << std::setw(5) << "nhits\t" << std::setw(12) << "noise hits\t" << std::setw(22) << "maxCPId_byNumberOfHits\t" << std::setw(8) << "nhitsCP\t" << std::setw(13) << "maxCPId_byEnergy\t" << std::setw(20) << "maxEnergySharedLCandCP\t" << std::setw(22) << "totalCPEnergyOnLayer\t" << std::setw(22) << "energyFractionOfLCinCP\t" << std::setw(25) << "energyFractionOfCPinLC\t" << "\n"; - LogDebug("LCToCPAssociatorByEnergyScoreImpl") + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << std::setw(10) << lcLayerId << "\t" << std::setw(12) << lcId << "\t" << std::setw(10) << clusters[lcId].energy() << "\t" << std::setw(5) << numberOfHitsInLC << "\t" << std::setw(12) << numberOfNoiseHitsInLC << "\t" << std::setw(22) << maxCPId_byNumberOfHits << "\t" << std::setw(8) @@ -311,38 +312,38 @@ ticl::association LCToCPAssociatorByEnergyScoreImpl::makeConnections( << energyFractionOfLCinCP << "\t" << std::setw(25) << energyFractionOfCPinLC << "\n"; } // End of loop over LayerClusters - LogDebug("LCToCPAssociatorByEnergyScoreImpl") << "Improved cPOnLayer INFO" << std::endl; + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "Improved cPOnLayer INFO" << std::endl; for (size_t cp = 0; cp < cPOnLayer.size(); ++cp) { - LogDebug("LCToCPAssociatorByEnergyScoreImpl") << "For CaloParticle Idx: " << cp << " we have: " << std::endl; + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "For CaloParticle Idx: " << cp << " we have: " << std::endl; for (size_t cpp = 0; cpp < cPOnLayer[cp].size(); ++cpp) { - LogDebug("LCToCPAssociatorByEnergyScoreImpl") << " On Layer: " << cpp << " we have:" << std::endl; - LogDebug("LCToCPAssociatorByEnergyScoreImpl") + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " On Layer: " << cpp << " we have:" << std::endl; + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " CaloParticleIdx: " << cPOnLayer[cp][cpp].caloParticleId << std::endl; - LogDebug("LCToCPAssociatorByEnergyScoreImpl") + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " Energy: " << cPOnLayer[cp][cpp].energy << std::endl; double tot_energy = 0.; for (auto const& haf : cPOnLayer[cp][cpp].hits_and_fractions) { const HIT* hit = hits_[hitMap_->at(haf.first)]; - LogDebug("LCToCPAssociatorByEnergyScoreImpl") << " Hits/fraction/energy: " << (uint32_t)haf.first << "/" - << haf.second << "/" << haf.second * hit->energy() << std::endl; + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " Hits/fraction/energy: " << (uint32_t)haf.first << "/" + << haf.second << "/" << haf.second * hit->energy() << std::endl; tot_energy += haf.second * hit->energy(); } - LogDebug("LCToCPAssociatorByEnergyScoreImpl") << " Tot Sum haf: " << tot_energy << std::endl; + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " Tot Sum haf: " << tot_energy << std::endl; for (auto const& lc : cPOnLayer[cp][cpp].layerClusterIdToEnergyAndScore) { - LogDebug("LCToCPAssociatorByEnergyScoreImpl") << " lcIdx/energy/score: " << lc.first << "/" - << lc.second.first << "/" << lc.second.second << std::endl; + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " lcIdx/energy/score: " << lc.first << "/" + << lc.second.first << "/" << lc.second.second << std::endl; } } } - LogDebug("LCToCPAssociatorByEnergyScoreImpl") << "Improved detIdToCaloParticleId_Map INFO" << std::endl; + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "Improved detIdToCaloParticleId_Map INFO" << std::endl; for (auto const& cp : detIdToCaloParticleId_Map) { - LogDebug("LCToCPAssociatorByEnergyScoreImpl") + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "For detId: " << (uint32_t)cp.first << " we have found the following connections with CaloParticles:" << std::endl; const HIT* hit = hits_[hitMap_->at(cp.first)]; for (auto const& cpp : cp.second) { - LogDebug("LCToCPAssociatorByEnergyScoreImpl") + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " CaloParticle Id: " << cpp.clusterId << " with fraction: " << cpp.fraction << " and energy: " << cpp.fraction * hit->energy() << std::endl; } @@ -370,8 +371,8 @@ ticl::association LCToCPAssociatorByEnergyScoreImpl::makeConnections( if (clusters[lcId].energy() == 0. && !cpsInLayerCluster[lcId].empty()) { for (auto& cpPair : cpsInLayerCluster[lcId]) { cpPair.second = 1.; - LogDebug("LCToCPAssociatorByEnergyScoreImpl") << "layerClusterId : \t " << lcId << "\t CP id : \t" - << cpPair.first << "\t score \t " << cpPair.second << "\n"; + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "layerClusterId : \t " << lcId << "\t CP id : \t" + << cpPair.first << "\t score \t " << cpPair.second << "\n"; } continue; } @@ -411,8 +412,8 @@ ticl::association LCToCPAssociatorByEnergyScoreImpl::makeConnections( } // End of loop over Hits within a LayerCluster #ifdef EDM_ML_DEBUG if (cpsInLayerCluster[lcId].empty()) - LogDebug("LCToCPAssociatorByEnergyScoreImpl") << "layerCluster Id: \t" << lcId << "\tCP id:\t-1 " - << "\t score \t-1\n"; + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "layerCluster Id: \t" << lcId << "\tCP id:\t-1 " + << "\t score \t-1\n"; #endif } // End of loop over LayerClusters @@ -439,12 +440,12 @@ ticl::association LCToCPAssociatorByEnergyScoreImpl::makeConnections( if (CPenergy > 0.f) CPEnergyFractionInLC = maxEnergyLCinCP / CPenergy; - LogDebug("LCToCPAssociatorByEnergyScoreImpl") + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << std::setw(8) << "LayerId:\t" << std::setw(12) << "caloparticle\t" << std::setw(15) << "cp total energy\t" << std::setw(15) << "cpEnergyOnLayer\t" << std::setw(14) << "CPNhitsOnLayer\t" << std::setw(18) << "lcWithMaxEnergyInCP\t" << std::setw(15) << "maxEnergyLCinCP\t" << std::setw(20) << "CPEnergyFractionInLC" << "\n"; - LogDebug("LCToCPAssociatorByEnergyScoreImpl") + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << std::setw(8) << layerId << "\t" << std::setw(12) << cpId << "\t" << std::setw(15) << caloParticles[cpId].energy() << "\t" << std::setw(15) << CPenergy << "\t" << std::setw(14) << CPNumberOfHits << "\t" << std::setw(18) << lcWithMaxEnergyInCP << "\t" << std::setw(15) << maxEnergyLCinCP @@ -484,7 +485,7 @@ ticl::association LCToCPAssociatorByEnergyScoreImpl::makeConnections( lcPair.second.second += std::min(std::pow(lcFraction - cpFraction, 2), std::pow(cpFraction, 2)) * hitEnergyWeight * invCPEnergyWeight; #ifdef EDM_ML_DEBUG - LogDebug("LCToCPAssociatorByEnergyScoreImpl") + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "cpDetId:\t" << (uint32_t)cp_hitDetId << "\tlayerClusterId:\t" << layerClusterId << "\t" << "lcfraction,cpfraction:\t" << lcFraction << ", " << cpFraction << "\t" << "hitEnergyWeight:\t" << hitEnergyWeight << "\t" @@ -495,11 +496,11 @@ ticl::association LCToCPAssociatorByEnergyScoreImpl::makeConnections( } // End of loop over hits of CaloParticle on a Layer #ifdef EDM_ML_DEBUG if (cPOnLayer[cpId][layerId].layerClusterIdToEnergyAndScore.empty()) - LogDebug("LCToCPAssociatorByEnergyScoreImpl") << "CP Id: \t" << cpId << "\tLC id:\t-1 " - << "\t score \t-1\n"; + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "CP Id: \t" << cpId << "\tLC id:\t-1 " + << "\t score \t-1\n"; for (const auto& lcPair : cPOnLayer[cpId][layerId].layerClusterIdToEnergyAndScore) { - LogDebug("LCToCPAssociatorByEnergyScoreImpl") + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "CP Id: \t" << cpId << "\t LC id: \t" << lcPair.first << "\t score \t" << lcPair.second.second << "\t shared energy:\t" << lcPair.second.first << "\t shared energy fraction:\t" << (lcPair.second.first / CPenergy) << "\n"; @@ -511,19 +512,24 @@ ticl::association LCToCPAssociatorByEnergyScoreImpl::makeConnections( return {cpsInLayerCluster, cPOnLayer}; } -template -ticl::RecoToSimCollection LCToCPAssociatorByEnergyScoreImpl::associateRecoToSim( - const edm::Handle& cCCH, const edm::Handle& cPCH) const { - ticl::RecoToSimCollection returnValue(productGetter_); +template +ticl::RecoToSimCollectionT LCToCPAssociatorByEnergyScoreImplT::associateRecoToSim( + const edm::Handle& cCCH, const edm::Handle& cPCH) const { + ticl::RecoToSimCollectionT returnValue(productGetter_); + + if (!hitMap_ || hitMap_->empty()) { + edm::LogWarning("LCToCPAssociatorByEnergyScoreImplT") << "hitMap_ is null or empty, skipping association."; + return returnValue; // return empty collection + } const auto& links = makeConnections(cCCH, cPCH); const auto& cpsInLayerCluster = std::get<0>(links); for (size_t lcId = 0; lcId < cpsInLayerCluster.size(); ++lcId) { for (auto& cpPair : cpsInLayerCluster[lcId]) { - LogDebug("LCToCPAssociatorByEnergyScoreImpl") + LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "layerCluster Id: \t" << lcId << "\t CP id: \t" << cpPair.first << "\t score \t" << cpPair.second << "\n"; // Fill AssociationMap - returnValue.insert(edm::Ref(cCCH, lcId), // Ref to LC + returnValue.insert(edm::Ref(cCCH, lcId), // Ref to LC std::make_pair(edm::Ref(cPCH, cpPair.first), cpPair.second) // Pair ); @@ -532,10 +538,16 @@ ticl::RecoToSimCollection LCToCPAssociatorByEnergyScoreImpl::associateRecoT return returnValue; } -template -ticl::SimToRecoCollection LCToCPAssociatorByEnergyScoreImpl::associateSimToReco( - const edm::Handle& cCCH, const edm::Handle& cPCH) const { - ticl::SimToRecoCollection returnValue(productGetter_); +template +ticl::SimToRecoCollectionT LCToCPAssociatorByEnergyScoreImplT::associateSimToReco( + const edm::Handle& cCCH, const edm::Handle& cPCH) const { + ticl::SimToRecoCollectionT returnValue(productGetter_); + + if (!hitMap_ || hitMap_->empty()) { + edm::LogWarning("LCToCPAssociatorByEnergyScoreImplT") << "hitMap_ is null or empty, skipping association."; + return returnValue; // return empty collection + } + const auto& links = makeConnections(cCCH, cPCH); const auto& cPOnLayer = std::get<1>(links); for (size_t cpId = 0; cpId < cPOnLayer.size(); ++cpId) { @@ -543,7 +555,7 @@ ticl::SimToRecoCollection LCToCPAssociatorByEnergyScoreImpl::associateSimTo for (auto& lcPair : cPOnLayer[cpId][layerId].layerClusterIdToEnergyAndScore) { returnValue.insert( edm::Ref(cPCH, cpId), // Ref to CP - std::make_pair(edm::Ref(cCCH, lcPair.first), // Pair (cCCH, lcPair.first), // Pair > ); } @@ -552,5 +564,7 @@ ticl::SimToRecoCollection LCToCPAssociatorByEnergyScoreImpl::associateSimTo return returnValue; } -template class LCToCPAssociatorByEnergyScoreImpl; -template class LCToCPAssociatorByEnergyScoreImpl; +template class LCToCPAssociatorByEnergyScoreImplT; +template class LCToCPAssociatorByEnergyScoreImplT; +template class LCToCPAssociatorByEnergyScoreImplT; +template class LCToCPAssociatorByEnergyScoreImplT; diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreImpl.h b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreImpl.h index ceadbc52cb3ba..0fabcc4e80643 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreImpl.h +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreImpl.h @@ -9,6 +9,7 @@ #include "DataFormats/HGCRecHit/interface/HGCRecHit.h" #include "DataFormats/HGCRecHit/interface/HGCRecHitCollections.h" #include "DataFormats/ParticleFlowReco/interface/PFRecHit.h" +#include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h" #include "SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociator.h" #include "RecoLocalCalo/HGCalRecAlgos/interface/RecHitTools.h" @@ -64,20 +65,20 @@ namespace ticl { typedef std::tuple association; } // namespace ticl -template -class LCToCPAssociatorByEnergyScoreImpl : public ticl::LayerClusterToCaloParticleAssociatorBaseImpl { +template +class LCToCPAssociatorByEnergyScoreImplT : public ticl::LayerClusterToCaloParticleAssociatorBaseImplT { public: - explicit LCToCPAssociatorByEnergyScoreImpl(edm::EDProductGetter const &, - bool, - std::shared_ptr, - const std::unordered_map *, - const std::vector &hits); + explicit LCToCPAssociatorByEnergyScoreImplT(edm::EDProductGetter const &, + bool, + std::shared_ptr, + const std::unordered_map *, + const std::vector &hits); - ticl::RecoToSimCollection associateRecoToSim(const edm::Handle &cCH, - const edm::Handle &cPCH) const override; + ticl::RecoToSimCollectionT associateRecoToSim( + const edm::Handle &cCH, const edm::Handle &cPCH) const override; - ticl::SimToRecoCollection associateSimToReco(const edm::Handle &cCH, - const edm::Handle &cPCH) const override; + ticl::SimToRecoCollectionT associateSimToReco( + const edm::Handle &cCH, const edm::Handle &cPCH) const override; private: const bool hardScatterOnly_; @@ -85,13 +86,21 @@ class LCToCPAssociatorByEnergyScoreImpl : public ticl::LayerClusterToCaloParticl const std::unordered_map *hitMap_; unsigned layers_; edm::EDProductGetter const *productGetter_; - ticl::association makeConnections(const edm::Handle &cCH, + ticl::association makeConnections(const edm::Handle &cCH, const edm::Handle &cPCH) const; std::vector hits_; }; -extern template class LCToCPAssociatorByEnergyScoreImpl; -extern template class LCToCPAssociatorByEnergyScoreImpl; +extern template class LCToCPAssociatorByEnergyScoreImplT; +extern template class LCToCPAssociatorByEnergyScoreImplT; +extern template class LCToCPAssociatorByEnergyScoreImplT; +extern template class LCToCPAssociatorByEnergyScoreImplT; -using HGCalLCToCPAssociatorByEnergyScoreImpl = LCToCPAssociatorByEnergyScoreImpl; -using BarrelLCToCPAssociatorByEnergyScoreImpl = LCToCPAssociatorByEnergyScoreImpl; +using HGCalLCToCPAssociatorByEnergyScoreImpl = + LCToCPAssociatorByEnergyScoreImplT; +using BarrelLCToCPAssociatorByEnergyScoreImpl = + LCToCPAssociatorByEnergyScoreImplT; +using HGCalPCToCPAssociatorByEnergyScoreImpl = + LCToCPAssociatorByEnergyScoreImplT; +using BarrelPCToCPAssociatorByEnergyScoreImpl = + LCToCPAssociatorByEnergyScoreImplT; diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreProducer.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreProducer.cc index da04af8b4cfcc..fd0f88f5839f6 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreProducer.cc +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreProducer.cc @@ -2,8 +2,8 @@ #include -template -LCToCPAssociatorByEnergyScoreProducer::LCToCPAssociatorByEnergyScoreProducer(const edm::ParameterSet &ps) +template +LCToCPAssociatorByEnergyScoreProducerT::LCToCPAssociatorByEnergyScoreProducerT(const edm::ParameterSet &ps) : hitMap_(consumes>(ps.getParameter("hitMapTag"))), caloGeometry_(esConsumes()), hardScatterOnly_(ps.getParameter("hardScatterOnly")), @@ -18,16 +18,16 @@ LCToCPAssociatorByEnergyScoreProducer::LCToCPAssociatorByEnergyScoreProduce rhtools_ = std::make_shared(); // Register the product - produces(); + produces>(); } -template -LCToCPAssociatorByEnergyScoreProducer::~LCToCPAssociatorByEnergyScoreProducer() {} +template +LCToCPAssociatorByEnergyScoreProducerT::~LCToCPAssociatorByEnergyScoreProducerT() {} -template -void LCToCPAssociatorByEnergyScoreProducer::produce(edm::StreamID, - edm::Event &iEvent, - const edm::EventSetup &es) const { +template +void LCToCPAssociatorByEnergyScoreProducerT::produce(edm::StreamID, + edm::Event &iEvent, + const edm::EventSetup &es) const { edm::ESHandle geom = es.getHandle(caloGeometry_); rhtools_->setGeometry(*geom); @@ -39,8 +39,8 @@ void LCToCPAssociatorByEnergyScoreProducer::produce(edm::StreamID, // Check handle validity if (!hits_handle.isValid()) { - edm::LogWarning("LCToCPAssociatorByEnergyScoreProducer") - << "Hit collection not available for token. Skipping this collection."; + edm::LogWarning("LCToCPAssociatorByEnergyScoreProducerT") + << "HGCAL Hit collection not available for token. Skipping this collection."; continue; // Skip invalid handle } @@ -55,8 +55,8 @@ void LCToCPAssociatorByEnergyScoreProducer::produce(edm::StreamID, // Check handle validity if (!hits_handle.isValid()) { - edm::LogWarning("LCToCPAssociatorByEnergyScoreProducer") - << "Hit collection not available for token. Skipping this collection."; + edm::LogWarning("LCToCPAssociatorByEnergyScoreProducerT") + << "Barrel Hit collection not available for token. Skipping this collection."; continue; // Skip invalid handle } @@ -66,16 +66,30 @@ void LCToCPAssociatorByEnergyScoreProducer::produce(edm::StreamID, } } - const auto hitMap = &iEvent.get(hitMap_); + if (hits.empty()) { + edm::LogWarning("LCToCPAssociatorByEnergyScoreProducerT") << "No hits collected. Producing empty associator."; + } + + if (!iEvent.getHandle(hitMap_)) { + edm::LogWarning("LCToCPAssociatorByEnergyScoreProducerT") << "Hit map not valid. Producing empty associator."; - auto impl = std::make_unique>( + const std::unordered_map hitMap; // empty map + auto impl = std::make_unique>( + iEvent.productGetter(), hardScatterOnly_, rhtools_, &hitMap, hits); + auto emptyAssociator = std::make_unique>(std::move(impl)); + iEvent.put(std::move(emptyAssociator)); + return; + } + + const auto hitMap = &iEvent.get(hitMap_); + auto impl = std::make_unique>( iEvent.productGetter(), hardScatterOnly_, rhtools_, hitMap, hits); - auto toPut = std::make_unique(std::move(impl)); + auto toPut = std::make_unique>(std::move(impl)); iEvent.put(std::move(toPut)); } -template -void LCToCPAssociatorByEnergyScoreProducer::fillDescriptions(edm::ConfigurationDescriptions &cfg) { +template +void LCToCPAssociatorByEnergyScoreProducerT::fillDescriptions(edm::ConfigurationDescriptions &cfg) { edm::ParameterSetDescription desc; desc.add("hardScatterOnly", true); if constexpr (std::is_same_v) { diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreProducer.h b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreProducer.h index 258d753db6f1e..9fa906dfb60c5 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreProducer.h +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreProducer.h @@ -20,11 +20,11 @@ #include "DataFormats/HGCRecHit/interface/HGCRecHitCollections.h" -template -class LCToCPAssociatorByEnergyScoreProducer : public edm::global::EDProducer<> { +template +class LCToCPAssociatorByEnergyScoreProducerT : public edm::global::EDProducer<> { public: - explicit LCToCPAssociatorByEnergyScoreProducer(const edm::ParameterSet &); - ~LCToCPAssociatorByEnergyScoreProducer() override; + explicit LCToCPAssociatorByEnergyScoreProducerT(const edm::ParameterSet &); + ~LCToCPAssociatorByEnergyScoreProducerT() override; static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); @@ -39,12 +39,22 @@ class LCToCPAssociatorByEnergyScoreProducer : public edm::global::EDProducer<> { std::vector>> hits_token_; }; -template class LCToCPAssociatorByEnergyScoreProducer; -template class LCToCPAssociatorByEnergyScoreProducer; +template class LCToCPAssociatorByEnergyScoreProducerT; +template class LCToCPAssociatorByEnergyScoreProducerT; +template class LCToCPAssociatorByEnergyScoreProducerT; +template class LCToCPAssociatorByEnergyScoreProducerT; -using HGCalLCToCPAssociatorByEnergyScoreProducer = LCToCPAssociatorByEnergyScoreProducer; +using HGCalLCToCPAssociatorByEnergyScoreProducer = + LCToCPAssociatorByEnergyScoreProducerT; DEFINE_FWK_MODULE(HGCalLCToCPAssociatorByEnergyScoreProducer); -using BarrelLCToCPAssociatorByEnergyScoreProducer = LCToCPAssociatorByEnergyScoreProducer; +using BarrelLCToCPAssociatorByEnergyScoreProducer = + LCToCPAssociatorByEnergyScoreProducerT; DEFINE_FWK_MODULE(BarrelLCToCPAssociatorByEnergyScoreProducer); +using HGCalPCToCPAssociatorByEnergyScoreProducer = + LCToCPAssociatorByEnergyScoreProducerT; +DEFINE_FWK_MODULE(HGCalPCToCPAssociatorByEnergyScoreProducer); +using BarrelPCToCPAssociatorByEnergyScoreProducer = + LCToCPAssociatorByEnergyScoreProducerT; +DEFINE_FWK_MODULE(BarrelPCToCPAssociatorByEnergyScoreProducer); #endif diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorEDProducer.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorEDProducer.cc index f17baf14adb21..79b37cac5f9c3 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorEDProducer.cc +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorEDProducer.cc @@ -22,66 +22,84 @@ #include "FWCore/MessageLogger/interface/MessageLogger.h" #include "SimDataFormats/CaloAnalysis/interface/CaloParticleFwd.h" +#include "SimDataFormats/CaloAnalysis/interface/CaloParticle.h" #include "DataFormats/CaloRecHit/interface/CaloClusterFwd.h" +#include "DataFormats/CaloRecHit/interface/CaloCluster.h" +#include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h" +#include "DataFormats/ParticleFlowReco/interface/PFCluster.h" #include "DataFormats/HGCRecHit/interface/HGCRecHitCollections.h" #include "DataFormats/ParticleFlowReco/interface/PFRecHitFwd.h" #include "FWCore/Utilities/interface/EDGetToken.h" // -// class decleration +// class declaration // -class LCToCPAssociatorEDProducer : public edm::global::EDProducer<> { +template +class LCToCPAssociatorEDProducerT : public edm::global::EDProducer<> { public: - explicit LCToCPAssociatorEDProducer(const edm::ParameterSet &); - ~LCToCPAssociatorEDProducer() override; + explicit LCToCPAssociatorEDProducerT(const edm::ParameterSet &); + ~LCToCPAssociatorEDProducerT() override = default; + + static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); private: void produce(edm::StreamID, edm::Event &, const edm::EventSetup &) const override; edm::EDGetTokenT CPCollectionToken_; - edm::EDGetTokenT LCCollectionToken_; - edm::EDGetTokenT associatorToken_; + edm::EDGetTokenT LCCollectionToken_; + edm::EDGetTokenT> associatorToken_; }; -LCToCPAssociatorEDProducer::LCToCPAssociatorEDProducer(const edm::ParameterSet &pset) { - produces(); - produces(); +template +LCToCPAssociatorEDProducerT::LCToCPAssociatorEDProducerT(const edm::ParameterSet &pset) { + produces>(); + produces>(); CPCollectionToken_ = consumes(pset.getParameter("label_cp")); - LCCollectionToken_ = consumes(pset.getParameter("label_lc")); + LCCollectionToken_ = consumes(pset.getParameter("label_lc")); associatorToken_ = - consumes(pset.getParameter("associator")); + consumes>(pset.getParameter("associator")); } -LCToCPAssociatorEDProducer::~LCToCPAssociatorEDProducer() {} - // // member functions // // ------------ method called to produce the data ------------ -void LCToCPAssociatorEDProducer::produce(edm::StreamID, edm::Event &iEvent, const edm::EventSetup &iSetup) const { +template +void LCToCPAssociatorEDProducerT::produce(edm::StreamID, + edm::Event &iEvent, + const edm::EventSetup &iSetup) const { using namespace edm; - edm::Handle theAssociator; + edm::Handle> theAssociator; iEvent.getByToken(associatorToken_, theAssociator); + if (!theAssociator.isValid()) { + edm::LogWarning("LCToCPAssociatorEDProducerT") << "Associator is unavailable."; + return; + } + Handle CPCollection; iEvent.getByToken(CPCollectionToken_, CPCollection); + if (!CPCollection.isValid()) { + edm::LogWarning("LCToCPAssociatorEDProducerT") << "CaloParticle collection is unavailable."; + return; + } - Handle LCCollection; + Handle LCCollection; iEvent.getByToken(LCCollectionToken_, LCCollection); - // Protection against missing CaloCluster collection + // Protection against missing cluster collection if (!LCCollection.isValid()) { - edm::LogWarning("LCToCPAssociatorEDProducer") - << "CaloCluster collection is unavailable. Producing empty associations."; + edm::LogWarning("LCToCPAssociatorEDProducerT") + << "Cluster collection is unavailable. Producing empty associations."; // Return empty collections - auto emptyRecSimColl = std::make_unique(); - auto emptySimRecColl = std::make_unique(); + auto emptyRecSimColl = std::make_unique>(); + auto emptySimRecColl = std::make_unique>(); iEvent.put(std::move(emptyRecSimColl)); iEvent.put(std::move(emptySimRecColl)); @@ -90,17 +108,29 @@ void LCToCPAssociatorEDProducer::produce(edm::StreamID, edm::Event &iEvent, cons // associate LC and CP LogTrace("AssociatorValidator") << "Calling associateRecoToSim method\n"; - ticl::RecoToSimCollection recSimColl = theAssociator->associateRecoToSim(LCCollection, CPCollection); + ticl::RecoToSimCollectionT recSimColl = theAssociator->associateRecoToSim(LCCollection, CPCollection); LogTrace("AssociatorValidator") << "Calling associateSimToReco method\n"; - ticl::SimToRecoCollection simRecColl = theAssociator->associateSimToReco(LCCollection, CPCollection); + ticl::SimToRecoCollectionT simRecColl = theAssociator->associateSimToReco(LCCollection, CPCollection); - auto rts = std::make_unique(recSimColl); - auto str = std::make_unique(simRecColl); + auto rts = std::make_unique>(recSimColl); + auto str = std::make_unique>(simRecColl); iEvent.put(std::move(rts)); iEvent.put(std::move(str)); } +template +void LCToCPAssociatorEDProducerT::fillDescriptions(edm::ConfigurationDescriptions &descriptions) { + edm::ParameterSetDescription desc; + desc.add("label_cp", edm::InputTag("cpAssocByEnergyScoreProducer")); + desc.add("label_lc", edm::InputTag("mix", "MergedCaloTruth")); + desc.add("associator", edm::InputTag("hgcalMergeLayerClusters")); + descriptions.addWithDefaultLabel(desc); +} + // define this as a plug-in +using LCToCPAssociatorEDProducer = LCToCPAssociatorEDProducerT; DEFINE_FWK_MODULE(LCToCPAssociatorEDProducer); +using PCToCPAssociatorEDProducer = LCToCPAssociatorEDProducerT; +DEFINE_FWK_MODULE(PCToCPAssociatorEDProducer); diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorByEnergyScoreImpl.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorByEnergyScoreImpl.cc index ebc07e0a54ad0..6044c7f1a7135 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorByEnergyScoreImpl.cc +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorByEnergyScoreImpl.cc @@ -4,8 +4,8 @@ #include "SimDataFormats/CaloAnalysis/interface/SimCluster.h" #include "DataFormats/CaloRecHit/interface/CaloCluster.h" -template -LCToSCAssociatorByEnergyScoreImpl::LCToSCAssociatorByEnergyScoreImpl( +template +LCToSCAssociatorByEnergyScoreImplT::LCToSCAssociatorByEnergyScoreImplT( edm::EDProductGetter const& productGetter, bool hardScatterOnly, std::shared_ptr recHitTools, @@ -22,9 +22,9 @@ LCToSCAssociatorByEnergyScoreImpl::LCToSCAssociatorByEnergyScoreImpl( layers_ = recHitTools_->lastLayerBarrel() + 1; //EB + 4 HB } -template -ticl::association LCToSCAssociatorByEnergyScoreImpl::makeConnections( - const edm::Handle& cCCH, const edm::Handle& sCCH) const { +template +ticl::association LCToSCAssociatorByEnergyScoreImplT::makeConnections( + const edm::Handle& cCCH, const edm::Handle& sCCH) const { // Get collections const auto& clusters = *cCCH.product(); const auto& simClusters = *sCCH.product(); @@ -37,7 +37,7 @@ ticl::association LCToSCAssociatorByEnergyScoreImpl::makeConnections( for (unsigned int scId = 0; scId < nSimClusters; ++scId) { if (hardScatterOnly_ && (simClusters[scId].g4Tracks()[0].eventId().event() != 0 or simClusters[scId].g4Tracks()[0].eventId().bunchCrossing() != 0)) { - LogDebug("LCToSCAssociatorByEnergyScoreImpl") + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << "Excluding SimCluster from event: " << simClusters[scId].g4Tracks()[0].eventId().event() << " with BX: " << simClusters[scId].g4Tracks()[0].eventId().bunchCrossing() << std::endl; continue; @@ -96,35 +96,35 @@ ticl::association LCToSCAssociatorByEnergyScoreImpl::makeConnections( } // end of loop over SimClusters #ifdef EDM_ML_DEBUG - LogDebug("LCToSCAssociatorByEnergyScoreImpl") + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << "lcsInSimCluster INFO (Only SimCluster filled at the moment)" << std::endl; - LogDebug("LCToSCAssociatorByEnergyScoreImpl") << " # of clusters : " << nLayerClusters << std::endl; + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << " # of clusters : " << nLayerClusters << std::endl; for (size_t sc = 0; sc < lcsInSimCluster.size(); ++sc) { - LogDebug("LCToSCAssociatorByEnergyScoreImpl") << "For SimCluster Idx: " << sc << " we have: " << std::endl; + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << "For SimCluster Idx: " << sc << " we have: " << std::endl; for (size_t sclay = 0; sclay < lcsInSimCluster[sc].size(); ++sclay) { - LogDebug("LCToSCAssociatorByEnergyScoreImpl") << " On Layer: " << sclay << " we have:" << std::endl; - LogDebug("LCToSCAssociatorByEnergyScoreImpl") + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << " On Layer: " << sclay << " we have:" << std::endl; + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << " SimClusterIdx: " << lcsInSimCluster[sc][sclay].simClusterId << std::endl; - LogDebug("LCToSCAssociatorByEnergyScoreImpl") + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << " Energy: " << lcsInSimCluster[sc][sclay].energy << std::endl; double tot_energy = 0.; for (auto const& haf : lcsInSimCluster[sc][sclay].hits_and_fractions) { const HIT* hit = hits_[hitMap_->at(haf.first)]; - LogDebug("LCToSCAssociatorByEnergyScoreImpl") << " Hits/fraction/energy: " << (uint32_t)haf.first << "/" - << haf.second << "/" << haf.second * hit->energy() << std::endl; + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << " Hits/fraction/energy: " << (uint32_t)haf.first << "/" + << haf.second << "/" << haf.second * hit->energy() << std::endl; tot_energy += haf.second * hit->energy(); } - LogDebug("LCToSCAssociatorByEnergyScoreImpl") << " Tot Sum haf: " << tot_energy << std::endl; + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << " Tot Sum haf: " << tot_energy << std::endl; for (auto const& lc : lcsInSimCluster[sc][sclay].layerClusterIdToEnergyAndScore) { - LogDebug("LCToSCAssociatorByEnergyScoreImpl") << " lcIdx/energy/score: " << lc.first << "/" - << lc.second.first << "/" << lc.second.second << std::endl; + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << " lcIdx/energy/score: " << lc.first << "/" + << lc.second.first << "/" << lc.second.second << std::endl; } } } - LogDebug("LCToSCAssociatorByEnergyScoreImpl") << "detIdToSimClusterId_Map INFO" << std::endl; + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << "detIdToSimClusterId_Map INFO" << std::endl; for (auto const& sc : detIdToSimClusterId_Map) { - LogDebug("LCToSCAssociatorByEnergyScoreImpl") + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << "For detId: " << (uint32_t)sc.first << " we have found the following connections with SimClusters:" << std::endl; // At this point here if you activate the printing you will notice cases where in a @@ -133,7 +133,7 @@ ticl::association LCToSCAssociatorByEnergyScoreImpl::makeConnections( // denominator of the score formula. const HIT* hit = hits_[hitMap_->at(sc.first)]; for (auto const& sclu : sc.second) { - LogDebug("LCToSCAssociatorByEnergyScoreImpl") + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << " SimCluster Id: " << sclu.clusterId << " with fraction: " << sclu.fraction << " and energy: " << sclu.fraction * hit->energy() << std::endl; } @@ -289,21 +289,21 @@ ticl::association LCToSCAssociatorByEnergyScoreImpl::makeConnections( } } - LogDebug("LCToSCAssociatorByEnergyScoreImpl") << std::setw(10) << "LayerId:" - << "\t" << std::setw(12) << "layerCluster" - << "\t" << std::setw(10) << "lc energy" - << "\t" << std::setw(5) << "nhits" - << "\t" << std::setw(12) << "noise hits" - << "\t" << std::setw(22) << "maxSCId_byNumberOfHits" - << "\t" << std::setw(8) << "nhitsSC" - << "\t" << std::setw(13) << "maxSCId_byEnergy" - << "\t" << std::setw(20) << "maxEnergySharedLCandSC" - << "\t" << std::setw(22) << "totalSCEnergyOnLayer" - << "\t" << std::setw(22) << "energyFractionOfLCinSC" - << "\t" << std::setw(25) << "energyFractionOfSCinLC" - << "\t" - << "\n"; - LogDebug("LCToSCAssociatorByEnergyScoreImpl") + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << std::setw(10) << "LayerId:" + << "\t" << std::setw(12) << "layerCluster" + << "\t" << std::setw(10) << "lc energy" + << "\t" << std::setw(5) << "nhits" + << "\t" << std::setw(12) << "noise hits" + << "\t" << std::setw(22) << "maxSCId_byNumberOfHits" + << "\t" << std::setw(8) << "nhitsSC" + << "\t" << std::setw(13) << "maxSCId_byEnergy" + << "\t" << std::setw(20) << "maxEnergySharedLCandSC" + << "\t" << std::setw(22) << "totalSCEnergyOnLayer" + << "\t" << std::setw(22) << "energyFractionOfLCinSC" + << "\t" << std::setw(25) << "energyFractionOfSCinLC" + << "\t" + << "\n"; + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << std::setw(10) << lcLayerId << "\t" << std::setw(12) << lcId << "\t" << std::setw(10) << clusters[lcId].energy() << "\t" << std::setw(5) << numberOfHitsInLC << "\t" << std::setw(12) << numberOfNoiseHitsInLC << "\t" << std::setw(22) << maxSCId_byNumberOfHits << "\t" << std::setw(8) @@ -312,40 +312,40 @@ ticl::association LCToSCAssociatorByEnergyScoreImpl::makeConnections( << energyFractionOfLCinSC << "\t" << std::setw(25) << energyFractionOfSCinLC << "\n"; } // End of loop over LayerClusters - LogDebug("LCToSCAssociatorByEnergyScoreImpl") + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << "Improved lcsInSimCluster INFO (Now containing the linked layer clusters id and energy - score still empty)" << std::endl; for (size_t sc = 0; sc < lcsInSimCluster.size(); ++sc) { - LogDebug("LCToSCAssociatorByEnergyScoreImpl") << "For SimCluster Idx: " << sc << " we have: " << std::endl; + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << "For SimCluster Idx: " << sc << " we have: " << std::endl; for (size_t sclay = 0; sclay < lcsInSimCluster[sc].size(); ++sclay) { - LogDebug("LCToSCAssociatorByEnergyScoreImpl") << " On Layer: " << sclay << " we have:" << std::endl; - LogDebug("LCToSCAssociatorByEnergyScoreImpl") + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << " On Layer: " << sclay << " we have:" << std::endl; + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << " SimClusterIdx: " << lcsInSimCluster[sc][sclay].simClusterId << std::endl; - LogDebug("LCToSCAssociatorByEnergyScoreImpl") + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << " Energy: " << lcsInSimCluster[sc][sclay].energy << std::endl; double tot_energy = 0.; for (auto const& haf : lcsInSimCluster[sc][sclay].hits_and_fractions) { const HIT* hit = hits_[hitMap_->at(haf.first)]; - LogDebug("LCToSCAssociatorByEnergyScoreImpl") << " Hits/fraction/energy: " << (uint32_t)haf.first << "/" - << haf.second << "/" << haf.second * hit->energy() << std::endl; + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << " Hits/fraction/energy: " << (uint32_t)haf.first << "/" + << haf.second << "/" << haf.second * hit->energy() << std::endl; tot_energy += haf.second * hit->energy(); } - LogDebug("LCToSCAssociatorByEnergyScoreImpl") << " Tot Sum haf: " << tot_energy << std::endl; + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << " Tot Sum haf: " << tot_energy << std::endl; for (auto const& lc : lcsInSimCluster[sc][sclay].layerClusterIdToEnergyAndScore) { - LogDebug("LCToSCAssociatorByEnergyScoreImpl") << " lcIdx/energy/score: " << lc.first << "/" - << lc.second.first << "/" << lc.second.second << std::endl; + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << " lcIdx/energy/score: " << lc.first << "/" + << lc.second.first << "/" << lc.second.second << std::endl; } } } - LogDebug("LCToSCAssociatorByEnergyScoreImpl") << "Improved detIdToSimClusterId_Map INFO" << std::endl; + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << "Improved detIdToSimClusterId_Map INFO" << std::endl; for (auto const& sc : detIdToSimClusterId_Map) { const HIT* hit = hits_[hitMap_->at(sc.first)]; - LogDebug("LCToSCAssociatorByEnergyScoreImpl") + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << "For detId: " << (uint32_t)sc.first << " we have found the following connections with SimClusters:" << std::endl; for (auto const& sclu : sc.second) { - LogDebug("LCToSCAssociatorByEnergyScoreImpl") + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << " SimCluster Id: " << sclu.clusterId << " with fraction: " << sclu.fraction << " and energy: " << sclu.fraction * hit->energy() << std::endl; } @@ -374,8 +374,8 @@ ticl::association LCToSCAssociatorByEnergyScoreImpl::makeConnections( if (clusters[lcId].energy() == 0. && !scsInLayerCluster[lcId].empty()) { for (auto& scPair : scsInLayerCluster[lcId]) { scPair.second = 1.; - LogDebug("LCToSCAssociatorByEnergyScoreImpl") << "layerClusterId : \t " << lcId << "\t SC id : \t" - << scPair.first << "\t score \t " << scPair.second << "\n"; + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << "layerClusterId : \t " << lcId << "\t SC id : \t" + << scPair.first << "\t score \t " << scPair.second << "\n"; } continue; } @@ -410,7 +410,7 @@ ticl::association LCToSCAssociatorByEnergyScoreImpl::makeConnections( scPair.second += std::min(std::pow(rhFraction - scFraction, 2), std::pow(rhFraction, 2)) * hitEnergyWeight * invLayerClusterEnergyWeight; #ifdef EDM_ML_DEBUG - LogDebug("LCToSCAssociatorByEnergyScoreImpl") + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << "rh_detid:\t" << (uint32_t)rh_detid << "\tlayerClusterId:\t" << lcId << "\t" << "rhfraction,scfraction:\t" << rhFraction << ", " << scFraction << "\t" << "hitEnergyWeight:\t" << hitEnergyWeight << "\t" @@ -421,9 +421,9 @@ ticl::association LCToSCAssociatorByEnergyScoreImpl::makeConnections( } // End of loop over Hits within a LayerCluster #ifdef EDM_ML_DEBUG if (scsInLayerCluster[lcId].empty()) - LogDebug("LCToSCAssociatorByEnergyScoreImpl") << "layerCluster Id: \t" << lcId << "\tSC id:\t-1 " - << "\t score \t-1" - << "\n"; + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << "layerCluster Id: \t" << lcId << "\tSC id:\t-1 " + << "\t score \t-1" + << "\n"; #endif } // End of loop over LayerClusters @@ -453,12 +453,12 @@ ticl::association LCToSCAssociatorByEnergyScoreImpl::makeConnections( if (SCenergy > 0.f) SCEnergyFractionInLC = maxEnergyLCinSC / SCenergy; - LogDebug("LCToSCAssociatorByEnergyScoreImpl") + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << std::setw(8) << "LayerId:\t" << std::setw(12) << "simcluster\t" << std::setw(15) << "sc total energy\t" << std::setw(15) << "scEnergyOnLayer\t" << std::setw(14) << "SCNhitsOnLayer\t" << std::setw(18) << "lcWithMaxEnergyInSC\t" << std::setw(15) << "maxEnergyLCinSC\t" << std::setw(20) << "SCEnergyFractionInLC" << "\n"; - LogDebug("LCToSCAssociatorByEnergyScoreImpl") + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << std::setw(8) << layerId << "\t" << std::setw(12) << scId << "\t" << std::setw(15) << simClusters[scId].energy() << "\t" << std::setw(15) << SCenergy << "\t" << std::setw(14) << SCNumberOfHits << "\t" << std::setw(18) << lcWithMaxEnergyInSC << "\t" << std::setw(15) << maxEnergyLCinSC << "\t" @@ -498,7 +498,7 @@ ticl::association LCToSCAssociatorByEnergyScoreImpl::makeConnections( lcPair.second.second += std::min(std::pow(lcFraction - scFraction, 2), std::pow(scFraction, 2)) * hitEnergyWeight * invSCEnergyWeight; #ifdef EDM_ML_DEBUG - LogDebug("LCToSCAssociatorByEnergyScoreImpl") + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << "scDetId:\t" << (uint32_t)sc_hitDetId << "\tlayerClusterId:\t" << layerClusterId << "\t" << "lcfraction,scfraction:\t" << lcFraction << ", " << scFraction << "\t" << "hitEnergyWeight:\t" << hitEnergyWeight << "\t" @@ -509,12 +509,12 @@ ticl::association LCToSCAssociatorByEnergyScoreImpl::makeConnections( } // End of loop over hits of SimCluster on a Layer #ifdef EDM_ML_DEBUG if (lcsInSimCluster[scId][layerId].layerClusterIdToEnergyAndScore.empty()) - LogDebug("LCToSCAssociatorByEnergyScoreImpl") << "SC Id: \t" << scId << "\tLC id:\t-1 " - << "\t score \t-1" - << "\n"; + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << "SC Id: \t" << scId << "\tLC id:\t-1 " + << "\t score \t-1" + << "\n"; for (const auto& lcPair : lcsInSimCluster[scId][layerId].layerClusterIdToEnergyAndScore) { - LogDebug("LCToSCAssociatorByEnergyScoreImpl") + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << "SC Id: \t" << scId << "\t LC id: \t" << lcPair.first << "\t score \t" << lcPair.second.second << "\t shared energy:\t" << lcPair.second.first << "\t shared energy fraction:\t" << (lcPair.second.first / SCenergy) << "\n"; @@ -526,19 +526,24 @@ ticl::association LCToSCAssociatorByEnergyScoreImpl::makeConnections( return {scsInLayerCluster, lcsInSimCluster}; } -template -ticl::RecoToSimCollectionWithSimClusters LCToSCAssociatorByEnergyScoreImpl::associateRecoToSim( - const edm::Handle& cCCH, const edm::Handle& sCCH) const { - ticl::RecoToSimCollectionWithSimClusters returnValue(productGetter_); +template +ticl::RecoToSimCollectionWithSimClustersT LCToSCAssociatorByEnergyScoreImplT::associateRecoToSim( + const edm::Handle& cCCH, const edm::Handle& sCCH) const { + ticl::RecoToSimCollectionWithSimClustersT returnValue(productGetter_); + + if (!hitMap_ || hitMap_->empty()) { + edm::LogWarning("LCToSCAssociatorByEnergyScoreImplT") << "hitMap_ is null or empty, skipping association."; + return returnValue; // return empty collection + } const auto& links = makeConnections(cCCH, sCCH); const auto& scsInLayerCluster = std::get<0>(links); for (size_t lcId = 0; lcId < scsInLayerCluster.size(); ++lcId) { for (auto& scPair : scsInLayerCluster[lcId]) { - LogDebug("LCToSCAssociatorByEnergyScoreImpl") + LogDebug("LCToSCAssociatorByEnergyScoreImplT") << "layerCluster Id: \t" << lcId << "\t SC id: \t" << scPair.first << "\t score \t" << scPair.second << "\n"; // Fill AssociationMap - returnValue.insert(edm::Ref(cCCH, lcId), // Ref to LC + returnValue.insert(edm::Ref(cCCH, lcId), // Ref to LC std::make_pair(edm::Ref(sCCH, scPair.first), scPair.second) // Pair ); @@ -547,10 +552,16 @@ ticl::RecoToSimCollectionWithSimClusters LCToSCAssociatorByEnergyScoreImpl: return returnValue; } -template -ticl::SimToRecoCollectionWithSimClusters LCToSCAssociatorByEnergyScoreImpl::associateSimToReco( - const edm::Handle& cCCH, const edm::Handle& sCCH) const { - ticl::SimToRecoCollectionWithSimClusters returnValue(productGetter_); +template +ticl::SimToRecoCollectionWithSimClustersT LCToSCAssociatorByEnergyScoreImplT::associateSimToReco( + const edm::Handle& cCCH, const edm::Handle& sCCH) const { + ticl::SimToRecoCollectionWithSimClustersT returnValue(productGetter_); + + if (!hitMap_ || hitMap_->empty()) { + edm::LogWarning("LCToSCAssociatorByEnergyScoreImplT") << "hitMap_ is null or empty, skipping association."; + return returnValue; // return empty collection + } + const auto& links = makeConnections(cCCH, sCCH); const auto& lcsInSimCluster = std::get<1>(links); for (size_t scId = 0; scId < lcsInSimCluster.size(); ++scId) { @@ -558,7 +569,7 @@ ticl::SimToRecoCollectionWithSimClusters LCToSCAssociatorByEnergyScoreImpl: for (auto& lcPair : lcsInSimCluster[scId][layerId].layerClusterIdToEnergyAndScore) { returnValue.insert( edm::Ref(sCCH, scId), // Ref to SC - std::make_pair(edm::Ref(cCCH, lcPair.first), // Pair (cCCH, lcPair.first), // Pair > ); } @@ -567,5 +578,7 @@ ticl::SimToRecoCollectionWithSimClusters LCToSCAssociatorByEnergyScoreImpl: return returnValue; } -template class LCToSCAssociatorByEnergyScoreImpl; -template class LCToSCAssociatorByEnergyScoreImpl; +template class LCToSCAssociatorByEnergyScoreImplT; +template class LCToSCAssociatorByEnergyScoreImplT; +template class LCToSCAssociatorByEnergyScoreImplT; +template class LCToSCAssociatorByEnergyScoreImplT; diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorByEnergyScoreImpl.h b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorByEnergyScoreImpl.h index 98d7a6335a252..ac4b2dc7ad086 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorByEnergyScoreImpl.h +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorByEnergyScoreImpl.h @@ -11,6 +11,7 @@ #include "DataFormats/ParticleFlowReco/interface/PFRecHit.h" #include "SimDataFormats/Associations/interface/LayerClusterToSimClusterAssociator.h" #include "RecoLocalCalo/HGCalRecAlgos/interface/RecHitTools.h" +#include "DataFormats/ParticleFlowReco/interface/PFCluster.h" namespace edm { class EDProductGetter; @@ -61,22 +62,20 @@ namespace ticl { typedef std::tuple association; } // namespace ticl -template -class LCToSCAssociatorByEnergyScoreImpl : public ticl::LayerClusterToSimClusterAssociatorBaseImpl { +template +class LCToSCAssociatorByEnergyScoreImplT : public ticl::LayerClusterToSimClusterAssociatorBaseImplT { public: - explicit LCToSCAssociatorByEnergyScoreImpl(edm::EDProductGetter const &, - bool, - std::shared_ptr, - const std::unordered_map *, - std::vector &hits); + explicit LCToSCAssociatorByEnergyScoreImplT(edm::EDProductGetter const &, + bool, + std::shared_ptr, + const std::unordered_map *, + std::vector &hits); - ticl::RecoToSimCollectionWithSimClusters associateRecoToSim( - const edm::Handle &cCH, - const edm::Handle &sCCH) const override; + ticl::RecoToSimCollectionWithSimClustersT associateRecoToSim( + const edm::Handle &cCH, const edm::Handle &sCCH) const override; - ticl::SimToRecoCollectionWithSimClusters associateSimToReco( - const edm::Handle &cCH, - const edm::Handle &sCCH) const override; + ticl::SimToRecoCollectionWithSimClustersT associateSimToReco( + const edm::Handle &cCH, const edm::Handle &sCCH) const override; private: const bool hardScatterOnly_; @@ -84,13 +83,20 @@ class LCToSCAssociatorByEnergyScoreImpl : public ticl::LayerClusterToSimClusterA const std::unordered_map *hitMap_; unsigned layers_; edm::EDProductGetter const *productGetter_; - ticl::association makeConnections(const edm::Handle &cCH, + ticl::association makeConnections(const edm::Handle &cCH, const edm::Handle &sCCH) const; std::vector hits_; }; -extern template class LCToSCAssociatorByEnergyScoreImpl; -extern template class LCToSCAssociatorByEnergyScoreImpl; +extern template class LCToSCAssociatorByEnergyScoreImplT; +extern template class LCToSCAssociatorByEnergyScoreImplT; +extern template class LCToSCAssociatorByEnergyScoreImplT; +extern template class LCToSCAssociatorByEnergyScoreImplT; -using HGCalLCToSCAssociatorByEnergyScoreImpl = LCToSCAssociatorByEnergyScoreImpl; -using BarrelLCToSCAssociatorByEnergyScoreImpl = LCToSCAssociatorByEnergyScoreImpl; +using HGCalLCToSCAssociatorByEnergyScoreImpl = + LCToSCAssociatorByEnergyScoreImplT; +using BarrelLCToSCAssociatorByEnergyScoreImpl = + LCToSCAssociatorByEnergyScoreImplT; +using HGCalPCToSCAssociatorByEnergyScoreImpl = LCToSCAssociatorByEnergyScoreImplT; +using BarrelPCToSCAssociatorByEnergyScoreImpl = + LCToSCAssociatorByEnergyScoreImplT; diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorByEnergyScoreProducer.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorByEnergyScoreProducer.cc index dc26b9f0cdf9b..932438079096d 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorByEnergyScoreProducer.cc +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorByEnergyScoreProducer.cc @@ -2,8 +2,8 @@ #include -template -LCToSCAssociatorByEnergyScoreProducer::LCToSCAssociatorByEnergyScoreProducer(const edm::ParameterSet &ps) +template +LCToSCAssociatorByEnergyScoreProducerT::LCToSCAssociatorByEnergyScoreProducerT(const edm::ParameterSet &ps) : hitMap_(consumes>(ps.getParameter("hitMapTag"))), caloGeometry_(esConsumes()), hardScatterOnly_(ps.getParameter("hardScatterOnly")), @@ -18,16 +18,16 @@ LCToSCAssociatorByEnergyScoreProducer::LCToSCAssociatorByEnergyScoreProduce rhtools_ = std::make_shared(); // Register the product - produces(); + produces>(); } -template -LCToSCAssociatorByEnergyScoreProducer::~LCToSCAssociatorByEnergyScoreProducer() {} +template +LCToSCAssociatorByEnergyScoreProducerT::~LCToSCAssociatorByEnergyScoreProducerT() {} -template -void LCToSCAssociatorByEnergyScoreProducer::produce(edm::StreamID, - edm::Event &iEvent, - const edm::EventSetup &es) const { +template +void LCToSCAssociatorByEnergyScoreProducerT::produce(edm::StreamID, + edm::Event &iEvent, + const edm::EventSetup &es) const { edm::ESHandle geom = es.getHandle(caloGeometry_); rhtools_->setGeometry(*geom); @@ -39,8 +39,8 @@ void LCToSCAssociatorByEnergyScoreProducer::produce(edm::StreamID, // Check handle validity if (!hits_handle.isValid()) { - edm::LogWarning("LCToSCAssociatorByEnergyScoreProducer") - << "Hit collection not available for token. Skipping this collection."; + edm::LogWarning("LCToSCAssociatorByEnergyScoreProducerT") + << "HGCAL Hit collection not available for token. Skipping this collection."; continue; // Skip invalid handle } @@ -55,8 +55,8 @@ void LCToSCAssociatorByEnergyScoreProducer::produce(edm::StreamID, // Check handle validity if (!hits_handle.isValid()) { - edm::LogWarning("LCToSCAssociatorByEnergyScoreProducer") - << "Hit collection not available for token. Skipping this collection."; + edm::LogWarning("LCToSCAssociatorByEnergyScoreProducerT") + << "Barrel Hit collection not available for token. Skipping this collection."; continue; // Skip invalid handle } @@ -65,16 +65,31 @@ void LCToSCAssociatorByEnergyScoreProducer::produce(edm::StreamID, } } } - const auto hitMap = &iEvent.get(hitMap_); - auto impl = std::make_unique>( + if (hits.empty()) { + edm::LogWarning("LCToSCAssociatorByEnergyScoreProducerT") << "No hits collected. Producing empty associator."; + } + + if (!iEvent.getHandle(hitMap_)) { + edm::LogWarning("LCToSCAssociatorByEnergyScoreProducerT") << "Hit map not valid. Producing empty associator."; + + const std::unordered_map hitMap; // empty map + auto impl = std::make_unique>( + iEvent.productGetter(), hardScatterOnly_, rhtools_, &hitMap, hits); + auto emptyAssociator = std::make_unique>(std::move(impl)); + iEvent.put(std::move(emptyAssociator)); + return; + } + + const auto hitMap = &iEvent.get(hitMap_); + auto impl = std::make_unique>( iEvent.productGetter(), hardScatterOnly_, rhtools_, hitMap, hits); - auto toPut = std::make_unique(std::move(impl)); + auto toPut = std::make_unique>(std::move(impl)); iEvent.put(std::move(toPut)); } -template -void LCToSCAssociatorByEnergyScoreProducer::fillDescriptions(edm::ConfigurationDescriptions &cfg) { +template +void LCToSCAssociatorByEnergyScoreProducerT::fillDescriptions(edm::ConfigurationDescriptions &cfg) { edm::ParameterSetDescription desc; desc.add("hardScatterOnly", true); if constexpr (std::is_same_v) { diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorByEnergyScoreProducer.h b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorByEnergyScoreProducer.h index 1bf22895c439e..229c0107b83a8 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorByEnergyScoreProducer.h +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorByEnergyScoreProducer.h @@ -1,5 +1,5 @@ -#ifndef SimCalorimetry_HGCalAssociatorProducers_LCToSCAssociatorByEnergyScoreProducer_H -#define SimCalorimetry_HGCalAssociatorProducers_LCToSCAssociatorByEnergyScoreProducer_H +#ifndef SimCalorimetry_HGCalAssociatorProducers_LCToSCAssociatorByEnergyScoreProducerT_H +#define SimCalorimetry_HGCalAssociatorProducers_LCToSCAssociatorByEnergyScoreProducerT_H // Original author: Leonardo Cristella @@ -20,11 +20,11 @@ #include "DataFormats/HGCRecHit/interface/HGCRecHitCollections.h" -template -class LCToSCAssociatorByEnergyScoreProducer : public edm::global::EDProducer<> { +template +class LCToSCAssociatorByEnergyScoreProducerT : public edm::global::EDProducer<> { public: - explicit LCToSCAssociatorByEnergyScoreProducer(const edm::ParameterSet &); - ~LCToSCAssociatorByEnergyScoreProducer() override; + explicit LCToSCAssociatorByEnergyScoreProducerT(const edm::ParameterSet &); + ~LCToSCAssociatorByEnergyScoreProducerT() override; static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); @@ -39,12 +39,22 @@ class LCToSCAssociatorByEnergyScoreProducer : public edm::global::EDProducer<> { std::vector>> hits_token_; }; -template class LCToSCAssociatorByEnergyScoreProducer; -template class LCToSCAssociatorByEnergyScoreProducer; +template class LCToSCAssociatorByEnergyScoreProducerT; +template class LCToSCAssociatorByEnergyScoreProducerT; +template class LCToSCAssociatorByEnergyScoreProducerT; +template class LCToSCAssociatorByEnergyScoreProducerT; -using HGCalLCToSCAssociatorByEnergyScoreProducer = LCToSCAssociatorByEnergyScoreProducer; +using HGCalLCToSCAssociatorByEnergyScoreProducer = + LCToSCAssociatorByEnergyScoreProducerT; DEFINE_FWK_MODULE(HGCalLCToSCAssociatorByEnergyScoreProducer); -using BarrelLCToSCAssociatorByEnergyScoreProducer = LCToSCAssociatorByEnergyScoreProducer; +using BarrelLCToSCAssociatorByEnergyScoreProducer = + LCToSCAssociatorByEnergyScoreProducerT; DEFINE_FWK_MODULE(BarrelLCToSCAssociatorByEnergyScoreProducer); +using HGCalPCToSCAssociatorByEnergyScoreProducer = + LCToSCAssociatorByEnergyScoreProducerT; +DEFINE_FWK_MODULE(HGCalPCToSCAssociatorByEnergyScoreProducer); +using BarrelPCToSCAssociatorByEnergyScoreProducer = + LCToSCAssociatorByEnergyScoreProducerT; +DEFINE_FWK_MODULE(BarrelPCToSCAssociatorByEnergyScoreProducer); #endif diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorEDProducer.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorEDProducer.cc index 1a88591b16e3c..201bfafc5e91d 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorEDProducer.cc +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSCAssociatorEDProducer.cc @@ -10,6 +10,7 @@ // user include files #include "DataFormats/CaloRecHit/interface/CaloClusterFwd.h" +#include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h" #include "FWCore/Framework/interface/ESHandle.h" #include "FWCore/Framework/interface/Event.h" #include "FWCore/Framework/interface/MakerMacros.h" @@ -21,13 +22,14 @@ #include "SimDataFormats/Associations/interface/LayerClusterToSimClusterAssociator.h" // -// class decleration +// class declaration // -class LCToSCAssociatorEDProducer : public edm::global::EDProducer<> { +template +class LCToSCAssociatorEDProducerT : public edm::global::EDProducer<> { public: - explicit LCToSCAssociatorEDProducer(const edm::ParameterSet &); - ~LCToSCAssociatorEDProducer() override = default; + explicit LCToSCAssociatorEDProducerT(const edm::ParameterSet &); + ~LCToSCAssociatorEDProducerT() override = default; static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); @@ -35,17 +37,19 @@ class LCToSCAssociatorEDProducer : public edm::global::EDProducer<> { void produce(edm::StreamID, edm::Event &, const edm::EventSetup &) const override; edm::EDGetTokenT SCCollectionToken_; - edm::EDGetTokenT LCCollectionToken_; - edm::EDGetTokenT associatorToken_; + edm::EDGetTokenT LCCollectionToken_; + edm::EDGetTokenT> associatorToken_; }; -LCToSCAssociatorEDProducer::LCToSCAssociatorEDProducer(const edm::ParameterSet &pset) { - produces(); - produces(); +template +LCToSCAssociatorEDProducerT::LCToSCAssociatorEDProducerT(const edm::ParameterSet &pset) { + produces>(); + produces>(); SCCollectionToken_ = consumes(pset.getParameter("label_scl")); - LCCollectionToken_ = consumes(pset.getParameter("label_lcl")); - associatorToken_ = consumes(pset.getParameter("associator")); + LCCollectionToken_ = consumes(pset.getParameter("label_lcl")); + associatorToken_ = + consumes>(pset.getParameter("associator")); } // @@ -53,26 +57,41 @@ LCToSCAssociatorEDProducer::LCToSCAssociatorEDProducer(const edm::ParameterSet & // // ------------ method called to produce the data ------------ -void LCToSCAssociatorEDProducer::produce(edm::StreamID, edm::Event &iEvent, const edm::EventSetup &iSetup) const { +template +void LCToSCAssociatorEDProducerT::produce(edm::StreamID, + edm::Event &iEvent, + const edm::EventSetup &iSetup) const { using namespace edm; - edm::Handle theAssociator; + edm::Handle> theAssociator; iEvent.getByToken(associatorToken_, theAssociator); + if (!theAssociator.isValid()) { + edm::LogWarning("LCToSCAssociatorEDProducerT") << "Associator is unavailable."; + return; + } + Handle SCCollection; iEvent.getByToken(SCCollectionToken_, SCCollection); - Handle LCCollection; + if (!SCCollection.isValid()) { + edm::LogWarning("LCToSCAssociatorEDProducerT") + << "SimCluster collection is unavailable. Producing empty associations."; + + return; + } + + Handle LCCollection; iEvent.getByToken(LCCollectionToken_, LCCollection); - // Protection against missing CaloCluster collection + // Protection against missing cluster collection if (!LCCollection.isValid()) { - edm::LogWarning("LCToSCAssociatorEDProducer") - << "CaloCluster collection is unavailable. Producing empty associations."; + edm::LogWarning("LCToSCAssociatorEDProducerT") + << "Cluster collection is unavailable. Producing empty associations."; // Return empty collections - auto emptyRecSimColl = std::make_unique(); - auto emptySimRecColl = std::make_unique(); + auto emptyRecSimColl = std::make_unique>(); + auto emptySimRecColl = std::make_unique>(); iEvent.put(std::move(emptyRecSimColl)); iEvent.put(std::move(emptySimRecColl)); @@ -81,19 +100,22 @@ void LCToSCAssociatorEDProducer::produce(edm::StreamID, edm::Event &iEvent, cons // associate LC and SC LogTrace("AssociatorValidator") << "Calling associateRecoToSim method\n"; - ticl::RecoToSimCollectionWithSimClusters recSimColl = theAssociator->associateRecoToSim(LCCollection, SCCollection); + ticl::RecoToSimCollectionWithSimClustersT recSimColl = + theAssociator->associateRecoToSim(LCCollection, SCCollection); LogTrace("AssociatorValidator") << "Calling associateSimToReco method\n"; - ticl::SimToRecoCollectionWithSimClusters simRecColl = theAssociator->associateSimToReco(LCCollection, SCCollection); + ticl::SimToRecoCollectionWithSimClustersT simRecColl = + theAssociator->associateSimToReco(LCCollection, SCCollection); - auto rts = std::make_unique(recSimColl); - auto str = std::make_unique(simRecColl); + auto rts = std::make_unique>(recSimColl); + auto str = std::make_unique>(simRecColl); iEvent.put(std::move(rts)); iEvent.put(std::move(str)); } -void LCToSCAssociatorEDProducer::fillDescriptions(edm::ConfigurationDescriptions &descriptions) { +template +void LCToSCAssociatorEDProducerT::fillDescriptions(edm::ConfigurationDescriptions &descriptions) { edm::ParameterSetDescription desc; desc.add("label_scl", edm::InputTag("scAssocByEnergyScoreProducer")); desc.add("label_lcl", edm::InputTag("mix", "MergedCaloTruth")); @@ -102,4 +124,7 @@ void LCToSCAssociatorEDProducer::fillDescriptions(edm::ConfigurationDescriptions } // define this as a plug-in +using LCToSCAssociatorEDProducer = LCToSCAssociatorEDProducerT; DEFINE_FWK_MODULE(LCToSCAssociatorEDProducer); +using PCToSCAssociatorEDProducer = LCToSCAssociatorEDProducerT; +DEFINE_FWK_MODULE(PCToSCAssociatorEDProducer); diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorByEnergyScoreImpl.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorByEnergyScoreImpl.cc index fbe6bcdc045ad..9dab14cb5e254 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorByEnergyScoreImpl.cc +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorByEnergyScoreImpl.cc @@ -14,9 +14,9 @@ ticl::RecoToSimTracksterCollection LCToSimTSAssociatorByEnergyScoreImpl::associa const edm::Handle& cCCH, const edm::Handle& sTCH, const edm::Handle& cPCH, - const ticl::RecoToSimCollection& lCToCPs, + const ticl::RecoToSimCollectionT& lCToCPs, const edm::Handle& sCCH, - const ticl::RecoToSimCollectionWithSimClusters& lCToSCs) const { + const ticl::RecoToSimCollectionWithSimClustersT& lCToSCs) const { ticl::RecoToSimTracksterCollection returnValue(productGetter_); const auto simTracksters = *sTCH.product(); @@ -93,9 +93,9 @@ ticl::SimTracksterToRecoCollection LCToSimTSAssociatorByEnergyScoreImpl::associa const edm::Handle& cCCH, const edm::Handle& sTCH, const edm::Handle& cPCH, - const ticl::SimToRecoCollection& cPToLCs, + const ticl::SimToRecoCollectionT& cPToLCs, const edm::Handle& sCCH, - const ticl::SimToRecoCollectionWithSimClusters& sCToLCs) const { + const ticl::SimToRecoCollectionWithSimClustersT& sCToLCs) const { ticl::SimTracksterToRecoCollection returnValue(productGetter_); const auto simTracksters = *sTCH.product(); diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorByEnergyScoreImpl.h b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorByEnergyScoreImpl.h index dee5669b1038c..042ed12280fe3 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorByEnergyScoreImpl.h +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorByEnergyScoreImpl.h @@ -28,17 +28,17 @@ class LCToSimTSAssociatorByEnergyScoreImpl : public ticl::LayerClusterToSimTrack const edm::Handle &cCH, const edm::Handle &sTCH, const edm::Handle &cPCH, - const ticl::RecoToSimCollection &lCToCPs, + const ticl::RecoToSimCollectionT &lCToCPs, const edm::Handle &sCCH, - const ticl::RecoToSimCollectionWithSimClusters &lCToSCs) const override; + const ticl::RecoToSimCollectionWithSimClustersT &lCToSCs) const override; ticl::SimTracksterToRecoCollection associateSimToReco( const edm::Handle &cCH, const edm::Handle &sTCH, const edm::Handle &cPCH, - const ticl::SimToRecoCollection &cPToLCs, + const ticl::SimToRecoCollectionT &cPToLCs, const edm::Handle &sCCH, - const ticl::SimToRecoCollectionWithSimClusters &sCToLCs) const override; + const ticl::SimToRecoCollectionWithSimClustersT &sCToLCs) const override; private: edm::EDProductGetter const *productGetter_; diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorEDProducer.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorEDProducer.cc index 456e3c5892ac2..6034920ce2101 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorEDProducer.cc +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorEDProducer.cc @@ -44,13 +44,13 @@ class LCToSimTSAssociatorEDProducer : public edm::global::EDProducer<> { edm::EDGetTokenT CPCollectionToken_; edm::InputTag associatorCP_; - edm::EDGetTokenT associationMapLCToCPToken_; - edm::EDGetTokenT associationMapCPToLCToken_; + edm::EDGetTokenT> associationMapLCToCPToken_; + edm::EDGetTokenT> associationMapCPToLCToken_; edm::EDGetTokenT SCCollectionToken_; edm::InputTag associatorSC_; - edm::EDGetTokenT associationMapLCToSCToken_; - edm::EDGetTokenT associationMapSCToLCToken_; + edm::EDGetTokenT> associationMapLCToSCToken_; + edm::EDGetTokenT> associationMapSCToLCToken_; }; LCToSimTSAssociatorEDProducer::LCToSimTSAssociatorEDProducer(const edm::ParameterSet &pset) @@ -60,12 +60,14 @@ LCToSimTSAssociatorEDProducer::LCToSimTSAssociatorEDProducer(const edm::Paramete consumes(pset.getParameter("associator"))), CPCollectionToken_(consumes(pset.getParameter("label_cp"))), associatorCP_(pset.getParameter("associator_cp")), - associationMapLCToCPToken_(consumes(associatorCP_)), - associationMapCPToLCToken_(consumes(associatorCP_)), + associationMapLCToCPToken_(consumes>(associatorCP_)), + associationMapCPToLCToken_(consumes>(associatorCP_)), SCCollectionToken_(consumes(pset.getParameter("label_scl"))), associatorSC_(pset.getParameter("associator_sc")), - associationMapLCToSCToken_(consumes(associatorSC_)), - associationMapSCToLCToken_(consumes(associatorSC_)) { + associationMapLCToSCToken_( + consumes>(associatorSC_)), + associationMapSCToLCToken_( + consumes>(associatorSC_)) { produces(); produces(); } diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/MultiClusterAssociatorByEnergyScoreImpl.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/MultiClusterAssociatorByEnergyScoreImpl.cc deleted file mode 100644 index 8d3f836f585b5..0000000000000 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/MultiClusterAssociatorByEnergyScoreImpl.cc +++ /dev/null @@ -1,536 +0,0 @@ -// Original Author: Leonardo Cristella -// - -#include "MultiClusterAssociatorByEnergyScoreImpl.h" - -#include "FWCore/MessageLogger/interface/MessageLogger.h" -#include "SimDataFormats/CaloAnalysis/interface/CaloParticle.h" -#include "SimDataFormats/CaloAnalysis/interface/SimCluster.h" -#include "SimCalorimetry/HGCalAssociatorProducers/interface/AssociatorTools.h" - -#include - -MultiClusterAssociatorByEnergyScoreImpl::MultiClusterAssociatorByEnergyScoreImpl( - edm::EDProductGetter const& productGetter, - bool hardScatterOnly, - std::shared_ptr recHitTools, - const std::unordered_map*& hitMap, - std::vector& hits) - : hardScatterOnly_(hardScatterOnly), - recHitTools_(recHitTools), - hitMap_(hitMap), - hits_(hits), - productGetter_(&productGetter) { - layers_ = recHitTools_->lastLayerBH(); -} - -hgcal::association MultiClusterAssociatorByEnergyScoreImpl::makeConnections( - const edm::Handle& mCCH, const edm::Handle& cPCH) const { - // 1. Extract collections and filter CaloParticles, if required - const auto& mClusters = *mCCH.product(); - const auto& caloParticles = *cPCH.product(); - auto nMultiClusters = mClusters.size(); - //Consider CaloParticles coming from the hard scatterer, excluding the PU contribution. - std::vector cPIndices; - //Consider CaloParticles coming from the hard scatterer - //excluding the PU contribution and save the indices. - removeCPFromPU(caloParticles, cPIndices, false); - auto nCaloParticles = cPIndices.size(); - - std::vector cPSelectedIndices; - removeCPFromPU(caloParticles, cPSelectedIndices, true); - - //cPOnLayer[caloparticle][layer] - //This defines a "caloParticle on layer" concept. It is only filled in case - //that caloParticle has a reconstructed hit related via detid. So, a cPOnLayer[i][j] connects a - //specific caloParticle i in layer j with: - //1. the sum of all recHits energy times fraction of the relevant simHit in layer j related to that caloParticle i. - //2. the hits and fractions of that caloParticle i in layer j. - //3. the layer clusters with matched recHit id. - hgcal::caloParticleToMultiCluster cPOnLayer; - cPOnLayer.resize(nCaloParticles); - for (unsigned int i = 0; i < nCaloParticles; ++i) { - auto cpIndex = cPIndices[i]; - cPOnLayer[cpIndex].resize(layers_ * 2); - for (unsigned int j = 0; j < layers_ * 2; ++j) { - cPOnLayer[cpIndex][j].caloParticleId = cpIndex; - cPOnLayer[cpIndex][j].energy = 0.f; - cPOnLayer[cpIndex][j].hits_and_fractions.clear(); - } - } - - std::unordered_map> detIdToCaloParticleId_Map; - // Fill detIdToCaloParticleId_Map and update cPOnLayer - for (const auto& cpId : cPIndices) { - //take sim clusters - const SimClusterRefVector& simClusterRefVector = caloParticles[cpId].simClusters(); - //loop through sim clusters - for (const auto& it_sc : simClusterRefVector) { - const SimCluster& simCluster = (*(it_sc)); - const auto& hits_and_fractions = simCluster.hits_and_fractions(); - for (const auto& it_haf : hits_and_fractions) { - const auto hitid = (it_haf.first); - const auto cpLayerId = - recHitTools_->getLayerWithOffset(hitid) + layers_ * ((recHitTools_->zside(hitid) + 1) >> 1) - 1; - const auto itcheck = hitMap_->find(hitid); - if (itcheck != hitMap_->end()) { - //Since the current hit from sim cluster has a reconstructed hit with the same detid, - //make a map that will connect a detid with: - //1. the caloParticles that have a simcluster with sim hits in that cell via caloParticle id. - //2. the sum of all simHits fractions that contributes to that detid. - //So, keep in mind that in case of multiple caloParticles contributing in the same cell - //the fraction is the sum over all caloParticles. So, something like: - //detid: (caloParticle 1, sum of hits fractions in that detid over all cp) , (caloParticle 2, sum of hits fractions in that detid over all cp), (caloParticle 3, sum of hits fractions in that detid over all cp) ... - auto hit_find_it = detIdToCaloParticleId_Map.find(hitid); - if (hit_find_it == detIdToCaloParticleId_Map.end()) { - detIdToCaloParticleId_Map[hitid] = std::vector(); - detIdToCaloParticleId_Map[hitid].emplace_back(cpId, it_haf.second); - } else { - auto findHitIt = std::find(detIdToCaloParticleId_Map[hitid].begin(), - detIdToCaloParticleId_Map[hitid].end(), - hgcal::detIdInfoInCluster{cpId, it_haf.second}); - if (findHitIt != detIdToCaloParticleId_Map[hitid].end()) { - findHitIt->fraction += it_haf.second; - } else { - detIdToCaloParticleId_Map[hitid].emplace_back(cpId, it_haf.second); - } - } - const HGCRecHit* hit = hits_[itcheck->second]; - //Since the current hit from sim cluster has a reconstructed hit with the same detid, - //fill the cPOnLayer[caloparticle][layer] object with energy (sum of all recHits energy times fraction - //of the relevant simHit) and keep the hit (detid and fraction) that contributed. - cPOnLayer[cpId][cpLayerId].energy += it_haf.second * hit->energy(); - // We need to compress the hits and fractions in order to have a - // reasonable score between CP and LC. Imagine, for example, that a - // CP has detID X used by 2 SimClusters with different fractions. If - // a single LC uses X with fraction 1 and is compared to the 2 - // contributions separately, it will be assigned a score != 0, which - // is wrong. - auto& haf = cPOnLayer[cpId][cpLayerId].hits_and_fractions; - auto found = std::find_if( - std::begin(haf), std::end(haf), [&hitid](const std::pair& v) { return v.first == hitid; }); - if (found != haf.end()) { - found->second += it_haf.second; - } else { - cPOnLayer[cpId][cpLayerId].hits_and_fractions.emplace_back(hitid, it_haf.second); - } - } - } // end of loop through simHits - } // end of loop through simclusters - } // end of loop through caloParticles - -#ifdef EDM_ML_DEBUG - LogDebug("MultiClusterAssociatorByEnergyScoreImpl") << "cPOnLayer INFO" << std::endl; - for (size_t cp = 0; cp < cPOnLayer.size(); ++cp) { - LogDebug("MultiClusterAssociatorByEnergyScoreImpl") << "For CaloParticle Idx: " << cp << " we have: " << std::endl; - for (size_t cpp = 0; cpp < cPOnLayer[cp].size(); ++cpp) { - LogDebug("MultiClusterAssociatorByEnergyScoreImpl") << " On Layer: " << cpp << " we have:" << std::endl; - LogDebug("MultiClusterAssociatorByEnergyScoreImpl") - << " CaloParticleIdx: " << cPOnLayer[cp][cpp].caloParticleId << std::endl; - LogDebug("MultiClusterAssociatorByEnergyScoreImpl") - << " Energy: " << cPOnLayer[cp][cpp].energy << std::endl; - double tot_energy = 0.; - for (auto const& haf : cPOnLayer[cp][cpp].hits_and_fractions) { - const HGCRecHit* hit = hits_[hitMap_->at(haf.first)]; - LogDebug("MultiClusterAssociatorByEnergyScoreImpl") - << " Hits/fraction/energy: " << (uint32_t)haf.first << "/" << haf.second << "/" - << haf.second * hit->energy() << std::endl; - tot_energy += haf.second * hit->energy(); - } - LogDebug("MultiClusterAssociatorByEnergyScoreImpl") << " Tot Sum haf: " << tot_energy << std::endl; - for (auto const& mc : cPOnLayer[cp][cpp].multiClusterIdToEnergyAndScore) { - LogDebug("MultiClusterAssociatorByEnergyScoreImpl") << " mcIdx/energy/score: " << mc.first << "/" - << mc.second.first << "/" << mc.second.second << std::endl; - } - } - } - - LogDebug("MultiClusterAssociatorByEnergyScoreImpl") << "detIdToCaloParticleId_Map INFO" << std::endl; - for (auto const& cp : detIdToCaloParticleId_Map) { - const HGCRecHit* hit = hits_[hitMap_->at(cp.first)]; - LogDebug("MultiClusterAssociatorByEnergyScoreImpl") - << "For detId: " << (uint32_t)cp.first - << " we have found the following connections with CaloParticles:" << std::endl; - for (auto const& cpp : cp.second) { - LogDebug("MultiClusterAssociatorByEnergyScoreImpl") - << " CaloParticle Id: " << cpp.clusterId << " with fraction: " << cpp.fraction - << " and energy: " << cpp.fraction * hit->energy() << std::endl; - } - } -#endif - - // Fill detIdToMultiClusterId_Map and cpsInMultiCluster; update cPOnLayer - std::unordered_map> detIdToMultiClusterId_Map; - - // this contains the ids of the caloParticles contributing with at least one hit to the multiCluster and the reconstruction error - //cpsInMultiCluster[multicluster][CPids] - //Connects a multiCluster with all related caloParticles. - hgcal::multiClusterToCaloParticle cpsInMultiCluster; - cpsInMultiCluster.resize(nMultiClusters); - - //Loop through multiClusters - for (unsigned int mcId = 0; mcId < nMultiClusters; ++mcId) { - const auto& hits_and_fractions = mClusters[mcId].hitsAndFractions(); - if (!hits_and_fractions.empty()) { - std::unordered_map CPEnergyInMCL; - int maxCPId_byNumberOfHits = -1; - unsigned int maxCPNumberOfHitsInMCL = 0; - int maxCPId_byEnergy = -1; - float maxEnergySharedMCLandCP = 0.f; - float energyFractionOfMCLinCP = 0.f; - float energyFractionOfCPinMCL = 0.f; - - //In case of matched rechit-simhit, so matched - //caloparticle-layercluster-multicluster, we count and save the number of - //recHits related to the maximum energy CaloParticle out of all - //CaloParticles related to that layer cluster and multiCluster. - - std::unordered_map occurrencesCPinMCL; - unsigned int numberOfNoiseHitsInMCL = 0; - unsigned int numberOfHitsInMCL = 0; - - //number of hits related to that cluster - unsigned int numberOfHitsInLC = hits_and_fractions.size(); - numberOfHitsInMCL += numberOfHitsInLC; - std::unordered_map CPEnergyInLC; - - //hitsToCaloParticleId is a vector of ints, one for each recHit of the - //layer cluster under study. If negative, there is no simHit from any CaloParticle related. - //If positive, at least one CaloParticle has been found with matched simHit. - //In more detail: - // 1. hitsToCaloParticleId[hitId] = -3 - // TN: These represent Halo Cells(N) that have not been - // assigned to any CaloParticle (hence the T). - // 2. hitsToCaloParticleId[hitId] = -2 - // FN: There represent Halo Cells(N) that have been assigned - // to a CaloParticle (hence the F, since those should have not been marked as halo) - // 3. hitsToCaloParticleId[hitId] = -1 - // FP: These represent Real Cells(P) that have not been - // assigned to any CaloParticle (hence the F, since these are fakes) - // 4. hitsToCaloParticleId[hitId] >= 0 - // TP There represent Real Cells(P) that have been assigned - // to a CaloParticle (hence the T) - - std::vector hitsToCaloParticleId(numberOfHitsInLC); - //det id of the first hit just to make the lcLayerId variable - //which maps the layers in -z: 0->51 and in +z: 52->103 - const auto firstHitDetId = hits_and_fractions[0].first; - int lcLayerId = recHitTools_->getLayerWithOffset(firstHitDetId) + - layers_ * ((recHitTools_->zside(firstHitDetId) + 1) >> 1) - 1; - - //Loop though the hits of the layer cluster under study - for (unsigned int hitId = 0; hitId < numberOfHitsInLC; hitId++) { - const auto rh_detid = hits_and_fractions[hitId].first; - const auto rhFraction = hits_and_fractions[hitId].second; - - //Since the hit is belonging to the layer cluster, it must also be in the recHits map. - const auto itcheck = hitMap_->find(rh_detid); - const HGCRecHit* hit = hits_[itcheck->second]; - - //Make a map that will connect a detid (that belongs to a recHit of the layer cluster under study, - //no need to save others) with: - //1. the layer clusters that have recHits in that detid - //2. the fraction of the recHit of each layer cluster that contributes to that detid. - //So, something like: - //detid: (layer cluster 1, hit fraction) , (layer cluster 2, hit fraction), (layer cluster 3, hit fraction) ... - //here comparing with the caloParticle map above - auto hit_find_in_LC = detIdToMultiClusterId_Map.find(rh_detid); - if (hit_find_in_LC == detIdToMultiClusterId_Map.end()) { - detIdToMultiClusterId_Map[rh_detid] = std::vector(); - } - detIdToMultiClusterId_Map[rh_detid].emplace_back(hgcal::detIdInfoInMultiCluster{mcId, mcId, rhFraction}); - - // Check whether the recHit of the layer cluster under study has a sim hit in the same cell - auto hit_find_in_CP = detIdToCaloParticleId_Map.find(rh_detid); - - // If the fraction is zero or the hit does not belong to any calo - // particle, set the caloParticleId for the hit to -1 and this will - // contribute to the number of noise hits - if (rhFraction == 0.) { // this could be a real hit that has been marked as halo - hitsToCaloParticleId[hitId] = -2; - } - if (hit_find_in_CP == detIdToCaloParticleId_Map.end()) { - hitsToCaloParticleId[hitId] -= 1; - } else { - auto maxCPEnergyInLC = 0.f; - auto maxCPId = -1; - for (auto& h : hit_find_in_CP->second) { - auto shared_fraction = std::min(rhFraction, h.fraction); - //We are in the case where there are caloParticles with simHits connected via detid with the recHit under study - //So, from all layers clusters, find the recHits that are connected with a caloParticle and save/calculate the - //energy of that caloParticle as the sum over all recHits of the recHits energy weighted - //by the caloParticle's fraction related to that recHit. - CPEnergyInMCL[h.clusterId] += shared_fraction * hit->energy(); - //Same but for layer clusters for the cell association per layer - CPEnergyInLC[h.clusterId] += shared_fraction * hit->energy(); - //Here cPOnLayer[caloparticle][layer] described above is set - //Here for multiClusters with matched recHit, the CP fraction times hit energy is added and saved - cPOnLayer[h.clusterId][lcLayerId].multiClusterIdToEnergyAndScore[mcId].first += - shared_fraction * hit->energy(); - cPOnLayer[h.clusterId][lcLayerId].multiClusterIdToEnergyAndScore[mcId].second = FLT_MAX; - //cpsInMultiCluster[multicluster][CPids] - //Connects a multiCluster with all related caloParticles - cpsInMultiCluster[mcId].emplace_back(h.clusterId, FLT_MAX); - //From all CaloParticles related to a layer cluster, we save id and energy of the caloParticle - //that after simhit-rechit matching in layer has the maximum energy. - if (shared_fraction > maxCPEnergyInLC) { - //energy is used only here. cpid is saved for multiClusters - maxCPEnergyInLC = CPEnergyInLC[h.clusterId]; - maxCPId = h.clusterId; - } - } - //Keep in mind here maxCPId could be zero. So, below ask for negative not including zero to count noise. - hitsToCaloParticleId[hitId] = maxCPId; - } - - } //end of loop through recHits of the layer cluster. - - //Loop through all recHits to count how many of them are noise and how many are matched. - //In case of matched rechit-simhit, we count and save the number of recHits related to the maximum energy CaloParticle. - for (auto c : hitsToCaloParticleId) { - if (c < 0) { - numberOfNoiseHitsInMCL++; - } else { - occurrencesCPinMCL[c]++; - } - } - - //Below from all maximum energy CaloParticles, we save the one with the largest amount - //of related recHits. - for (auto& c : occurrencesCPinMCL) { - if (c.second > maxCPNumberOfHitsInMCL) { - maxCPId_byNumberOfHits = c.first; - maxCPNumberOfHitsInMCL = c.second; - } - } - - //Find the CaloParticle that has the maximum energy shared with the multiCluster under study. - for (auto& c : CPEnergyInMCL) { - if (c.second > maxEnergySharedMCLandCP) { - maxCPId_byEnergy = c.first; - maxEnergySharedMCLandCP = c.second; - } - } - //The energy of the CaloParticle that found to have the maximum energy shared with the multiCluster under study. - float totalCPEnergyFromLayerCP = 0.f; - if (maxCPId_byEnergy >= 0) { - //Loop through all layers - for (unsigned int j = 0; j < layers_ * 2; ++j) { - totalCPEnergyFromLayerCP = totalCPEnergyFromLayerCP + cPOnLayer[maxCPId_byEnergy][j].energy; - } - energyFractionOfCPinMCL = maxEnergySharedMCLandCP / totalCPEnergyFromLayerCP; - if (mClusters[mcId].energy() > 0.f) { - energyFractionOfMCLinCP = maxEnergySharedMCLandCP / mClusters[mcId].energy(); - } - } - - LogDebug("MultiClusterAssociatorByEnergyScoreImpl") << std::setw(12) << "multiCluster" - << "\t" << std::setw(10) << "mulcl energy" - << "\t" << std::setw(5) << "nhits" - << "\t" << std::setw(12) << "noise hits" - << "\t" << std::setw(22) << "maxCPId_byNumberOfHits" - << "\t" << std::setw(8) << "nhitsCP" - << "\t" << std::setw(16) << "maxCPId_byEnergy" - << "\t" << std::setw(23) << "maxEnergySharedMCLandCP" - << "\t" << std::setw(22) << "totalCPEnergyFromAllLayerCP" - << "\t" << std::setw(22) << "energyFractionOfMCLinCP" - << "\t" << std::setw(25) << "energyFractionOfCPinMCL" - << "\t" << std::endl; - LogDebug("MultiClusterAssociatorByEnergyScoreImpl") - << std::setw(12) << mcId << "\t" << std::setw(10) << mClusters[mcId].energy() << "\t" << std::setw(5) - << numberOfHitsInMCL << "\t" << std::setw(12) << numberOfNoiseHitsInMCL << "\t" << std::setw(22) - << maxCPId_byNumberOfHits << "\t" << std::setw(8) << maxCPNumberOfHitsInMCL << "\t" << std::setw(16) - << maxCPId_byEnergy << "\t" << std::setw(23) << maxEnergySharedMCLandCP << "\t" << std::setw(22) - << totalCPEnergyFromLayerCP << "\t" << std::setw(22) << energyFractionOfMCLinCP << "\t" << std::setw(25) - << energyFractionOfCPinMCL << std::endl; - } - } // end of loop through multiClusters - - // Update cpsInMultiCluster; compute the score MultiCluster-to-CaloParticle, - // together with the returned AssociationMap - for (unsigned int mcId = 0; mcId < nMultiClusters; ++mcId) { - // find the unique caloParticles id contributing to the multilusters - std::sort(cpsInMultiCluster[mcId].begin(), cpsInMultiCluster[mcId].end()); - auto last = std::unique(cpsInMultiCluster[mcId].begin(), cpsInMultiCluster[mcId].end()); - cpsInMultiCluster[mcId].erase(last, cpsInMultiCluster[mcId].end()); - - const auto& hits_and_fractions = mClusters[mcId].hitsAndFractions(); - unsigned int numberOfHitsInLC = hits_and_fractions.size(); - if (numberOfHitsInLC > 0) { - if (mClusters[mcId].energy() == 0. && !cpsInMultiCluster[mcId].empty()) { - //Loop through all CaloParticles contributing to multiCluster mcId. - for (auto& cpPair : cpsInMultiCluster[mcId]) { - //In case of a multiCluster with zero energy but related CaloParticles the score is set to 1. - cpPair.second = 1.; - LogDebug("MultiClusterAssociatorByEnergyScoreImpl") - << "multiClusterId : \t " << mcId << "\t CP id : \t" << cpPair.first << "\t score \t " << cpPair.second - << "\n"; - } - continue; - } - - // Compute the correct normalization - float invMultiClusterEnergyWeight = 0.f; - for (auto const& haf : mClusters[mcId].hitsAndFractions()) { - const HGCRecHit* hit = hits_[hitMap_->at(haf.first)]; - invMultiClusterEnergyWeight += (haf.second * hit->energy()) * (haf.second * hit->energy()); - } - invMultiClusterEnergyWeight = 1.f / invMultiClusterEnergyWeight; - - for (unsigned int i = 0; i < numberOfHitsInLC; ++i) { - DetId rh_detid = hits_and_fractions[i].first; - float rhFraction = hits_and_fractions[i].second; - - bool hitWithNoCP = (detIdToCaloParticleId_Map.find(rh_detid) == detIdToCaloParticleId_Map.end()); - - auto itcheck = hitMap_->find(rh_detid); - const HGCRecHit* hit = hits_[itcheck->second]; - float hitEnergyWeight = hit->energy() * hit->energy(); - - for (auto& cpPair : cpsInMultiCluster[mcId]) { - unsigned int multiClusterId = cpPair.first; - float cpFraction = 0.f; - if (!hitWithNoCP) { - auto findHitIt = std::find(detIdToCaloParticleId_Map[rh_detid].begin(), - detIdToCaloParticleId_Map[rh_detid].end(), - hgcal::detIdInfoInCluster{multiClusterId, 0.f}); - if (findHitIt != detIdToCaloParticleId_Map[rh_detid].end()) - cpFraction = findHitIt->fraction; - } - if (cpPair.second == FLT_MAX) { - cpPair.second = 0.f; - } - cpPair.second += - (rhFraction - cpFraction) * (rhFraction - cpFraction) * hitEnergyWeight * invMultiClusterEnergyWeight; - } - } // End of loop over Hits within a MultiCluster -#ifdef EDM_ML_DEBUG - //In case of a multiCluster with some energy but none related CaloParticles print some info. - if (cpsInMultiCluster[mcId].empty()) - LogDebug("MultiClusterAssociatorByEnergyScoreImpl") << "multiCluster Id: \t" << mcId << "\tCP id:\t-1 " - << "\t score \t-1" - << "\n"; -#endif - } - } // End of loop over MultiClusters - - // Compute the CaloParticle-To-MultiCluster score - for (const auto& cpId : cPSelectedIndices) { - for (unsigned int layerId = 0; layerId < layers_ * 2; ++layerId) { - unsigned int CPNumberOfHits = cPOnLayer[cpId][layerId].hits_and_fractions.size(); - if (CPNumberOfHits == 0) - continue; -#ifdef EDM_ML_DEBUG - int mcWithMaxEnergyInCP = -1; - float maxEnergyMCLperlayerinCP = 0.f; - float CPenergy = cPOnLayer[cpId][layerId].energy; - float CPEnergyFractionInMCLperlayer = 0.f; - for (auto& mc : cPOnLayer[cpId][layerId].multiClusterIdToEnergyAndScore) { - if (mc.second.first > maxEnergyMCLperlayerinCP) { - maxEnergyMCLperlayerinCP = mc.second.first; - mcWithMaxEnergyInCP = mc.first; - } - } - if (CPenergy > 0.f) - CPEnergyFractionInMCLperlayer = maxEnergyMCLperlayerinCP / CPenergy; - - LogDebug("MultiClusterAssociatorByEnergyScoreImpl") - << std::setw(8) << "LayerId:\t" << std::setw(12) << "caloparticle\t" << std::setw(15) << "cp total energy\t" - << std::setw(15) << "cpEnergyOnLayer\t" << std::setw(14) << "CPNhitsOnLayer\t" << std::setw(18) - << "mcWithMaxEnergyInCP\t" << std::setw(15) << "maxEnergyMCLinCP\t" << std::setw(20) - << "CPEnergyFractionInMCL" - << "\n"; - LogDebug("MultiClusterAssociatorByEnergyScoreImpl") - << std::setw(8) << layerId << "\t" << std::setw(12) << cpId << "\t" << std::setw(15) - << caloParticles[cpId].energy() << "\t" << std::setw(15) << CPenergy << "\t" << std::setw(14) - << CPNumberOfHits << "\t" << std::setw(18) << mcWithMaxEnergyInCP << "\t" << std::setw(15) - << maxEnergyMCLperlayerinCP << "\t" << std::setw(20) << CPEnergyFractionInMCLperlayer << "\n"; -#endif - - for (unsigned int i = 0; i < CPNumberOfHits; ++i) { - auto& cp_hitDetId = cPOnLayer[cpId][layerId].hits_and_fractions[i].first; - auto& cpFraction = cPOnLayer[cpId][layerId].hits_and_fractions[i].second; - - bool hitWithNoMCL = false; - if (cpFraction == 0.f) - continue; //hopefully this should never happen - auto hit_find_in_MCL = detIdToMultiClusterId_Map.find(cp_hitDetId); - if (hit_find_in_MCL == detIdToMultiClusterId_Map.end()) - hitWithNoMCL = true; - auto itcheck = hitMap_->find(cp_hitDetId); - const HGCRecHit* hit = hits_[itcheck->second]; - float hitEnergyWeight = hit->energy() * hit->energy(); - for (auto& mcPair : cPOnLayer[cpId][layerId].multiClusterIdToEnergyAndScore) { - unsigned int multiClusterId = mcPair.first; - float mcFraction = 0.f; - - if (!hitWithNoMCL) { - auto findHitIt = std::find(detIdToMultiClusterId_Map[cp_hitDetId].begin(), - detIdToMultiClusterId_Map[cp_hitDetId].end(), - hgcal::detIdInfoInMultiCluster{multiClusterId, 0, 0.f}); - if (findHitIt != detIdToMultiClusterId_Map[cp_hitDetId].end()) - mcFraction = findHitIt->fraction; - } - //Observe here that we do not divide as before by the layer cluster energy weight. We should sum first - //over all layers and divide with the total CP energy over all layers. - if (mcPair.second.second == FLT_MAX) { - mcPair.second.second = 0.f; - } - mcPair.second.second += (mcFraction - cpFraction) * (mcFraction - cpFraction) * hitEnergyWeight; -#ifdef EDM_ML_DEBUG - LogDebug("HGCalValidator") << "multiClusterId:\t" << multiClusterId << "\tmcfraction,cpfraction:\t" - << mcFraction << ", " << cpFraction << "\thitEnergyWeight:\t" << hitEnergyWeight - << "\tcurrent score numerator:\t" << mcPair.second.second << "\n"; -#endif - } // End of loop over MultiClusters linked to hits of this CaloParticle - } // End of loop over hits of CaloParticle on a Layer -#ifdef EDM_ML_DEBUG - if (cPOnLayer[cpId][layerId].multiClusterIdToEnergyAndScore.empty()) - LogDebug("HGCalValidator") << "CP Id: \t" << cpId << "\t MCL id:\t-1 " - << "\t layer \t " << layerId << " Sub score in \t -1" - << "\n"; - -#endif - } - } - return {cpsInMultiCluster, cPOnLayer}; -} - -hgcal::RecoToSimCollectionWithMultiClusters MultiClusterAssociatorByEnergyScoreImpl::associateRecoToSim( - const edm::Handle& mCCH, const edm::Handle& cPCH) const { - hgcal::RecoToSimCollectionWithMultiClusters returnValue(productGetter_); - const auto& links = makeConnections(mCCH, cPCH); - - const auto& cpsInMultiCluster = std::get<0>(links); - for (size_t mcId = 0; mcId < cpsInMultiCluster.size(); ++mcId) { - for (auto& cpPair : cpsInMultiCluster[mcId]) { - LogDebug("MultiClusterAssociatorByEnergyScoreImpl") - << "multiCluster Id: \t" << mcId << "\t CP id: \t" << cpPair.first << "\t score \t" << cpPair.second << "\n"; - // Fill AssociationMap - returnValue.insert(edm::Ref(mCCH, mcId), // Ref to MC - std::make_pair(edm::Ref(cPCH, cpPair.first), - cpPair.second) // Pair - ); - } - } - return returnValue; -} - -hgcal::SimToRecoCollectionWithMultiClusters MultiClusterAssociatorByEnergyScoreImpl::associateSimToReco( - const edm::Handle& mCCH, const edm::Handle& cPCH) const { - hgcal::SimToRecoCollectionWithMultiClusters returnValue(productGetter_); - const auto& links = makeConnections(mCCH, cPCH); - const auto& cPOnLayer = std::get<1>(links); - for (size_t cpId = 0; cpId < cPOnLayer.size(); ++cpId) { - for (size_t layerId = 0; layerId < cPOnLayer[cpId].size(); ++layerId) { - for (auto& mcPair : cPOnLayer[cpId][layerId].multiClusterIdToEnergyAndScore) { - returnValue.insert( - edm::Ref(cPCH, cpId), // Ref to CP - std::make_pair(edm::Ref(mCCH, mcPair.first), // Pair > - ); - } - } - } - return returnValue; -} diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/MultiClusterAssociatorByEnergyScoreImpl.h b/SimCalorimetry/HGCalAssociatorProducers/plugins/MultiClusterAssociatorByEnergyScoreImpl.h deleted file mode 100644 index ecfa818775a14..0000000000000 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/MultiClusterAssociatorByEnergyScoreImpl.h +++ /dev/null @@ -1,72 +0,0 @@ -// Original Author: Leonardo Cristella - -#include -#include -#include -#include // shared_ptr - -#include "DataFormats/ForwardDetId/interface/HGCalDetId.h" -#include "DataFormats/HGCRecHit/interface/HGCRecHit.h" -#include "SimDataFormats/Associations/interface/MultiClusterToCaloParticleAssociator.h" -#include "RecoLocalCalo/HGCalRecAlgos/interface/RecHitTools.h" - -namespace edm { - class EDProductGetter; -} - -namespace hgcal { - struct detIdInfoInCluster { - bool operator==(const detIdInfoInCluster &o) const { return clusterId == o.clusterId; }; - long unsigned int clusterId; - float fraction; - detIdInfoInCluster(long unsigned int cId, float fr) { - clusterId = cId; - fraction = fr; - } - }; - - struct detIdInfoInMultiCluster { - bool operator==(const detIdInfoInMultiCluster &o) const { return multiclusterId == o.multiclusterId; }; - unsigned int multiclusterId; - long unsigned int clusterId; - float fraction; - }; - - struct caloParticleOnALayer { - unsigned int caloParticleId; - float energy = 0; - std::vector> hits_and_fractions; - std::unordered_map> multiClusterIdToEnergyAndScore; - }; - - typedef std::vector>> multiClusterToCaloParticle; - typedef std::vector> caloParticleToMultiCluster; - typedef std::tuple association; -} // namespace hgcal - -class MultiClusterAssociatorByEnergyScoreImpl : public hgcal::MultiClusterToCaloParticleAssociatorBaseImpl { -public: - explicit MultiClusterAssociatorByEnergyScoreImpl(edm::EDProductGetter const &, - bool, - std::shared_ptr, - const std::unordered_map *&, - std::vector &hits); - - hgcal::RecoToSimCollectionWithMultiClusters associateRecoToSim( - const edm::Handle &mCCH, - const edm::Handle &cPCH) const override; - - hgcal::SimToRecoCollectionWithMultiClusters associateSimToReco( - const edm::Handle &mCCH, - const edm::Handle &cPCH) const override; - -private: - const bool hardScatterOnly_; - std::shared_ptr recHitTools_; - const std::unordered_map *hitMap_; - std::vector hits_; - unsigned layers_; - edm::EDProductGetter const *productGetter_; - hgcal::association makeConnections(const edm::Handle &mCCH, - const edm::Handle &cPCH) const; -}; diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/MultiClusterAssociatorByEnergyScoreProducer.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/MultiClusterAssociatorByEnergyScoreProducer.cc deleted file mode 100644 index 99de9507e9ea5..0000000000000 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/MultiClusterAssociatorByEnergyScoreProducer.cc +++ /dev/null @@ -1,90 +0,0 @@ -// Original author: Leonardo Cristella - -// user include files -#include - -#include "FWCore/Framework/interface/Frameworkfwd.h" -#include "FWCore/Framework/interface/global/EDProducer.h" - -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/MakerMacros.h" - -#include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "FWCore/Utilities/interface/EDGetToken.h" -#include "FWCore/Utilities/interface/ESGetToken.h" - -#include "SimDataFormats/Associations/interface/MultiClusterToCaloParticleAssociator.h" -#include "MultiClusterAssociatorByEnergyScoreImpl.h" - -#include "DataFormats/HGCRecHit/interface/HGCRecHitCollections.h" - -class MultiClusterAssociatorByEnergyScoreProducer : public edm::global::EDProducer<> { -public: - explicit MultiClusterAssociatorByEnergyScoreProducer(const edm::ParameterSet &); - ~MultiClusterAssociatorByEnergyScoreProducer() override; - - static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); - -private: - void produce(edm::StreamID, edm::Event &, const edm::EventSetup &) const override; - edm::EDGetTokenT> hitMap_; - edm::ESGetToken caloGeometry_; - const bool hardScatterOnly_; - std::shared_ptr rhtools_; - std::vector hits_label_; - std::vector> hits_token_; -}; - -MultiClusterAssociatorByEnergyScoreProducer::MultiClusterAssociatorByEnergyScoreProducer(const edm::ParameterSet &ps) - : hitMap_(consumes>(ps.getParameter("hitMapTag"))), - caloGeometry_(esConsumes()), - hardScatterOnly_(ps.getParameter("hardScatterOnly")), - hits_label_(ps.getParameter>("hits")) { - for (auto &label : hits_label_) { - hits_token_.push_back(consumes(label)); - } - rhtools_ = std::make_shared(); - - // Register the product - produces(); -} - -MultiClusterAssociatorByEnergyScoreProducer::~MultiClusterAssociatorByEnergyScoreProducer() {} - -void MultiClusterAssociatorByEnergyScoreProducer::produce(edm::StreamID, - edm::Event &iEvent, - const edm::EventSetup &es) const { - edm::ESHandle geom = es.getHandle(caloGeometry_); - rhtools_->setGeometry(*geom); - - std::vector hits; - for (auto &token : hits_token_) { - edm::Handle hits_handle; - iEvent.getByToken(token, hits_handle); - for (const auto &hit : *hits_handle) { - hits.push_back(&hit); - } - } - - const std::unordered_map *hitMap = &iEvent.get(hitMap_); - - auto impl = std::make_unique( - iEvent.productGetter(), hardScatterOnly_, rhtools_, hitMap, hits); - auto toPut = std::make_unique(std::move(impl)); - iEvent.put(std::move(toPut)); -} - -void MultiClusterAssociatorByEnergyScoreProducer::fillDescriptions(edm::ConfigurationDescriptions &cfg) { - edm::ParameterSetDescription desc; - desc.add("hitMapTag", edm::InputTag("recHitMapProducer", "hgcalRecHitMap")); - desc.add>("hits", - {edm::InputTag("HGCalRecHit", "HGCEERecHits"), - edm::InputTag("HGCalRecHit", "HGCHEFRecHits"), - edm::InputTag("HGCalRecHit", "HGCHEBRecHits")}); - desc.add("hardScatterOnly", true); - - cfg.add("multiClusterAssociatorByEnergyScore", desc); -} - -//define this as a plug-in -DEFINE_FWK_MODULE(MultiClusterAssociatorByEnergyScoreProducer); diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/TSToSCAssociatorByEnergyScoreProducer.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/TSToSCAssociatorByEnergyScoreProducer.cc index b87af943f64fb..fc4bfe3dad2a1 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/TSToSCAssociatorByEnergyScoreProducer.cc +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/TSToSCAssociatorByEnergyScoreProducer.cc @@ -66,8 +66,22 @@ void TSToSCAssociatorByEnergyScoreProducer::produce(edm::StreamID, } } - const auto hitMap = &iEvent.get(hitMap_); + if (hits.empty()) { + edm::LogWarning("TSToSCAssociatorByEnergyScoreProducer") << "No hits collected. Producing empty associator."; + } + + if (!iEvent.getHandle(hitMap_)) { + edm::LogWarning("TSToSCAssociatorByEnergyScoreProducer") << "Hit map not valid. Producing empty associator."; + const std::unordered_map hitMap; // empty map + auto impl = std::make_unique( + iEvent.productGetter(), hardScatterOnly_, rhtools_, &hitMap, hits); + auto emptyAssociator = std::make_unique(std::move(impl)); + iEvent.put(std::move(emptyAssociator)); + return; + } + + const auto hitMap = &iEvent.get(hitMap_); auto impl = std::make_unique( iEvent.productGetter(), hardScatterOnly_, rhtools_, hitMap, hits); auto toPut = std::make_unique(std::move(impl)); diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/TSToSimTSAssociatorByEnergyScoreProducer.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/TSToSimTSAssociatorByEnergyScoreProducer.cc index 3ffdb25b12612..7c351d651a14b 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/TSToSimTSAssociatorByEnergyScoreProducer.cc +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/TSToSimTSAssociatorByEnergyScoreProducer.cc @@ -67,8 +67,22 @@ void TSToSimTSAssociatorByEnergyScoreProducer::produce(edm::StreamID, } } - const auto hitMap = &iEvent.get(hitMap_); + if (hits.empty()) { + edm::LogWarning("TSToSimTSAssociatorByEnergyScoreProducer") << "No hits collected. Producing empty associator."; + } + + if (!iEvent.getHandle(hitMap_)) { + edm::LogWarning("TSToSimTSAssociatorByEnergyScoreProducer") << "Hit map not valid. Producing empty associator."; + const std::unordered_map hitMap; // empty map + auto impl = std::make_unique( + iEvent.productGetter(), hardScatterOnly_, rhtools_, &hitMap, hits); + auto emptyAssociator = std::make_unique(std::move(impl)); + iEvent.put(std::move(emptyAssociator)); + return; + } + + const auto hitMap = &iEvent.get(hitMap_); auto impl = std::make_unique( iEvent.productGetter(), hardScatterOnly_, rhtools_, hitMap, hits); auto toPut = std::make_unique(std::move(impl)); diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/TSToSimTSHitLCAssociatorByEnergyScoreProducer.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/TSToSimTSHitLCAssociatorByEnergyScoreProducer.cc index becc775dc5603..e6d560abf91ae 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/TSToSimTSHitLCAssociatorByEnergyScoreProducer.cc +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/TSToSimTSHitLCAssociatorByEnergyScoreProducer.cc @@ -67,8 +67,24 @@ void TSToSimTSHitLCAssociatorByEnergyScoreProducer::produce(edm::StreamID, } } - const auto hitMap = &iEvent.get(hitMap_); + if (hits.empty()) { + edm::LogWarning("TSToSimTSHitLCAssociatorByEnergyScoreProducer") + << "No hits collected. Producing empty associator."; + } + + if (!iEvent.getHandle(hitMap_)) { + edm::LogWarning("TSToSimTSHitLCAssociatorByEnergyScoreProducer") + << "Hit map not valid. Producing empty associator."; + const std::unordered_map hitMap; // empty map + auto impl = std::make_unique( + iEvent.productGetter(), hardScatterOnly_, rhtools_, &hitMap, hits); + auto emptyAssociator = std::make_unique(std::move(impl)); + iEvent.put(std::move(emptyAssociator)); + return; + } + + const auto hitMap = &iEvent.get(hitMap_); auto impl = std::make_unique( iEvent.productGetter(), hardScatterOnly_, rhtools_, hitMap, hits); auto toPut = std::make_unique(std::move(impl)); diff --git a/SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociator.h b/SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociator.h index d5c079a298fd8..0e1432c26e40a 100644 --- a/SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociator.h +++ b/SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociator.h @@ -6,42 +6,50 @@ #include // user include files - #include "SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociatorBaseImpl.h" +#include "DataFormats/Common/interface/Uninitialized.h" // forward declarations namespace ticl { - class LayerClusterToCaloParticleAssociator { + template + class LayerClusterToCaloParticleAssociatorT { public: - LayerClusterToCaloParticleAssociator(std::unique_ptr); - LayerClusterToCaloParticleAssociator() = default; - LayerClusterToCaloParticleAssociator(LayerClusterToCaloParticleAssociator &&) = default; - LayerClusterToCaloParticleAssociator &operator=(LayerClusterToCaloParticleAssociator &&) = default; - LayerClusterToCaloParticleAssociator(const LayerClusterToCaloParticleAssociator &) = delete; // stop default - const LayerClusterToCaloParticleAssociator &operator=(const LayerClusterToCaloParticleAssociator &) = + explicit LayerClusterToCaloParticleAssociatorT( + std::unique_ptr> impl) + : m_impl(std::move(impl)) {} + LayerClusterToCaloParticleAssociatorT() = delete; + explicit LayerClusterToCaloParticleAssociatorT(edm::Uninitialized) noexcept {}; + LayerClusterToCaloParticleAssociatorT(LayerClusterToCaloParticleAssociatorT &&) = default; + LayerClusterToCaloParticleAssociatorT &operator=(LayerClusterToCaloParticleAssociatorT &&) = default; + LayerClusterToCaloParticleAssociatorT(const LayerClusterToCaloParticleAssociatorT &) = + delete; // stop default + const LayerClusterToCaloParticleAssociatorT &operator=(const LayerClusterToCaloParticleAssociatorT &) = delete; // stop default - ~LayerClusterToCaloParticleAssociator() = default; + ~LayerClusterToCaloParticleAssociatorT() = default; // ---------- const member functions --------------------- /// Associate a LayerCluster to CaloParticles - ticl::RecoToSimCollection associateRecoToSim(const edm::Handle &cCCH, - const edm::Handle &cPCH) const { + ticl::RecoToSimCollectionT associateRecoToSim(const edm::Handle &cCCH, + const edm::Handle &cPCH) const { return m_impl->associateRecoToSim(cCCH, cPCH); }; /// Associate a CaloParticle to LayerClusters - ticl::SimToRecoCollection associateSimToReco(const edm::Handle &cCCH, - const edm::Handle &cPCH) const { + ticl::SimToRecoCollectionT associateSimToReco(const edm::Handle &cCCH, + const edm::Handle &cPCH) const { return m_impl->associateSimToReco(cCCH, cPCH); } private: // ---------- member data -------------------------------- - std::unique_ptr m_impl; + std::unique_ptr> m_impl; }; } // namespace ticl +extern template class ticl::LayerClusterToCaloParticleAssociatorT; +extern template class ticl::LayerClusterToCaloParticleAssociatorT; + #endif diff --git a/SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociatorBaseImpl.h b/SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociatorBaseImpl.h index 9eb79d516d3bb..e7c2f975e2788 100644 --- a/SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociatorBaseImpl.h +++ b/SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociatorBaseImpl.h @@ -14,31 +14,36 @@ #include "DataFormats/Common/interface/AssociationMap.h" #include "DataFormats/CaloRecHit/interface/CaloClusterCollection.h" #include "SimDataFormats/CaloAnalysis/interface/CaloParticleFwd.h" +#include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h" namespace ticl { - typedef edm::AssociationMap< - edm::OneToManyWithQualityGeneric>> - SimToRecoCollection; - typedef edm::AssociationMap< - edm::OneToManyWithQualityGeneric> - RecoToSimCollection; + template + using SimToRecoCollectionT = + edm::AssociationMap>>; + template + using RecoToSimCollectionT = + edm::AssociationMap>; - class LayerClusterToCaloParticleAssociatorBaseImpl { + template + class LayerClusterToCaloParticleAssociatorBaseImplT { public: /// Constructor - LayerClusterToCaloParticleAssociatorBaseImpl(); + LayerClusterToCaloParticleAssociatorBaseImplT(); /// Destructor - virtual ~LayerClusterToCaloParticleAssociatorBaseImpl(); + virtual ~LayerClusterToCaloParticleAssociatorBaseImplT(); /// Associate a LayerCluster to CaloParticles - virtual ticl::RecoToSimCollection associateRecoToSim(const edm::Handle &cCH, - const edm::Handle &cPCH) const; + virtual ticl::RecoToSimCollectionT associateRecoToSim( + const edm::Handle &cCH, const edm::Handle &cPCH) const; /// Associate a CaloParticle to LayerClusters - virtual ticl::SimToRecoCollection associateSimToReco(const edm::Handle &cCH, - const edm::Handle &cPCH) const; + virtual ticl::SimToRecoCollectionT associateSimToReco( + const edm::Handle &cCH, const edm::Handle &cPCH) const; }; } // namespace ticl +extern template class ticl::LayerClusterToCaloParticleAssociatorBaseImplT; +extern template class ticl::LayerClusterToCaloParticleAssociatorBaseImplT; + #endif diff --git a/SimDataFormats/Associations/interface/LayerClusterToSimClusterAssociator.h b/SimDataFormats/Associations/interface/LayerClusterToSimClusterAssociator.h index 6953c0fb3975c..a1bbce359ded5 100644 --- a/SimDataFormats/Associations/interface/LayerClusterToSimClusterAssociator.h +++ b/SimDataFormats/Associations/interface/LayerClusterToSimClusterAssociator.h @@ -6,41 +6,51 @@ #include // user include files - #include "SimDataFormats/Associations/interface/LayerClusterToSimClusterAssociatorBaseImpl.h" +#include "DataFormats/Common/interface/Uninitialized.h" // forward declarations namespace ticl { - class LayerClusterToSimClusterAssociator { + template + class LayerClusterToSimClusterAssociatorT { public: - LayerClusterToSimClusterAssociator(std::unique_ptr); - LayerClusterToSimClusterAssociator() = default; - LayerClusterToSimClusterAssociator(LayerClusterToSimClusterAssociator &&) = default; - LayerClusterToSimClusterAssociator &operator=(LayerClusterToSimClusterAssociator &&) = default; - LayerClusterToSimClusterAssociator(const LayerClusterToSimClusterAssociator &) = delete; // stop default - - ~LayerClusterToSimClusterAssociator() = default; - const LayerClusterToSimClusterAssociator &operator=(const LayerClusterToSimClusterAssociator &) = + explicit LayerClusterToSimClusterAssociatorT( + std::unique_ptr> impl) + : m_impl(std::move(impl)) {} + LayerClusterToSimClusterAssociatorT() = delete; + explicit LayerClusterToSimClusterAssociatorT(edm::Uninitialized) noexcept {}; + LayerClusterToSimClusterAssociatorT(LayerClusterToSimClusterAssociatorT &&) = default; + LayerClusterToSimClusterAssociatorT &operator=(LayerClusterToSimClusterAssociatorT &&) = default; + LayerClusterToSimClusterAssociatorT(const LayerClusterToSimClusterAssociatorT &) = delete; // stop default + + ~LayerClusterToSimClusterAssociatorT() = default; + const LayerClusterToSimClusterAssociatorT &operator=(const LayerClusterToSimClusterAssociatorT &) = delete; // stop default // ---------- const member functions --------------------- /// Associate a LayerCluster to SimClusters - ticl::RecoToSimCollectionWithSimClusters associateRecoToSim(const edm::Handle &cCCH, - const edm::Handle &sCCH) const { + RecoToSimCollectionWithSimClustersT associateRecoToSim( + const edm::Handle &cCCH, const edm::Handle &sCCH) const { return m_impl->associateRecoToSim(cCCH, sCCH); }; /// Associate a SimCluster to LayerClusters - ticl::SimToRecoCollectionWithSimClusters associateSimToReco(const edm::Handle &cCCH, - const edm::Handle &sCCH) const { + SimToRecoCollectionWithSimClustersT associateSimToReco( + const edm::Handle &cCCH, const edm::Handle &sCCH) const { return m_impl->associateSimToReco(cCCH, sCCH); } private: // ---------- member data -------------------------------- - std::unique_ptr m_impl; + std::unique_ptr> m_impl; }; } // namespace ticl +extern template class ticl::LayerClusterToSimClusterAssociatorT; +extern template class ticl::LayerClusterToSimClusterAssociatorT; + +using LayerClusterToSimClusterAssociator = ticl::LayerClusterToSimClusterAssociatorT; +using ParticleFlowClusterToSimClusterAssociator = ticl::LayerClusterToSimClusterAssociatorT; + #endif diff --git a/SimDataFormats/Associations/interface/LayerClusterToSimClusterAssociatorBaseImpl.h b/SimDataFormats/Associations/interface/LayerClusterToSimClusterAssociatorBaseImpl.h index 424b042c9ae0a..effb0ac502f09 100644 --- a/SimDataFormats/Associations/interface/LayerClusterToSimClusterAssociatorBaseImpl.h +++ b/SimDataFormats/Associations/interface/LayerClusterToSimClusterAssociatorBaseImpl.h @@ -1,7 +1,7 @@ -#ifndef SimDataFormats_Associations_LayerClusterToSimClusterAssociatorBaseImpl_h -#define SimDataFormats_Associations_LayerClusterToSimClusterAssociatorBaseImpl_h +#ifndef SimDataFormats_Associations_LayerClusterToSimClusterAssociatorBaseImplT_h +#define SimDataFormats_Associations_LayerClusterToSimClusterAssociatorBaseImplT_h -/** \class LayerClusterToSimClusterAssociatorBaseImpl +/** \class LayerClusterToSimClusterAssociatorBaseImplT * * Base class for LayerClusterToSimClusterAssociators. Methods take as input * the handle of LayerClusters and the SimCluster collections and return an @@ -13,32 +13,37 @@ #include "DataFormats/Common/interface/Handle.h" #include "DataFormats/Common/interface/AssociationMap.h" #include "DataFormats/CaloRecHit/interface/CaloClusterCollection.h" - +#include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h" #include "SimDataFormats/CaloAnalysis/interface/SimClusterFwd.h" namespace ticl { - typedef edm::AssociationMap< - edm::OneToManyWithQualityGeneric>> - SimToRecoCollectionWithSimClusters; - typedef edm::AssociationMap> - RecoToSimCollectionWithSimClusters; + template + using SimToRecoCollectionWithSimClustersT = + edm::AssociationMap>>; + template + using RecoToSimCollectionWithSimClustersT = + edm::AssociationMap>; - class LayerClusterToSimClusterAssociatorBaseImpl { + template + class LayerClusterToSimClusterAssociatorBaseImplT { public: /// Constructor - LayerClusterToSimClusterAssociatorBaseImpl(); + LayerClusterToSimClusterAssociatorBaseImplT(); /// Destructor - virtual ~LayerClusterToSimClusterAssociatorBaseImpl(); + virtual ~LayerClusterToSimClusterAssociatorBaseImplT(); /// Associate a LayerCluster to SimClusters - virtual ticl::RecoToSimCollectionWithSimClusters associateRecoToSim( - const edm::Handle &cCH, const edm::Handle &sCCH) const; + virtual RecoToSimCollectionWithSimClustersT associateRecoToSim( + const edm::Handle &cCH, const edm::Handle &sCCH) const; /// Associate a SimCluster to LayerClusters - virtual ticl::SimToRecoCollectionWithSimClusters associateSimToReco( - const edm::Handle &cCH, const edm::Handle &sCCH) const; + virtual SimToRecoCollectionWithSimClustersT associateSimToReco( + const edm::Handle &cCH, const edm::Handle &sCCH) const; }; } // namespace ticl +extern template class ticl::LayerClusterToSimClusterAssociatorBaseImplT; +extern template class ticl::LayerClusterToSimClusterAssociatorBaseImplT; + #endif diff --git a/SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociator.h b/SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociator.h index 77db7c9afce23..8ebcf8aa8adae 100644 --- a/SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociator.h +++ b/SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociator.h @@ -6,8 +6,8 @@ #include // user include files - #include "SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociatorBaseImpl.h" +#include "DataFormats/Common/interface/Uninitialized.h" // forward declarations @@ -16,7 +16,8 @@ namespace ticl { class LayerClusterToSimTracksterAssociator { public: LayerClusterToSimTracksterAssociator(std::unique_ptr); - LayerClusterToSimTracksterAssociator() = default; + LayerClusterToSimTracksterAssociator() = delete; + explicit LayerClusterToSimTracksterAssociator(edm::Uninitialized) noexcept {}; LayerClusterToSimTracksterAssociator(LayerClusterToSimTracksterAssociator &&) = default; LayerClusterToSimTracksterAssociator &operator=(LayerClusterToSimTracksterAssociator &&) = default; LayerClusterToSimTracksterAssociator(const LayerClusterToSimTracksterAssociator &) = delete; // stop default @@ -31,9 +32,9 @@ namespace ticl { const edm::Handle &cCCH, const edm::Handle &stCH, const edm::Handle &cPCH, - const ticl::RecoToSimCollection &lCToCPs, + const ticl::RecoToSimCollectionT &lCToCPs, const edm::Handle &sCCH, - const ticl::RecoToSimCollectionWithSimClusters &lCToSCs) const { + const ticl::RecoToSimCollectionWithSimClustersT &lCToSCs) const { return m_impl->associateRecoToSim(cCCH, stCH, cPCH, lCToCPs, sCCH, lCToSCs); }; @@ -42,9 +43,9 @@ namespace ticl { const edm::Handle &cCCH, const edm::Handle &sTCH, const edm::Handle &cPCH, - const ticl::SimToRecoCollection &cpToLCs, + const ticl::SimToRecoCollectionT &cpToLCs, const edm::Handle &sCCH, - const ticl::SimToRecoCollectionWithSimClusters &sCToLCs) const { + const ticl::SimToRecoCollectionWithSimClustersT &sCToLCs) const { return m_impl->associateSimToReco(cCCH, sTCH, cPCH, cpToLCs, sCCH, sCToLCs); } diff --git a/SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociatorBaseImpl.h b/SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociatorBaseImpl.h index 9882ce85b5280..160df3b1ad125 100644 --- a/SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociatorBaseImpl.h +++ b/SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociatorBaseImpl.h @@ -41,18 +41,18 @@ namespace ticl { const edm::Handle &cCH, const edm::Handle &sTCH, const edm::Handle &cPCH, - const ticl::RecoToSimCollection &lCToCPs, + const ticl::RecoToSimCollectionT &lCToCPs, const edm::Handle &sCCH, - const ticl::RecoToSimCollectionWithSimClusters &lCToSCs) const; + const ticl::RecoToSimCollectionWithSimClustersT &lCToSCs) const; /// Associate a SimTrackster to LayerClusters virtual ticl::SimTracksterToRecoCollection associateSimToReco( const edm::Handle &cCH, const edm::Handle &sTCH, const edm::Handle &cPCH, - const ticl::SimToRecoCollection &cPToLCs, + const ticl::SimToRecoCollectionT &cPToLCs, const edm::Handle &sCCH, - const ticl::SimToRecoCollectionWithSimClusters &sCToLCs) const; + const ticl::SimToRecoCollectionWithSimClustersT &sCToLCs) const; }; } // namespace ticl diff --git a/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociator.h b/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociator.h index 8ed6cb4bec026..ba8c19a50fe24 100644 --- a/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociator.h +++ b/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociator.h @@ -7,6 +7,7 @@ // user include files #include "SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociatorBaseImpl.h" +#include "DataFormats/Common/interface/Uninitialized.h" // forward declarations @@ -15,7 +16,8 @@ namespace reco { class MtdRecoClusterToSimLayerClusterAssociator { public: MtdRecoClusterToSimLayerClusterAssociator(std::unique_ptr); - MtdRecoClusterToSimLayerClusterAssociator() = default; + MtdRecoClusterToSimLayerClusterAssociator() = delete; + explicit MtdRecoClusterToSimLayerClusterAssociator(edm::Uninitialized) noexcept {}; MtdRecoClusterToSimLayerClusterAssociator(MtdRecoClusterToSimLayerClusterAssociator &&) = default; MtdRecoClusterToSimLayerClusterAssociator &operator=(MtdRecoClusterToSimLayerClusterAssociator &&) = default; MtdRecoClusterToSimLayerClusterAssociator(const MtdRecoClusterToSimLayerClusterAssociator &) = diff --git a/SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociator.h b/SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociator.h index 3efaf558b232f..bfd788723a97e 100644 --- a/SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociator.h +++ b/SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociator.h @@ -6,8 +6,8 @@ #include // user include files - #include "SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociatorBaseImpl.h" +#include "DataFormats/Common/interface/Uninitialized.h" // forward declarations @@ -15,7 +15,8 @@ namespace reco { class MtdSimLayerClusterToTPAssociator { public: MtdSimLayerClusterToTPAssociator(std::unique_ptr); - MtdSimLayerClusterToTPAssociator() = default; + MtdSimLayerClusterToTPAssociator() = delete; + explicit MtdSimLayerClusterToTPAssociator(edm::Uninitialized) noexcept {}; MtdSimLayerClusterToTPAssociator(MtdSimLayerClusterToTPAssociator &&) = default; MtdSimLayerClusterToTPAssociator &operator=(MtdSimLayerClusterToTPAssociator &&) = default; MtdSimLayerClusterToTPAssociator(const MtdSimLayerClusterToTPAssociator &) = delete; // stop default diff --git a/SimDataFormats/Associations/interface/MultiClusterToCaloParticleAssociator.h b/SimDataFormats/Associations/interface/MultiClusterToCaloParticleAssociator.h index 9e6c13fe84bd3..b53b204f13d7d 100644 --- a/SimDataFormats/Associations/interface/MultiClusterToCaloParticleAssociator.h +++ b/SimDataFormats/Associations/interface/MultiClusterToCaloParticleAssociator.h @@ -6,8 +6,8 @@ #include // user include files - #include "SimDataFormats/Associations/interface/MultiClusterToCaloParticleAssociatorBaseImpl.h" +#include "DataFormats/Common/interface/Uninitialized.h" // forward declarations diff --git a/SimDataFormats/Associations/interface/MuonToTrackingParticleAssociator.h b/SimDataFormats/Associations/interface/MuonToTrackingParticleAssociator.h index 3254d4c7f4108..7886ff103c42f 100644 --- a/SimDataFormats/Associations/interface/MuonToTrackingParticleAssociator.h +++ b/SimDataFormats/Associations/interface/MuonToTrackingParticleAssociator.h @@ -8,13 +8,15 @@ #include "SimDataFormats/Associations/interface/MuonToTrackingParticleAssociatorBaseImpl.h" #include "SimDataFormats/Associations/interface/MuonTrackType.h" #include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h" +#include "DataFormats/Common/interface/Uninitialized.h" #include namespace reco { class MuonToTrackingParticleAssociator { public: - MuonToTrackingParticleAssociator() = default; + MuonToTrackingParticleAssociator() = delete; + explicit MuonToTrackingParticleAssociator(edm::Uninitialized) noexcept {}; ~MuonToTrackingParticleAssociator() = default; #ifndef __GCCXML__ MuonToTrackingParticleAssociator(std::unique_ptr); diff --git a/SimDataFormats/Associations/interface/TrackToGenParticleAssociator.h b/SimDataFormats/Associations/interface/TrackToGenParticleAssociator.h index a7c93b7b19f73..c16c2207e7667 100644 --- a/SimDataFormats/Associations/interface/TrackToGenParticleAssociator.h +++ b/SimDataFormats/Associations/interface/TrackToGenParticleAssociator.h @@ -16,6 +16,7 @@ #include "SimDataFormats/Vertex/interface/SimVertexContainer.h" #include "SimDataFormats/Associations/interface/TrackToGenParticleAssociatorBaseImpl.h" +#include "DataFormats/Common/interface/Uninitialized.h" #include @@ -34,7 +35,8 @@ namespace reco { class TrackToGenParticleAssociator { public: /// Constructor - TrackToGenParticleAssociator() = default; + TrackToGenParticleAssociator() = delete; + explicit TrackToGenParticleAssociator(edm::Uninitialized) noexcept {}; #ifndef __GCCXML__ TrackToGenParticleAssociator(std::unique_ptr); #endif diff --git a/SimDataFormats/Associations/interface/TrackToTrackingParticleAssociator.h b/SimDataFormats/Associations/interface/TrackToTrackingParticleAssociator.h index 0951e73c61d55..c7affcd511934 100644 --- a/SimDataFormats/Associations/interface/TrackToTrackingParticleAssociator.h +++ b/SimDataFormats/Associations/interface/TrackToTrackingParticleAssociator.h @@ -29,6 +29,7 @@ #include "DataFormats/TrajectorySeed/interface/TrajectorySeedCollection.h" #include "SimDataFormats/Associations/interface/TrackToTrackingParticleAssociatorBaseImpl.h" +#include "DataFormats/Common/interface/Uninitialized.h" // forward declarations @@ -38,7 +39,8 @@ namespace reco { #ifndef __GCCXML__ TrackToTrackingParticleAssociator(std::unique_ptr); #endif - TrackToTrackingParticleAssociator() = default; + TrackToTrackingParticleAssociator() = delete; + explicit TrackToTrackingParticleAssociator(edm::Uninitialized) noexcept {}; TrackToTrackingParticleAssociator(TrackToTrackingParticleAssociator &&) = default; TrackToTrackingParticleAssociator &operator=(TrackToTrackingParticleAssociator &&) = default; TrackToTrackingParticleAssociator(const TrackToTrackingParticleAssociator &) = delete; // stop default diff --git a/SimDataFormats/Associations/interface/TracksterToSimClusterAssociator.h b/SimDataFormats/Associations/interface/TracksterToSimClusterAssociator.h index 3bcfa788b9c95..ed82444ce7fe4 100644 --- a/SimDataFormats/Associations/interface/TracksterToSimClusterAssociator.h +++ b/SimDataFormats/Associations/interface/TracksterToSimClusterAssociator.h @@ -6,8 +6,8 @@ #include // user include files - #include "SimDataFormats/Associations/interface/TracksterToSimClusterAssociatorBaseImpl.h" +#include "DataFormats/Common/interface/Uninitialized.h" // forward declarations @@ -16,7 +16,8 @@ namespace ticl { class TracksterToSimClusterAssociator { public: TracksterToSimClusterAssociator(std::unique_ptr); - TracksterToSimClusterAssociator() = default; + TracksterToSimClusterAssociator() = delete; + explicit TracksterToSimClusterAssociator(edm::Uninitialized) noexcept {}; TracksterToSimClusterAssociator(TracksterToSimClusterAssociator &&) = default; TracksterToSimClusterAssociator &operator=(TracksterToSimClusterAssociator &&) = default; TracksterToSimClusterAssociator(const TracksterToSimClusterAssociator &) = delete; // stop default diff --git a/SimDataFormats/Associations/interface/TracksterToSimTracksterAssociator.h b/SimDataFormats/Associations/interface/TracksterToSimTracksterAssociator.h index 301922fc32779..e754bb27b9bed 100644 --- a/SimDataFormats/Associations/interface/TracksterToSimTracksterAssociator.h +++ b/SimDataFormats/Associations/interface/TracksterToSimTracksterAssociator.h @@ -6,8 +6,8 @@ #include // user include files - #include "SimDataFormats/Associations/interface/TracksterToSimTracksterAssociatorBaseImpl.h" +#include "DataFormats/Common/interface/Uninitialized.h" // forward declarations @@ -16,7 +16,8 @@ namespace ticl { class TracksterToSimTracksterAssociator { public: TracksterToSimTracksterAssociator(std::unique_ptr); - TracksterToSimTracksterAssociator() = default; + TracksterToSimTracksterAssociator() = delete; + explicit TracksterToSimTracksterAssociator(edm::Uninitialized) noexcept {}; TracksterToSimTracksterAssociator(TracksterToSimTracksterAssociator &&) = default; TracksterToSimTracksterAssociator &operator=(TracksterToSimTracksterAssociator &&) = default; TracksterToSimTracksterAssociator(const TracksterToSimTracksterAssociator &) = delete; // stop default diff --git a/SimDataFormats/Associations/interface/TracksterToSimTracksterHitLCAssociator.h b/SimDataFormats/Associations/interface/TracksterToSimTracksterHitLCAssociator.h index d66ed0685b5f9..028724dddb498 100644 --- a/SimDataFormats/Associations/interface/TracksterToSimTracksterHitLCAssociator.h +++ b/SimDataFormats/Associations/interface/TracksterToSimTracksterHitLCAssociator.h @@ -6,15 +6,16 @@ #include // user include files - #include "SimDataFormats/Associations/interface/TracksterToSimTracksterHitLCAssociatorBaseImpl.h" +#include "DataFormats/Common/interface/Uninitialized.h" namespace ticl { class TracksterToSimTracksterHitLCAssociator { public: TracksterToSimTracksterHitLCAssociator(std::unique_ptr); - TracksterToSimTracksterHitLCAssociator() = default; + TracksterToSimTracksterHitLCAssociator() = delete; + explicit TracksterToSimTracksterHitLCAssociator(edm::Uninitialized) noexcept {}; TracksterToSimTracksterHitLCAssociator(TracksterToSimTracksterHitLCAssociator &&) = default; TracksterToSimTracksterHitLCAssociator &operator=(TracksterToSimTracksterHitLCAssociator &&) = default; TracksterToSimTracksterHitLCAssociator(const TracksterToSimTracksterHitLCAssociator &) = delete; diff --git a/SimDataFormats/Associations/interface/VertexToTrackingVertexAssociator.h b/SimDataFormats/Associations/interface/VertexToTrackingVertexAssociator.h index 46015d2902633..88a181eb6c5c2 100644 --- a/SimDataFormats/Associations/interface/VertexToTrackingVertexAssociator.h +++ b/SimDataFormats/Associations/interface/VertexToTrackingVertexAssociator.h @@ -4,6 +4,7 @@ #include "SimDataFormats/Associations/interface/VertexAssociation.h" #include "SimDataFormats/Associations/interface/VertexToTrackingVertexAssociatorBaseImpl.h" +#include "DataFormats/Common/interface/Uninitialized.h" namespace reco { class VertexToTrackingVertexAssociator { @@ -11,7 +12,8 @@ namespace reco { #ifndef __GCCXML__ VertexToTrackingVertexAssociator(std::unique_ptr); #endif - VertexToTrackingVertexAssociator() = default; + VertexToTrackingVertexAssociator() = delete; + explicit VertexToTrackingVertexAssociator(edm::Uninitialized) noexcept {}; VertexToTrackingVertexAssociator(VertexToTrackingVertexAssociator &&) = default; VertexToTrackingVertexAssociator &operator=(VertexToTrackingVertexAssociator &&) = default; VertexToTrackingVertexAssociator(const VertexToTrackingVertexAssociator &) = delete; // stop default diff --git a/SimDataFormats/Associations/src/LayerClusterToCaloParticleAssociator.cc b/SimDataFormats/Associations/src/LayerClusterToCaloParticleAssociator.cc index 78ee7e394e2b0..659af3449dd67 100644 --- a/SimDataFormats/Associations/src/LayerClusterToCaloParticleAssociator.cc +++ b/SimDataFormats/Associations/src/LayerClusterToCaloParticleAssociator.cc @@ -2,6 +2,5 @@ #include "SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociator.h" -ticl::LayerClusterToCaloParticleAssociator::LayerClusterToCaloParticleAssociator( - std::unique_ptr ptr) - : m_impl(std::move(ptr)) {} +template class ticl::LayerClusterToCaloParticleAssociatorT; +template class ticl::LayerClusterToCaloParticleAssociatorT; diff --git a/SimDataFormats/Associations/src/LayerClusterToCaloParticleAssociatorBaseImpl.cc b/SimDataFormats/Associations/src/LayerClusterToCaloParticleAssociatorBaseImpl.cc index 4ae41bfd936ef..49039362fccba 100644 --- a/SimDataFormats/Associations/src/LayerClusterToCaloParticleAssociatorBaseImpl.cc +++ b/SimDataFormats/Associations/src/LayerClusterToCaloParticleAssociatorBaseImpl.cc @@ -3,17 +3,23 @@ #include "SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociatorBaseImpl.h" namespace ticl { - LayerClusterToCaloParticleAssociatorBaseImpl::LayerClusterToCaloParticleAssociatorBaseImpl() {} - LayerClusterToCaloParticleAssociatorBaseImpl::~LayerClusterToCaloParticleAssociatorBaseImpl() {} + template + LayerClusterToCaloParticleAssociatorBaseImplT::LayerClusterToCaloParticleAssociatorBaseImplT() {} + template + LayerClusterToCaloParticleAssociatorBaseImplT::~LayerClusterToCaloParticleAssociatorBaseImplT() {} - ticl::RecoToSimCollection LayerClusterToCaloParticleAssociatorBaseImpl::associateRecoToSim( - const edm::Handle &cCCH, const edm::Handle &cPCH) const { - return ticl::RecoToSimCollection(); + template + ticl::RecoToSimCollectionT LayerClusterToCaloParticleAssociatorBaseImplT::associateRecoToSim( + const edm::Handle &cCCH, const edm::Handle &cPCH) const { + return ticl::RecoToSimCollectionT(); } - ticl::SimToRecoCollection LayerClusterToCaloParticleAssociatorBaseImpl::associateSimToReco( - const edm::Handle &cCCH, const edm::Handle &cPCH) const { - return ticl::SimToRecoCollection(); + template + ticl::SimToRecoCollectionT LayerClusterToCaloParticleAssociatorBaseImplT::associateSimToReco( + const edm::Handle &cCCH, const edm::Handle &cPCH) const { + return ticl::SimToRecoCollectionT(); } - } // namespace ticl + +template class ticl::LayerClusterToCaloParticleAssociatorBaseImplT; +template class ticl::LayerClusterToCaloParticleAssociatorBaseImplT; diff --git a/SimDataFormats/Associations/src/LayerClusterToSimClusterAssociator.cc b/SimDataFormats/Associations/src/LayerClusterToSimClusterAssociator.cc index 2d1ac9c97a69e..60689d01aab1b 100644 --- a/SimDataFormats/Associations/src/LayerClusterToSimClusterAssociator.cc +++ b/SimDataFormats/Associations/src/LayerClusterToSimClusterAssociator.cc @@ -2,6 +2,5 @@ #include "SimDataFormats/Associations/interface/LayerClusterToSimClusterAssociator.h" -ticl::LayerClusterToSimClusterAssociator::LayerClusterToSimClusterAssociator( - std::unique_ptr ptr) - : m_impl(std::move(ptr)) {} +template class ticl::LayerClusterToSimClusterAssociatorT; +template class ticl::LayerClusterToSimClusterAssociatorT; \ No newline at end of file diff --git a/SimDataFormats/Associations/src/LayerClusterToSimClusterAssociatorBaseImpl.cc b/SimDataFormats/Associations/src/LayerClusterToSimClusterAssociatorBaseImpl.cc index 0b2306473bff6..f16b48a0b5556 100644 --- a/SimDataFormats/Associations/src/LayerClusterToSimClusterAssociatorBaseImpl.cc +++ b/SimDataFormats/Associations/src/LayerClusterToSimClusterAssociatorBaseImpl.cc @@ -3,17 +3,24 @@ #include "SimDataFormats/Associations/interface/LayerClusterToSimClusterAssociatorBaseImpl.h" namespace ticl { - LayerClusterToSimClusterAssociatorBaseImpl::LayerClusterToSimClusterAssociatorBaseImpl() {} - LayerClusterToSimClusterAssociatorBaseImpl::~LayerClusterToSimClusterAssociatorBaseImpl() {} + template + LayerClusterToSimClusterAssociatorBaseImplT::LayerClusterToSimClusterAssociatorBaseImplT() {} + template + LayerClusterToSimClusterAssociatorBaseImplT::~LayerClusterToSimClusterAssociatorBaseImplT() {} - ticl::RecoToSimCollectionWithSimClusters LayerClusterToSimClusterAssociatorBaseImpl::associateRecoToSim( - const edm::Handle &cCCH, const edm::Handle &sCCH) const { - return ticl::RecoToSimCollectionWithSimClusters(); + template + RecoToSimCollectionWithSimClustersT LayerClusterToSimClusterAssociatorBaseImplT::associateRecoToSim( + const edm::Handle &cCCH, const edm::Handle &sCCH) const { + return RecoToSimCollectionWithSimClustersT(); } - ticl::SimToRecoCollectionWithSimClusters LayerClusterToSimClusterAssociatorBaseImpl::associateSimToReco( - const edm::Handle &cCCH, const edm::Handle &sCCH) const { - return ticl::SimToRecoCollectionWithSimClusters(); + template + SimToRecoCollectionWithSimClustersT LayerClusterToSimClusterAssociatorBaseImplT::associateSimToReco( + const edm::Handle &cCCH, const edm::Handle &sCCH) const { + return SimToRecoCollectionWithSimClustersT(); } + template class ticl::LayerClusterToSimClusterAssociatorBaseImplT; + template class ticl::LayerClusterToSimClusterAssociatorBaseImplT; + } // namespace ticl diff --git a/SimDataFormats/Associations/src/LayerClusterToSimTracksterAssociatorBaseImpl.cc b/SimDataFormats/Associations/src/LayerClusterToSimTracksterAssociatorBaseImpl.cc index 58e15a3de1a7a..98cc03e269a55 100644 --- a/SimDataFormats/Associations/src/LayerClusterToSimTracksterAssociatorBaseImpl.cc +++ b/SimDataFormats/Associations/src/LayerClusterToSimTracksterAssociatorBaseImpl.cc @@ -10,9 +10,9 @@ namespace ticl { const edm::Handle &cCCH, const edm::Handle &sTCH, const edm::Handle &cPCH, - const ticl::RecoToSimCollection &lCToCPs, + const ticl::RecoToSimCollectionT &lCToCPs, const edm::Handle &sCCH, - const ticl::RecoToSimCollectionWithSimClusters &lCToSCs) const { + const ticl::RecoToSimCollectionWithSimClustersT &lCToSCs) const { return ticl::RecoToSimTracksterCollection(); } @@ -20,9 +20,9 @@ namespace ticl { const edm::Handle &cCCH, const edm::Handle &sTCH, const edm::Handle &cPCH, - const ticl::SimToRecoCollection &cPToLCs, + const ticl::SimToRecoCollectionT &cPToLCs, const edm::Handle &sCCH, - const ticl::SimToRecoCollectionWithSimClusters &sCToLCs) const { + const ticl::SimToRecoCollectionWithSimClustersT &sCToLCs) const { return ticl::SimTracksterToRecoCollection(); } diff --git a/SimDataFormats/Associations/src/classes.h b/SimDataFormats/Associations/src/classes.h index a240d5382b5a5..cd38c1eb350ce 100644 --- a/SimDataFormats/Associations/src/classes.h +++ b/SimDataFormats/Associations/src/classes.h @@ -6,6 +6,7 @@ #include "SimDataFormats/Associations/interface/TrackToTrackingParticleAssociator.h" #include "SimDataFormats/Associations/interface/VertexAssociation.h" #include "SimDataFormats/Associations/interface/VertexToTrackingVertexAssociator.h" +#include "SimDataFormats/CaloAnalysis/interface/CaloParticle.h" #include "SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociator.h" #include "SimDataFormats/Associations/interface/LayerClusterToSimClusterAssociator.h" #include "SimDataFormats/Associations/interface/TrackAssociation.h" @@ -22,7 +23,15 @@ #include "SimDataFormats/Associations/interface/TTTypes.h" #include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h" #include "SimDataFormats/TrackingAnalysis/interface/TrackingParticleFwd.h" +#include "DataFormats/CaloRecHit/interface/CaloCluster.h" +#include "DataFormats/CaloRecHit/interface/CaloClusterFwd.h" +#include "DataFormats/ParticleFlowReco/interface/PFCluster.h" +#include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h" #include "SimDataFormats/TrackingHit/interface/PSimHitContainer.h" #include "SimDataFormats/Associations/interface/TICLAssociationMap.h" #include "DataFormats/Common/interface/RefProd.h" #include "DataFormats/Common/interface/Ref.h" +#include "DataFormats/Common/interface/AssociationMap.h" +#include "DataFormats/Common/interface/OneToManyWithQualityGeneric.h" +#include "DataFormats/Common/interface/AssociationMapHelpers.h" +#include "SimDataFormats/CaloAnalysis/interface/SimCluster.h" diff --git a/SimDataFormats/Associations/src/classes_def.xml b/SimDataFormats/Associations/src/classes_def.xml index 690ae56da3c90..f61f51cbd2a2b 100644 --- a/SimDataFormats/Associations/src/classes_def.xml +++ b/SimDataFormats/Associations/src/classes_def.xml @@ -10,11 +10,17 @@ - - + + - - + + + + + + + + @@ -97,16 +103,21 @@ - - - + + + + + + - - + + + - + + @@ -114,14 +125,22 @@ - + + + + + + + + + - - + - + + @@ -149,7 +168,44 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/SimG4Core/Configuration/python/customise_trackerOnlySim.py b/SimG4Core/Configuration/python/customise_trackerOnlySim.py new file mode 100644 index 0000000000000..23c97deca9186 --- /dev/null +++ b/SimG4Core/Configuration/python/customise_trackerOnlySim.py @@ -0,0 +1,7 @@ +import FWCore.ParameterSet.Config as cms + +def customise(process): + process.g4SimHits.OnlySDs = [ + 'TkAccumulatingSensitiveDetector' + ] + return process diff --git a/Validation/HGCalValidation/interface/BarrelVHistoProducerAlgo.h b/Validation/HGCalValidation/interface/BarrelVHistoProducerAlgo.h index 59b59d6b6be3a..12f69ff08c907 100644 --- a/Validation/HGCalValidation/interface/BarrelVHistoProducerAlgo.h +++ b/Validation/HGCalValidation/interface/BarrelVHistoProducerAlgo.h @@ -236,22 +236,23 @@ class BarrelVHistoProducerAlgo { std::vector const& cPSelectedIndices, std::unordered_map const&, unsigned int layers, - const ticl::RecoToSimCollection& recSimColl, - const ticl::SimToRecoCollection& simRecColl, + const ticl::RecoToSimCollectionT& recSimColl, + const ticl::SimToRecoCollectionT& simRecColl, edm::MultiSpan const& barrelHits) const; - void layerClusters_to_SimClusters(const Histograms& histograms, - const int count, - edm::Handle clusterHandle, - const reco::CaloClusterCollection& clusters, - edm::Handle> simClusterHandle, - std::vector const& simClusters, - std::vector const& sCIndices, - const std::vector& mask, - std::unordered_map const&, - unsigned int layers, - const ticl::RecoToSimCollectionWithSimClusters& recSimColl, - const ticl::SimToRecoCollectionWithSimClusters& simRecColl, - edm::MultiSpan const& barrelHits) const; + void layerClusters_to_SimClusters( + const Histograms& histograms, + const int count, + edm::Handle clusterHandle, + const reco::CaloClusterCollection& clusters, + edm::Handle> simClusterHandle, + std::vector const& simClusters, + std::vector const& sCIndices, + const std::vector& mask, + std::unordered_map const&, + unsigned int layers, + const ticl::RecoToSimCollectionWithSimClustersT& recSimColl, + const ticl::SimToRecoCollectionWithSimClustersT& simRecColl, + edm::MultiSpan const& barrelHits) const; void tracksters_to_SimTracksters_fp(const Histograms& histograms, const int count, @@ -281,25 +282,26 @@ class BarrelVHistoProducerAlgo { std::vector const& cPSelectedIndices, std::unordered_map const&, unsigned int layers, - const ticl::RecoToSimCollection& recSimColl, - const ticl::SimToRecoCollection& simRecColl, + const ticl::RecoToSimCollectionT& recSimColl, + const ticl::SimToRecoCollectionT& simRecColl, edm::MultiSpan const& barrelHits) const; void fill_simCluster_histos(const Histograms& histograms, std::vector const& simClusters, unsigned int layers) const; - void fill_simClusterAssociation_histos(const Histograms& histograms, - const int count, - edm::Handle clusterHandle, - const reco::CaloClusterCollection& clusters, - edm::Handle> simClusterHandle, - std::vector const& simClusters, - std::vector const& sCIndices, - const std::vector& mask, - std::unordered_map const& barrelHitMap, - unsigned int layers, - const ticl::RecoToSimCollectionWithSimClusters& recSimColl, - const ticl::SimToRecoCollectionWithSimClusters& simRecColl, - edm::MultiSpan const& barrelHits) const; + void fill_simClusterAssociation_histos( + const Histograms& histograms, + const int count, + edm::Handle clusterHandle, + const reco::CaloClusterCollection& clusters, + edm::Handle> simClusterHandle, + std::vector const& simClusters, + std::vector const& sCIndices, + const std::vector& mask, + std::unordered_map const& barrelHitMap, + unsigned int layers, + const ticl::RecoToSimCollectionWithSimClustersT& recSimColl, + const ticl::SimToRecoCollectionWithSimClustersT& simRecColl, + edm::MultiSpan const& barrelHits) const; void fill_cluster_histos(const Histograms& histograms, const int count, const reco::CaloCluster& cluster) const; double distance2(const double x1, const double y1, const double x2, const double y2) const; diff --git a/Validation/HGCalValidation/interface/BarrelValidator.h b/Validation/HGCalValidation/interface/BarrelValidator.h index 8617539151c56..00ddbc9744c89 100644 --- a/Validation/HGCalValidation/interface/BarrelValidator.h +++ b/Validation/HGCalValidation/interface/BarrelValidator.h @@ -1,11 +1,6 @@ #ifndef BarrelValidator_h #define BarrelValidator_h -/** \class BarrelValidator - * Class that produces histograms to validate HGCal Reconstruction performances - * - * \author HGCal - */ #include "FWCore/Framework/interface/Event.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" @@ -92,10 +87,12 @@ class BarrelValidator : public DQMGlobalEDAnalyzer { edm::EDGetTokenT> simVertices_; std::vector>> clustersMaskTokens_; edm::EDGetTokenT> barrelHitMap_; - std::vector> associatorMapRtS; - std::vector> associatorMapStR; - std::vector> associatorMapSimtR; - std::vector> associatorMapRtSim; + std::vector>> associatorMapRtS; + std::vector>> associatorMapStR; + std::vector>> + associatorMapSimtR; + std::vector>> + associatorMapRtSim; std::unique_ptr histoProducerAlgo_; std::vector barrel_hits_label_; std::vector>> barrel_hits_tokens_; diff --git a/Validation/HGCalValidation/interface/HGCalValidator.h b/Validation/HGCalValidation/interface/HGCalValidator.h index feabd43a74c7b..be4524105f43d 100644 --- a/Validation/HGCalValidation/interface/HGCalValidator.h +++ b/Validation/HGCalValidation/interface/HGCalValidator.h @@ -108,10 +108,10 @@ class HGCalValidator : public DQMGlobalEDAnalyzer { edm::EDGetTokenT> simVertices_; std::vector>> clustersMaskTokens_; edm::EDGetTokenT> hitMap_; - edm::EDGetTokenT associatorMapRtS; - edm::EDGetTokenT associatorMapStR; - edm::EDGetTokenT associatorMapSimtR; - edm::EDGetTokenT associatorMapRtSim; + edm::EDGetTokenT> associatorMapRtS; + edm::EDGetTokenT> associatorMapStR; + edm::EDGetTokenT> associatorMapSimtR; + edm::EDGetTokenT> associatorMapRtSim; std::unique_ptr histoProducerAlgo_; std::vector hits_label_; std::vector> hits_tokens_; diff --git a/Validation/HGCalValidation/interface/HGVHistoProducerAlgo.h b/Validation/HGCalValidation/interface/HGVHistoProducerAlgo.h index 6798662c884e7..7530f2fbe2e47 100644 --- a/Validation/HGCalValidation/interface/HGVHistoProducerAlgo.h +++ b/Validation/HGCalValidation/interface/HGVHistoProducerAlgo.h @@ -280,22 +280,23 @@ class HGVHistoProducerAlgo { std::vector const& cPSelectedIndices, std::unordered_map const&, unsigned int layers, - const ticl::RecoToSimCollection& recSimColl, - const ticl::SimToRecoCollection& simRecColl, + const ticl::RecoToSimCollectionT& recSimColl, + const ticl::SimToRecoCollectionT& simRecColl, edm::MultiSpan const& hits) const; - void layerClusters_to_SimClusters(const Histograms& histograms, - const int count, - edm::Handle clusterHandle, - const reco::CaloClusterCollection& clusters, - edm::Handle> simClusterHandle, - std::vector const& simClusters, - std::vector const& sCIndices, - const std::vector& mask, - std::unordered_map const&, - unsigned int layers, - const ticl::RecoToSimCollectionWithSimClusters& recSimColl, - const ticl::SimToRecoCollectionWithSimClusters& simRecColl, - edm::MultiSpan const& hits) const; + void layerClusters_to_SimClusters( + const Histograms& histograms, + const int count, + edm::Handle clusterHandle, + const reco::CaloClusterCollection& clusters, + edm::Handle> simClusterHandle, + std::vector const& simClusters, + std::vector const& sCIndices, + const std::vector& mask, + std::unordered_map const&, + unsigned int layers, + const ticl::RecoToSimCollectionWithSimClustersT& recSimColl, + const ticl::SimToRecoCollectionWithSimClustersT& simRecColl, + edm::MultiSpan const& hits) const; void tracksters_to_SimTracksters_fp(const Histograms& histograms, const int count, @@ -323,30 +324,31 @@ class HGVHistoProducerAlgo { std::vector const& cP, std::vector const& cPIndices, std::vector const& cPSelectedIndices, - std::unordered_map const&, + std::unordered_map const& hitMap, std::map cummatbudg, unsigned int layers, std::vector thicknesses, - const ticl::RecoToSimCollection& recSimColl, - const ticl::SimToRecoCollection& simRecColl, + const ticl::RecoToSimCollectionT& recSimColl, + const ticl::SimToRecoCollectionT& simRecColl, edm::MultiSpan const& hits) const; void fill_simCluster_histos(const Histograms& histograms, std::vector const& simClusters, unsigned int layers, std::vector thicknesses) const; - void fill_simClusterAssociation_histos(const Histograms& histograms, - const int count, - edm::Handle clusterHandle, - const reco::CaloClusterCollection& clusters, - edm::Handle> simClusterHandle, - std::vector const& simClusters, - std::vector const& sCIndices, - const std::vector& mask, - std::unordered_map const& hitMap, - unsigned int layers, - const ticl::RecoToSimCollectionWithSimClusters& recSimColl, - const ticl::SimToRecoCollectionWithSimClusters& simRecColl, - edm::MultiSpan const& hits) const; + void fill_simClusterAssociation_histos( + const Histograms& histograms, + const int count, + edm::Handle clusterHandle, + const reco::CaloClusterCollection& clusters, + edm::Handle> simClusterHandle, + std::vector const& simClusters, + std::vector const& sCIndices, + const std::vector& mask, + std::unordered_map const& hitMap, + unsigned int layers, + const ticl::RecoToSimCollectionWithSimClustersT& recSimColl, + const ticl::SimToRecoCollectionWithSimClustersT& simRecColl, + edm::MultiSpan const& hits) const; void fill_cluster_histos(const Histograms& histograms, const int count, const reco::CaloCluster& cluster) const; void fill_trackster_histos(const Histograms& histograms, const int count, diff --git a/Validation/HGCalValidation/plugins/BarrelValidator.cc b/Validation/HGCalValidation/plugins/BarrelValidator.cc index 3db3692681886..2da8957dae3a7 100644 --- a/Validation/HGCalValidation/plugins/BarrelValidator.cc +++ b/Validation/HGCalValidation/plugins/BarrelValidator.cc @@ -97,10 +97,12 @@ BarrelValidator::BarrelValidator(const edm::ParameterSet& pset) } for (auto& itag : associatorSim_) { - associatorMapRtSim.push_back(consumes(itag)); + associatorMapRtSim.push_back( + consumes>(itag)); } for (auto& itag : associatorSim_) { - associatorMapSimtR.push_back(consumes(itag)); + associatorMapSimtR.push_back( + consumes>(itag)); } barrelHitMap_ = @@ -111,10 +113,10 @@ BarrelValidator::BarrelValidator(const edm::ParameterSet& pset) layerclusters_ = consumes(label_lcl); for (auto& itag : associator_) { - associatorMapRtS.push_back(consumes(itag)); + associatorMapRtS.push_back(consumes>(itag)); } for (auto& itag : associator_) { - associatorMapStR.push_back(consumes(itag)); + associatorMapStR.push_back(consumes>(itag)); } cpSelector = CaloParticleSelector(pset.getParameter("ptMinCP"), @@ -263,13 +265,13 @@ void BarrelValidator::dqmAnalyze(const edm::Event& event, tools_->setGeometry(*geom); histoProducerAlgo_->setRecHitTools(tools_); - std::vector recSimColl; - std::vector simRecColl; + std::vector> recSimColl; + std::vector> simRecColl; for (unsigned int i = 0; i < associatorMapRtS.size(); ++i) { - edm::Handle simToRecoCollectionH; + edm::Handle> simToRecoCollectionH; event.getByToken(associatorMapStR[i], simToRecoCollectionH); simRecColl.push_back(*simToRecoCollectionH); - edm::Handle recoToSimCollectionH; + edm::Handle> recoToSimCollectionH; event.getByToken(associatorMapRtS[i], recoToSimCollectionH); recSimColl.push_back(*recoToSimCollectionH); } @@ -340,13 +342,13 @@ void BarrelValidator::dqmAnalyze(const edm::Event& event, for (unsigned int ws = 0; ws < label_clustersmask.size(); ws++) { const auto& inputClusterMask = event.get(clustersMaskTokens_[ws]); - std::vector recSimColl; - std::vector simRecColl; + std::vector> recSimColl; + std::vector> simRecColl; for (unsigned int i = 0; i < associatorMapRtSim.size(); ++i) { - edm::Handle simtorecoCollectionH; + edm::Handle> simtorecoCollectionH; event.getByToken(associatorMapSimtR[i], simtorecoCollectionH); simRecColl.push_back(*simtorecoCollectionH); - edm::Handle recotosimCollectionH; + edm::Handle> recotosimCollectionH; event.getByToken(associatorMapRtSim[i], recotosimCollectionH); recSimColl.push_back(*recotosimCollectionH); } diff --git a/Validation/HGCalValidation/plugins/HGCalValidator.cc b/Validation/HGCalValidation/plugins/HGCalValidator.cc index 07407a708db7c..48f3651937fb3 100644 --- a/Validation/HGCalValidation/plugins/HGCalValidator.cc +++ b/Validation/HGCalValidation/plugins/HGCalValidator.cc @@ -117,8 +117,8 @@ HGCalValidator::HGCalValidator(const edm::ParameterSet& pset) clustersMaskTokens_.push_back(consumes>(itag)); } - associatorMapSimtR = consumes(associatorSim_); - associatorMapRtSim = consumes(associatorSim_); + associatorMapSimtR = consumes>(associatorSim_); + associatorMapRtSim = consumes>(associatorSim_); simTrackstersMap_ = consumes>>(pset.getParameter("simTrackstersMap")); @@ -165,8 +165,8 @@ HGCalValidator::HGCalValidator(const edm::ParameterSet& pset) simTracksters_ = consumes(label_simTS); simTracksters_fromCPs_ = consumes(label_simTSFromCP); - associatorMapRtS = consumes(associator_); - associatorMapStR = consumes(associator_); + associatorMapRtS = consumes>(associator_); + associatorMapStR = consumes>(associator_); cpSelector = CaloParticleSelector(pset.getParameter("ptMinCP"), pset.getParameter("ptMaxCP"), @@ -406,10 +406,10 @@ void HGCalValidator::dqmAnalyze(const edm::Event& event, tools_->setGeometry(*geom); histoProducerAlgo_->setRecHitTools(tools_); - edm::Handle simtorecoCollectionH; + edm::Handle> simtorecoCollectionH; event.getByToken(associatorMapStR, simtorecoCollectionH); const auto& simRecColl = *simtorecoCollectionH; - edm::Handle recotosimCollectionH; + edm::Handle> recotosimCollectionH; event.getByToken(associatorMapRtS, recotosimCollectionH); const auto& recSimColl = *recotosimCollectionH; @@ -511,10 +511,10 @@ void HGCalValidator::dqmAnalyze(const edm::Event& event, const auto& inputClusterMask = *inputClusterMaskHandle; - edm::Handle simtorecoCollectionH; + edm::Handle> simtorecoCollectionH; event.getByToken(associatorMapSimtR, simtorecoCollectionH); auto simRecColl = *simtorecoCollectionH; - edm::Handle recotosimCollectionH; + edm::Handle> recotosimCollectionH; event.getByToken(associatorMapRtSim, recotosimCollectionH); auto recSimColl = *recotosimCollectionH; diff --git a/Validation/HGCalValidation/src/BarrelVHistoProducerAlgo.cc b/Validation/HGCalValidation/src/BarrelVHistoProducerAlgo.cc index 2b01b8fff9504..4eec007f41565 100644 --- a/Validation/HGCalValidation/src/BarrelVHistoProducerAlgo.cc +++ b/Validation/HGCalValidation/src/BarrelVHistoProducerAlgo.cc @@ -831,8 +831,8 @@ void BarrelVHistoProducerAlgo::BarrelVHistoProducerAlgo::fill_simClusterAssociat const std::vector& mask, std::unordered_map const& barrelHitMap, unsigned int layers, - const ticl::RecoToSimCollectionWithSimClusters& scsInLayerClusterMap, - const ticl::SimToRecoCollectionWithSimClusters& lcsInSimClusterMap, + const ticl::RecoToSimCollectionWithSimClustersT& scsInLayerClusterMap, + const ticl::SimToRecoCollectionWithSimClustersT& lcsInSimClusterMap, edm::MultiSpan const& barrelHits) const { //Each event to be treated as two events: an event in +ve endcap, //plus another event in -ve endcap. In this spirit there will be @@ -876,8 +876,8 @@ void BarrelVHistoProducerAlgo::layerClusters_to_CaloParticles( std::vector const& cPSelectedIndices, std::unordered_map const& barrelHitMap, unsigned int layers, - const ticl::RecoToSimCollection& cpsInLayerClusterMap, - const ticl::SimToRecoCollection& cPOnLayerMap, + const ticl::RecoToSimCollectionT& cpsInLayerClusterMap, + const ticl::SimToRecoCollectionT& cPOnLayerMap, edm::MultiSpan const& barrelHits) const { const auto nLayerClusters = clusters.size(); @@ -1151,8 +1151,8 @@ void BarrelVHistoProducerAlgo::layerClusters_to_SimClusters( const std::vector& mask, std::unordered_map const& barrelHitMap, unsigned int layers, - const ticl::RecoToSimCollectionWithSimClusters& scsInLayerClusterMap, - const ticl::SimToRecoCollectionWithSimClusters& lcsInSimClusterMap, + const ticl::RecoToSimCollectionWithSimClustersT& scsInLayerClusterMap, + const ticl::SimToRecoCollectionWithSimClustersT& lcsInSimClusterMap, edm::MultiSpan const& barrelHits) const { // Here fill the plots to compute the different metrics linked to // reco-level, namely fake-rate and merge-rate. In this loop should *not* @@ -1339,8 +1339,8 @@ void BarrelVHistoProducerAlgo::fill_generic_cluster_histos( std::vector const& cPSelectedIndices, std::unordered_map const& barrelHitMap, unsigned int layers, - const ticl::RecoToSimCollection& cpsInLayerClusterMap, - const ticl::SimToRecoCollection& cPOnLayerMap, + const ticl::RecoToSimCollectionT& cpsInLayerClusterMap, + const ticl::SimToRecoCollectionT& cPOnLayerMap, edm::MultiSpan const& barrelHits) const { //To keep track of total num of layer clusters per layer //tnlcpl[layerid] diff --git a/Validation/HGCalValidation/src/HGVHistoProducerAlgo.cc b/Validation/HGCalValidation/src/HGVHistoProducerAlgo.cc index ee5a942b47cad..cf0922149005a 100644 --- a/Validation/HGCalValidation/src/HGVHistoProducerAlgo.cc +++ b/Validation/HGCalValidation/src/HGVHistoProducerAlgo.cc @@ -1579,10 +1579,10 @@ void HGVHistoProducerAlgo::fill_caloparticle_histos(const Histograms& histograms } } -void HGVHistoProducerAlgo::HGVHistoProducerAlgo::fill_simCluster_histos(const Histograms& histograms, - std::vector const& simClusters, - unsigned int layers, - std::vector thicknesses) const { +void HGVHistoProducerAlgo::fill_simCluster_histos(const Histograms& histograms, + std::vector const& simClusters, + unsigned int layers, + std::vector thicknesses) const { //Each event to be treated as two events: an event in +ve endcap, //plus another event in -ve endcap. In this spirit there will be //a layer variable (layerid) that maps the layers in : @@ -1706,7 +1706,7 @@ void HGVHistoProducerAlgo::HGVHistoProducerAlgo::fill_simCluster_histos(const Hi histograms.h_mixedhitssimcluster_zminus->Fill(tnscpthminus["mixed"]); } -void HGVHistoProducerAlgo::HGVHistoProducerAlgo::fill_simClusterAssociation_histos( +void HGVHistoProducerAlgo::fill_simClusterAssociation_histos( const Histograms& histograms, const int count, edm::Handle clusterHandle, @@ -1717,8 +1717,8 @@ void HGVHistoProducerAlgo::HGVHistoProducerAlgo::fill_simClusterAssociation_hist const std::vector& mask, std::unordered_map const& hitMap, unsigned int layers, - const ticl::RecoToSimCollectionWithSimClusters& scsInLayerClusterMap, - const ticl::SimToRecoCollectionWithSimClusters& lcsInSimClusterMap, + const ticl::RecoToSimCollectionWithSimClustersT& scsInLayerClusterMap, + const ticl::SimToRecoCollectionWithSimClustersT& lcsInSimClusterMap, edm::MultiSpan const& hits) const { //Each event to be treated as two events: an event in +ve endcap, //plus another event in -ve endcap. In this spirit there will be @@ -1750,18 +1750,19 @@ void HGVHistoProducerAlgo::fill_cluster_histos(const Histograms& histograms, histograms.h_cluster_eta[count]->Fill(eta); } -void HGVHistoProducerAlgo::layerClusters_to_CaloParticles(const Histograms& histograms, - edm::Handle clusterHandle, - const reco::CaloClusterCollection& clusters, - edm::Handle> caloParticleHandle, - std::vector const& cP, - std::vector const& cPIndices, - std::vector const& cPSelectedIndices, - std::unordered_map const& hitMap, - unsigned int layers, - const ticl::RecoToSimCollection& cpsInLayerClusterMap, - const ticl::SimToRecoCollection& cPOnLayerMap, - edm::MultiSpan const& hits) const { +void HGVHistoProducerAlgo::layerClusters_to_CaloParticles( + const Histograms& histograms, + edm::Handle clusterHandle, + const reco::CaloClusterCollection& clusters, + edm::Handle> caloParticleHandle, + std::vector const& cP, + std::vector const& cPIndices, + std::vector const& cPSelectedIndices, + std::unordered_map const& hitMap, + unsigned int layers, + const ticl::RecoToSimCollectionT& cpsInLayerClusterMap, + const ticl::SimToRecoCollectionT& cPOnLayerMap, + edm::MultiSpan const& hits) const { const auto nLayerClusters = clusters.size(); std::unordered_map> detIdToCaloParticleId_Map; @@ -2032,8 +2033,8 @@ void HGVHistoProducerAlgo::layerClusters_to_SimClusters( const std::vector& mask, std::unordered_map const& hitMap, unsigned int layers, - const ticl::RecoToSimCollectionWithSimClusters& scsInLayerClusterMap, - const ticl::SimToRecoCollectionWithSimClusters& lcsInSimClusterMap, + const ticl::RecoToSimCollectionWithSimClustersT& scsInLayerClusterMap, + const ticl::SimToRecoCollectionWithSimClustersT& lcsInSimClusterMap, edm::MultiSpan const& hits) const { // Here fill the plots to compute the different metrics linked to // reco-level, namely fake-rate and merge-rate. In this loop should *not* @@ -2207,21 +2208,22 @@ void HGVHistoProducerAlgo::layerClusters_to_SimClusters( } } -void HGVHistoProducerAlgo::fill_generic_cluster_histos(const Histograms& histograms, - const int count, - edm::Handle clusterHandle, - const reco::CaloClusterCollection& clusters, - edm::Handle> caloParticleHandle, - std::vector const& cP, - std::vector const& cPIndices, - std::vector const& cPSelectedIndices, - std::unordered_map const& hitMap, - std::map cummatbudg, - unsigned int layers, - std::vector thicknesses, - const ticl::RecoToSimCollection& cpsInLayerClusterMap, - const ticl::SimToRecoCollection& cPOnLayerMap, - edm::MultiSpan const& hits) const { +void HGVHistoProducerAlgo::fill_generic_cluster_histos( + const Histograms& histograms, + const int count, + edm::Handle clusterHandle, + const reco::CaloClusterCollection& clusters, + edm::Handle> caloParticleHandle, + std::vector const& cP, + std::vector const& cPIndices, + std::vector const& cPSelectedIndices, + std::unordered_map const& hitMap, + std::map cummatbudg, + unsigned int layers, + std::vector thicknesses, + const ticl::RecoToSimCollectionT& cpsInLayerClusterMap, + const ticl::SimToRecoCollectionT& cPOnLayerMap, + edm::MultiSpan const& hits) const { //Each event to be treated as two events: an event in +ve endcap, //plus another event in -ve endcap. In this spirit there will be //a layer variable (layerid) that maps the layers in : diff --git a/Validation/RecoMET/plugins/METTester.h b/Validation/RecoMET/plugins/METTester.h index 0889c5b5ffa72..6b0fa2f2e2dea 100644 --- a/Validation/RecoMET/plugins/METTester.h +++ b/Validation/RecoMET/plugins/METTester.h @@ -41,10 +41,10 @@ class METTester : public DQMEDAnalyzer { void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override; static void fillDescriptions(edm::ConfigurationDescriptions &); - static const int mNMETBins = 11; + static constexpr int mNMETBins = 11; static constexpr std::array mMETBins = { {0., 20., 40., 60., 80., 100., 150., 200., 300., 400., 500., 1000.}}; - static const int mNPhiBins = 6; + static constexpr int mNPhiBins = 6; static constexpr std::array mPhiBins = {{-3.15, -2., -1., 0., 1., 2., 3.15}}; static std::string binStr(float left, float right, bool roundInt = true); diff --git a/Validation/RecoMET/plugins/METTesterPostProcessor.cc b/Validation/RecoMET/plugins/METTesterPostProcessor.cc index 1de0d4ce7a4a7..fe3cf982f05cf 100644 --- a/Validation/RecoMET/plugins/METTesterPostProcessor.cc +++ b/Validation/RecoMET/plugins/METTesterPostProcessor.cc @@ -37,6 +37,8 @@ void METTesterPostProcessor::dqmEndJob(DQMStore::IBooker &ibook_, DQMStore::IGet } } +bool METTesterPostProcessor::mCheckHisto(MElem *h) { return h && h->getRootObject(); } + void METTesterPostProcessor::mFillAggrHistograms(std::string metdir, DQMStore::IGetter &iget) { for (std::string bt : {"MET", "Phi"}) { // loop over bin types for (unsigned idx = 0; idx < mNBins[bt]; ++idx) { @@ -46,12 +48,27 @@ void METTesterPostProcessor::mFillAggrHistograms(std::string metdir, DQMStore::I mArrayIdx(mMETDiff_GenMETTrue[bt], idx) = iget.get(metdir + "/METDiff_GenMETTrue_" + bt + edges); mArrayIdx(mMETRatio_GenMETTrue[bt], idx) = iget.get(metdir + "/METRatio_GenMETTrue_" + bt + edges); mArrayIdx(mMETDeltaPhi_GenMETTrue[bt], idx) = iget.get(metdir + "/METDeltaPhi_GenMETTrue_" + bt + edges); + + // check one object, if it exists, then the remaining ME's exists too + // for genmet none of these ME's are filled + if (mCheckHisto(mArrayIdx(mMETDiff_GenMETTrue[bt], 0))) { + // log histograms with zero entries + if (mArrayIdx(mMET[bt], idx)->getEntries() < mEpsilonDouble || + mArrayIdx(mMETDiff_GenMETTrue[bt], idx)->getEntries() < mEpsilonDouble || + mArrayIdx(mMETRatio_GenMETTrue[bt], idx)->getEntries() < mEpsilonDouble || + mArrayIdx(mMETDeltaPhi_GenMETTrue[bt], idx)->getEntries() < mEpsilonDouble) { + LogDebug("METTesterPostProcessor") + << "At least one of the " << bt + edges << " histograms has zero entries:\n" + << " MET: " << mArrayIdx(mMET[bt], idx)->getEntries() << "\n" + << " METDiff: " << mArrayIdx(mMETDiff_GenMETTrue[bt], idx)->getEntries() << "\n" + << " METRatio: " << mArrayIdx(mMETRatio_GenMETTrue[bt], idx)->getEntries() << "\n" + << " METDeltaPhi: " << mArrayIdx(mMETDeltaPhi_GenMETTrue[bt], idx)->getEntries(); + } + } } - // check one object, if it exists, then the remaining ME's exists too - // for genmet none of these ME's are filled - if (mArrayIdx(mMETDiff_GenMETTrue[bt], 0) && - mArrayIdx(mMETDiff_GenMETTrue[bt], 0)->getRootObject()) { + if (mCheckHisto(mArrayIdx(mMETDiff_GenMETTrue[bt], 0))) { + // compute and store MET quantities for (unsigned idx = 0; idx < mNBins[bt]; ++idx) { mMETDiffAggr[bt]->setBinContent(idx + 1, mArrayIdx(mMETDiff_GenMETTrue[bt], idx)->getMean()); mMETDiffAggr[bt]->setBinError(idx + 1, mArrayIdx(mMETDiff_GenMETTrue[bt], idx)->getRMS()); @@ -67,11 +84,13 @@ void METTesterPostProcessor::mFillAggrHistograms(std::string metdir, DQMStore::I mMETResolAggr[bt]->setBinContent(idx + 1, metRMS); mMETResolAggr[bt]->setBinError(idx + 1, resolError); - float significance = metMean / metRMS; + float significance = metRMS < mEpsilonFloat ? 0.f : metMean / metRMS; + float significance_error = metRMS < mEpsilonFloat || metMean < mEpsilonFloat + ? 0.f + : significance * std::sqrt((metRMS * metRMS / (metMean * metMean)) + + (resolError * resolError / (metRMS * metRMS))); mMETSignAggr[bt]->setBinContent(idx + 1, significance); - mMETSignAggr[bt]->setBinError(idx + 1, - significance * std::sqrt((metRMS * metRMS / (metMean * metMean)) + - (resolError * resolError / (metRMS * metRMS)))); + mMETSignAggr[bt]->setBinError(idx + 1, significance_error); } } } diff --git a/Validation/RecoMET/plugins/METTesterPostProcessor.h b/Validation/RecoMET/plugins/METTesterPostProcessor.h index 5ad8367fabc4c..0a2949ffd7330 100644 --- a/Validation/RecoMET/plugins/METTesterPostProcessor.h +++ b/Validation/RecoMET/plugins/METTesterPostProcessor.h @@ -22,9 +22,11 @@ class METTesterPostProcessor : public DQMEDHarvester { void dqmEndJob(DQMStore::IBooker&, DQMStore::IGetter&) override; std::vector met_dirs; + using MElem = MonitorElement; + void mFillAggrHistograms(std::string, DQMStore::IGetter&); + bool mCheckHisto(MElem* h); - using MElem = MonitorElement; template using ArrayVariant = std::variant, std::array>; @@ -59,6 +61,9 @@ class METTesterPostProcessor : public DQMEDHarvester { ElemMap mMETSignAggr; std::string runDir; + + float mEpsilonFloat = std::numeric_limits::epsilon(); + double mEpsilonDouble = std::numeric_limits::epsilon(); }; #endif