Merge pull request #43233 from thesps/scj_multiboard_13_3_0_pre3

L1T Seeded Cone jets update

DataFormats/L1TParticleFlow/interface/gt_datatypes.h

@@ -156,8 +156,8 @@ namespace l1gt {
     }
 
     static const int BITWIDTH = 64;
-    inline ap_uint<BITWIDTH> pack() const {
-      ap_uint<BITWIDTH> ret;
+    inline ap_uint<BITWIDTH> pack_ap() const {
+      ap_uint<BITWIDTH> ret(0);
       unsigned int start = 0;
       pack_into_bits(ret, start, valid);
       pack_into_bits(ret, start, vector_pt);
@@ -166,12 +166,19 @@ namespace l1gt {
       return ret;
     }
 
+    inline uint64_t pack() const {
+      ap_uint<BITWIDTH> x = pack_ap();
+      return (uint64_t)x;
+    }
+
     inline static Sum unpack_ap(const ap_uint<BITWIDTH> &src) {
       Sum ret;
       ret.initFromBits(src);
       return ret;
     }
 
+    inline static Sum unpack(const uint64_t &src) { return unpack_ap(src); }
+
     inline void initFromBits(const ap_uint<BITWIDTH> &src) {
       unsigned int start = 0;
       unpack_from_bits(src, start, valid);
@@ -194,7 +201,7 @@ namespace l1gt {
 
     static const int BITWIDTH = 128;
     inline ap_uint<BITWIDTH> pack_ap() const {
-      ap_uint<BITWIDTH> ret;
+      ap_uint<BITWIDTH> ret(0);
       unsigned int start = 0;
       pack_into_bits(ret, start, valid);
       pack_into_bits(ret, start, v3.pack());
@@ -333,7 +340,7 @@ namespace l1gt {
     }
 
     inline static Photon unpack(const std::array<uint64_t, 2> &src, int parity) {
-      ap_uint<BITWIDTH> bits;
+      ap_uint<BITWIDTH> bits(0);
       if (parity == 0) {
         bits(63, 0) = src[0];
         bits(95, 64) = src[1];

L1Trigger/Configuration/python/L1Trigger_EventContent_cff.py

@@ -197,10 +197,10 @@ def _appendPhase2Digis(obj):
         'keep *_l1tPFClustersFromHGC3DClusters_*_*',
         'keep *_l1tPFTracksFromL1TracksBarrel_*_*',
         'keep *_l1tPFTracksFromL1TracksHGCal_*_*',
-        'keep *_l1tSCPFL1PuppiCorrectedEmulator_*_*',
-        'keep *_l1tSCPFL1PuppiCorrectedEmulatorMHT_*_*',
-        'keep *_l1tSCPFL1PuppiExtendedCorrectedEmulator_*_*',
-        'keep *_l1tSCPFL1PuppiExtendedCorrectedEmulatorMHT_*_*',
+        'keep *_l1tSC4PFL1PuppiCorrectedEmulator_*_*',
+        'keep *_l1tSC4PFL1PuppiCorrectedEmulatorMHT_*_*',
+        'keep *_l1tSC4PFL1PuppiExtendedCorrectedEmulator_*_*',
+        'keep *_l1tSC4PFL1PuppiExtendedCorrectedEmulatorMHT_*_*',
         'keep *_l1tPhase1JetProducer9x9_*_*', 
         'keep *_l1tPhase1JetCalibrator9x9_*_*',
         'keep *_l1tPhase1JetSumsProducer9x9_*_*',

L1Trigger/Phase2L1GT/python/l1tGTProducer_cff.py

@@ -10,10 +10,10 @@
     GMTSaPromptMuons = cms.InputTag("l1tSAMuonsGmt", "promptSAMuons"),
     GMTSaDisplacedMuons = cms.InputTag("l1tSAMuonsGmt", "displacedSAMuons"),
     GMTTkMuons = cms.InputTag("l1tTkMuonsGmtLowPtFix", "l1tTkMuonsGmtLowPtFix"),
-    CL2Jets = cms.InputTag("l1tSCPFL1PuppiCorrectedEmulator"),
+    CL2Jets = cms.InputTag("l1tSC4PFL1PuppiCorrectedEmulator"),
     CL2Electrons = cms.InputTag("l1tLayer2EG", "L1CtTkElectron"),
     CL2Photons = cms.InputTag("l1tLayer2EG", "L1CtTkEm"),
     CL2Taus = cms.InputTag("l1tNNTauProducerPuppi", "L1PFTausNN"),
     CL2EtSum = cms.InputTag("l1tMETPFProducer"),
-    CL2HtSum = cms.InputTag("l1tSCPFL1PuppiCorrectedEmulatorMHT")
+    CL2HtSum = cms.InputTag("l1tSC4PFL1PuppiCorrectedEmulatorMHT")
 )

L1Trigger/Phase2L1ParticleFlow/plugins/L1CTJetFileWriter.cc

@@ -1,4 +1,5 @@
 #include <memory>
+#include <numeric>
 
 // user include files
 #include "FWCore/Framework/interface/Frameworkfwd.h"
@@ -16,6 +17,7 @@
 #include "L1Trigger/DemonstratorTools/interface/utilities.h"
 #include "DataFormats/L1TParticleFlow/interface/PFJet.h"
 #include "DataFormats/L1TParticleFlow/interface/gt_datatypes.h"
+#include "DataFormats/L1Trigger/interface/EtSum.h"
 
 //
 // class declaration
@@ -29,7 +31,8 @@ class L1CTJetFileWriter : public edm::one::EDAnalyzer<edm::one::SharedResources>
 
 private:
   // ----------constants, enums and typedefs ---------
-  unsigned nJets_;
+  std::vector<edm::ParameterSet> collections_;
+
   size_t nFramesPerBX_;
   size_t ctl2BoardTMUX_;
   size_t gapLengthOutput_;
@@ -39,45 +42,84 @@ class L1CTJetFileWriter : public edm::one::EDAnalyzer<edm::one::SharedResources>
   // ----------member functions ----------------------
   void analyze(const edm::Event&, const edm::EventSetup&) override;
   void endJob() override;
-  std::vector<ap_uint<64>> encodeJets(const std::vector<l1t::PFJet> jets);
+  std::vector<ap_uint<64>> encodeJets(const std::vector<l1t::PFJet> jets, unsigned nJets);
+  std::vector<ap_uint<64>> encodeSums(const std::vector<l1t::EtSum> sums, unsigned nSums);
 
-  edm::EDGetTokenT<edm::View<l1t::PFJet>> jetsToken_;
   l1t::demo::BoardDataWriter fileWriterOutputToGT_;
+  std::vector<std::pair<edm::EDGetTokenT<edm::View<l1t::PFJet>>, edm::EDGetTokenT<edm::View<l1t::EtSum>>>> tokens_;
+  std::vector<std::pair<bool, bool>> tokensToWrite_;
+  std::vector<unsigned> nJets_;
+  std::vector<unsigned> nSums_;
 };
 
 L1CTJetFileWriter::L1CTJetFileWriter(const edm::ParameterSet& iConfig)
-    : nJets_(iConfig.getParameter<unsigned>("nJets")),
+    : collections_(iConfig.getParameter<std::vector<edm::ParameterSet>>("collections")),
       nFramesPerBX_(iConfig.getParameter<unsigned>("nFramesPerBX")),
       ctl2BoardTMUX_(iConfig.getParameter<unsigned>("TMUX")),
-      gapLengthOutput_(ctl2BoardTMUX_ * nFramesPerBX_ - 2 * nJets_),
+      gapLengthOutput_(iConfig.getParameter<unsigned>("gapLengthOutput")),
       maxLinesPerFile_(iConfig.getParameter<unsigned>("maxLinesPerFile")),
       channelSpecsOutputToGT_{{{"jets", 0}, {{ctl2BoardTMUX_, gapLengthOutput_}, {0}}}},
-      jetsToken_(consumes<edm::View<l1t::PFJet>>(iConfig.getParameter<edm::InputTag>("jets"))),
       fileWriterOutputToGT_(l1t::demo::parseFileFormat(iConfig.getParameter<std::string>("format")),
                             iConfig.getParameter<std::string>("outputFilename"),
                             iConfig.getParameter<std::string>("outputFileExtension"),
                             nFramesPerBX_,
                             ctl2BoardTMUX_,
                             maxLinesPerFile_,
-                            channelSpecsOutputToGT_) {}
+                            channelSpecsOutputToGT_) {
+  for (const auto& pset : collections_) {
+    edm::EDGetTokenT<edm::View<l1t::PFJet>> jetToken;
+    edm::EDGetTokenT<edm::View<l1t::EtSum>> mhtToken;
+    unsigned nJets = pset.getParameter<unsigned>("nJets");
+    unsigned nSums = pset.getParameter<unsigned>("nSums");
+    nJets_.push_back(nJets);
+    nSums_.push_back(nSums);
+    bool writeJetToken(false), writeMhtToken(false);
+    if (nJets > 0) {
+      jetToken = consumes<edm::View<l1t::PFJet>>(pset.getParameter<edm::InputTag>("jets"));
+      writeJetToken = true;
+    }
+    if (nSums > 0) {
+      mhtToken = consumes<edm::View<l1t::EtSum>>(pset.getParameter<edm::InputTag>("mht"));
+      writeMhtToken = true;
+    }
+    tokens_.emplace_back(jetToken, mhtToken);
+    tokensToWrite_.emplace_back(writeJetToken, writeMhtToken);
+  }
+}
 
 void L1CTJetFileWriter::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
   using namespace edm;
 
-  // 1) Encode jet information onto vectors containing link data
-  // TODO remove the sort here and sort the input collection where it's created
-  const edm::View<l1t::PFJet>& jets = iEvent.get(jetsToken_);
-  std::vector<l1t::PFJet> sortedJets;
-  sortedJets.reserve(jets.size());
-  std::copy(jets.begin(), jets.end(), std::back_inserter(sortedJets));
-
-  std::stable_sort(
-      sortedJets.begin(), sortedJets.end(), [](l1t::PFJet i, l1t::PFJet j) { return (i.hwPt() > j.hwPt()); });
-  const auto outputJets(encodeJets(sortedJets));
+  // 1) Pack collections in the order they're specified. jets then sums within collection
+  std::vector<ap_uint<64>> link_words;
+  for (unsigned iCollection = 0; iCollection < collections_.size(); iCollection++) {
+    if (tokensToWrite_.at(iCollection).first) {
+      const auto& jetToken = tokens_.at(iCollection).first;
+      // 2) Encode jet information onto vectors containing link data
+      const edm::View<l1t::PFJet>& jets = iEvent.get(jetToken);
+      std::vector<l1t::PFJet> sortedJets;
+      sortedJets.reserve(jets.size());
+      std::copy(jets.begin(), jets.end(), std::back_inserter(sortedJets));
+
+      std::stable_sort(
+          sortedJets.begin(), sortedJets.end(), [](l1t::PFJet i, l1t::PFJet j) { return (i.hwPt() > j.hwPt()); });
+      const auto outputJets(encodeJets(sortedJets, nJets_.at(iCollection)));
+      link_words.insert(link_words.end(), outputJets.begin(), outputJets.end());
+    }
 
-  // 2) Pack jet information into 'event data' object, and pass that to file writer
+    if (tokensToWrite_.at(iCollection).second) {
+      // 3) Encode sums onto vectors containing link data
+      const auto& mhtToken = tokens_.at(iCollection).second;
+      const edm::View<l1t::EtSum>& mht = iEvent.get(mhtToken);
+      std::vector<l1t::EtSum> orderedSums;
+      std::copy(mht.begin(), mht.end(), std::back_inserter(orderedSums));
+      const auto outputSums(encodeSums(orderedSums, nSums_.at(iCollection)));
+      link_words.insert(link_words.end(), outputSums.begin(), outputSums.end());
+    }
+  }
+  // 4) Pack jet information into 'event data' object, and pass that to file writer
   l1t::demo::EventData eventDataJets;
-  eventDataJets.add({"jets", 0}, outputJets);
+  eventDataJets.add({"jets", 0}, link_words);
   fileWriterOutputToGT_.addEvent(eventDataJets);
 }
 
@@ -87,31 +129,51 @@ void L1CTJetFileWriter::endJob() {
   fileWriterOutputToGT_.flush();
 }
 
-std::vector<ap_uint<64>> L1CTJetFileWriter::encodeJets(const std::vector<l1t::PFJet> jets) {
-  std::vector<ap_uint<64>> jet_words;
-  for (unsigned i = 0; i < nJets_; i++) {
-    l1t::PFJet j;
-    if (i < jets.size()) {
-      j = jets.at(i);
-    } else {  // pad up to nJets_ with null jets
-      l1t::PFJet j(0, 0, 0, 0, 0, 0);
-    }
-    jet_words.push_back(j.encodedJet()[0]);
-    jet_words.push_back(j.encodedJet()[1]);
+std::vector<ap_uint<64>> L1CTJetFileWriter::encodeJets(const std::vector<l1t::PFJet> jets, const unsigned nJets) {
+  // Encode up to nJets jets, padded with 0s
+  std::vector<ap_uint<64>> jet_words(2 * nJets, 0);  // allocate 2 words per jet
+  for (unsigned i = 0; i < std::min(nJets, (uint)jets.size()); i++) {
+    const l1t::PFJet& j = jets.at(i);
+    jet_words[2 * i] = j.encodedJet()[0];
+    jet_words[2 * i + 1] = j.encodedJet()[1];
   }
   return jet_words;
 }
 
+std::vector<ap_uint<64>> L1CTJetFileWriter::encodeSums(const std::vector<l1t::EtSum> sums, unsigned nSums) {
+  // Need two l1t::EtSum for each GT Sum
+  std::vector<ap_uint<64>> sum_words;
+  for (unsigned i = 0; i < nSums; i++) {
+    if (2 * i < sums.size()) {
+      l1gt::Sum gtSum;
+      gtSum.valid = 1;  // if the sums are sent at all, they are valid
+      gtSum.vector_pt.V = sums.at(2 * i + 1).hwPt();
+      gtSum.vector_phi.V = sums.at(2 * i + 1).hwPhi();
+      gtSum.scalar_pt.V = sums.at(2 * i).hwPt();
+      sum_words.push_back(gtSum.pack_ap());
+    } else {
+      sum_words.push_back(0);
+    }
+  }
+  return sum_words;
+}
+
 // ------------ method fills 'descriptions' with the allowed parameters for the module  ------------
 void L1CTJetFileWriter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
-  //The following says we do not know what parameters are allowed so do no validation
-  // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
-  desc.add<edm::InputTag>("jets");
+  {
+    edm::ParameterSetDescription vpsd1;
+    vpsd1.addOptional<edm::InputTag>("jets");
+    vpsd1.addOptional<edm::InputTag>("mht");
+    vpsd1.add<uint>("nJets", 0);
+    vpsd1.add<uint>("nSums", 0);
+    desc.addVPSet("collections", vpsd1);
+  }
   desc.add<std::string>("outputFilename");
   desc.add<std::string>("outputFileExtension", "txt");
   desc.add<uint32_t>("nJets", 12);
   desc.add<uint32_t>("nFramesPerBX", 9);
+  desc.add<uint32_t>("gapLengthOutput", 4);
   desc.add<uint32_t>("TMUX", 6);
   desc.add<uint32_t>("maxLinesPerFile", 1024);
   desc.add<std::string>("format", "EMPv2");

L1Trigger/Phase2L1ParticleFlow/plugins/L1MHtPFProducer.cc

@@ -43,16 +43,16 @@ void L1MhtPfProducer::produce(edm::StreamID, edm::Event& iEvent, const edm::Even
   // Get the jets from the event
   l1t::PFJetCollection edmJets = iEvent.get(jetsToken);
 
+  std::vector<l1ct::Jet> hwJets = convertEDMToHW(edmJets);  // convert to the emulator format
   // Apply pT and eta selections
-  l1t::PFJetCollection edmJetsFiltered;
-  std::copy_if(edmJets.begin(), edmJets.end(), std::back_inserter(edmJetsFiltered), [&](auto jet) {
-    return jet.pt() > minJetPt && std::abs(jet.eta()) < maxJetEta;
+  std::vector<l1ct::Jet> hwJetsFiltered;
+  std::copy_if(hwJets.begin(), hwJets.end(), std::back_inserter(hwJetsFiltered), [&](auto jet) {
+    return jet.hwPt > l1ct::Scales::makePtFromFloat(minJetPt) &&
+           std::abs(jet.hwEta) < l1ct::Scales::makeGlbEta(maxJetEta);
   });
 
-  // Run the emulation
-  std::vector<l1ct::Jet> hwJets = convertEDMToHW(edmJetsFiltered);  // convert to the emulator format
-  l1ct::Sum hwSums = htmht(hwJets);                                 // call the emulator
-  std::vector<l1t::EtSum> edmSums = convertHWToEDM(hwSums);         // convert back to edm format
+  l1ct::Sum hwSums = htmht(hwJetsFiltered);                  // call the emulator
+  std::vector<l1t::EtSum> edmSums = convertHWToEDM(hwSums);  // convert back to edm format
 
   // Put the sums in the event
   std::unique_ptr<std::vector<l1t::EtSum>> mhtCollection(new std::vector<l1t::EtSum>(0));

L1Trigger/Phase2L1ParticleFlow/python/L1BJetProducer_cff.py

@@ -4,15 +4,15 @@
 
 from L1Trigger.Phase2L1ParticleFlow.L1BJetProducer_cfi import  L1BJetProducer
 l1tBJetProducerPuppi = L1BJetProducer.clone(
-    jets = ("l1tSCPFL1PuppiExtended", ""),
+    jets = ("l1tSC4PFL1PuppiExtended", ""),
     maxJets = 6,
     minPt = 10,
     vtx = ("l1tVertexFinderEmulator","L1VerticesEmulation")
 )
 
 
 l1tBJetProducerPuppiCorrectedEmulator = l1tBJetProducerPuppi.clone(
-    jets = ("l1tSCPFL1PuppiExtendedCorrectedEmulator", "")
+    jets = ("l1tSC4PFL1PuppiExtendedCorrectedEmulator", "")
 )
 
 L1TBJetsTask = cms.Task(

L1Trigger/Phase2L1ParticleFlow/python/l1pfJetMet_cff.py

@@ -3,13 +3,20 @@
 from L1Trigger.Phase2L1ParticleFlow.l1SeedConePFJetProducer_cfi import l1SeedConePFJetProducer 
 from L1Trigger.Phase2L1ParticleFlow.l1SeedConePFJetEmulatorProducer_cfi import l1SeedConePFJetEmulatorProducer
 from L1Trigger.Phase2L1ParticleFlow.l1tDeregionizerProducer_cfi import l1tDeregionizerProducer as l1tLayer2Deregionizer, l1tDeregionizerProducerExtended as l1tLayer2DeregionizerExtended
-l1tSCPFL1PF            = l1SeedConePFJetProducer.clone(L1PFObjects = 'l1tLayer1:PF')
-l1tSCPFL1Puppi         = l1SeedConePFJetProducer.clone()
-l1tSCPFL1PuppiEmulator = l1SeedConePFJetEmulatorProducer.clone(L1PFObjects = 'l1tLayer2Deregionizer:Puppi')
-l1tSCPFL1PuppiCorrectedEmulator = l1SeedConePFJetEmulatorProducer.clone(L1PFObjects = 'l1tLayer2Deregionizer:Puppi',
-                                                                     doCorrections = True,
-                                                                     correctorFile = "L1Trigger/Phase2L1ParticleFlow/data/jecs/jecs_20220308.root",
-                                                                     correctorDir = "L1PuppiSC4EmuJets")
+l1tSC4PFL1PF            = l1SeedConePFJetProducer.clone(L1PFObjects = 'l1tLayer1:PF')
+l1tSC4PFL1Puppi         = l1SeedConePFJetProducer.clone()
+l1tSC4PFL1PuppiEmulator = l1SeedConePFJetEmulatorProducer.clone(L1PFObjects = 'l1tLayer2Deregionizer:Puppi')
+l1tSC8PFL1PuppiEmulator = l1SeedConePFJetEmulatorProducer.clone(L1PFObjects = 'l1tLayer2Deregionizer:Puppi',
+                                                                 coneSize = cms.double(0.8))
+l1tSC4PFL1PuppiCorrectedEmulator = l1SeedConePFJetEmulatorProducer.clone(L1PFObjects = 'l1tLayer2Deregionizer:Puppi',
+                                                                          doCorrections = cms.bool(True),
+                                                                          correctorFile = cms.string("L1Trigger/Phase2L1ParticleFlow/data/jecs/jecs_20220308.root"),
+                                                                          correctorDir = cms.string('L1PuppiSC4EmuJets'))
+l1tSC8PFL1PuppiCorrectedEmulator = l1SeedConePFJetEmulatorProducer.clone(L1PFObjects = 'l1tLayer2Deregionizer:Puppi',
+                                                                          coneSize = cms.double(0.8),
+                                                                          doCorrections = cms.bool(True),
+                                                                          correctorFile = cms.string("L1Trigger/Phase2L1ParticleFlow/data/jecs/jecs_20220308.root"),
+                                                                          correctorDir = cms.string('L1PuppiSC4EmuJets'))
 
 _correctedJets = cms.EDProducer("L1TCorrectedPFJetProducer", 
     jets = cms.InputTag("_tag_"),
@@ -26,28 +33,25 @@
 phase2_hgcalV11.toModify(_correctedJets, correctorFile = "L1Trigger/Phase2L1ParticleFlow/data/jecs/jecs_20220308.root")
 
 from L1Trigger.Phase2L1ParticleFlow.l1tMHTPFProducer_cfi import l1tMHTPFProducer
-l1tSCPFL1PuppiCorrectedEmulatorMHT = l1tMHTPFProducer.clone(jets = 'l1tSCPFL1PuppiCorrectedEmulator')
+l1tSC4PFL1PuppiCorrectedEmulatorMHT = l1tMHTPFProducer.clone(jets = 'l1tSC4PFL1PuppiCorrectedEmulator')
 
-L1TPFJetsTask = cms.Task(
-    l1tLayer2Deregionizer, l1tSCPFL1PF, l1tSCPFL1Puppi, l1tSCPFL1PuppiEmulator, l1tSCPFL1PuppiCorrectedEmulator, l1tSCPFL1PuppiCorrectedEmulatorMHT
-)
-
-l1tSCPFL1PuppiExtended         = l1SeedConePFJetProducer.clone(L1PFObjects = 'l1tLayer1Extended:Puppi')
-l1tSCPFL1PuppiExtendedEmulator = l1SeedConePFJetEmulatorProducer.clone(L1PFObjects = 'l1tLayer2DeregionizerExtended:Puppi')
-l1tSCPFL1PuppiExtendedCorrectedEmulator = l1SeedConePFJetEmulatorProducer.clone(L1PFObjects = 'l1tLayer2DeregionizerExtended:Puppi',
-                                                                     doCorrections = True,
-                                                                     correctorFile = "L1Trigger/Phase2L1ParticleFlow/data/jecs/jecs_20220308.root",
-                                                                     correctorDir = "L1PuppiSC4EmuJets")
+l1tSC4PFL1PuppiExtended         = l1SeedConePFJetProducer.clone(L1PFObjects = 'l1tLayer1Extended:Puppi')
+l1tSC4PFL1PuppiExtendedEmulator = l1SeedConePFJetEmulatorProducer.clone(L1PFObjects = 'l1tLayer2DeregionizerExtended:Puppi')
+l1tSC4PFL1PuppiExtendedCorrectedEmulator = l1SeedConePFJetEmulatorProducer.clone(L1PFObjects = 'l1tLayer2DeregionizerExtended:Puppi',
+                                                                     doCorrections = cms.bool(True),
+                                                                     correctorFile = cms.string("L1Trigger/Phase2L1ParticleFlow/data/jecs/jecs_20220308.root"),
+                                                                     correctorDir = cms.string('L1PuppiSC4EmuJets'))
 
 L1TPFJetsTask = cms.Task(
-    l1tLayer2Deregionizer, l1tSCPFL1PF, l1tSCPFL1Puppi, l1tSCPFL1PuppiEmulator, l1tSCPFL1PuppiCorrectedEmulator, l1tSCPFL1PuppiCorrectedEmulatorMHT
+    l1tLayer2Deregionizer, l1tSC4PFL1PF, l1tSC4PFL1Puppi, l1tSC4PFL1PuppiEmulator, l1tSC4PFL1PuppiCorrectedEmulator, l1tSC4PFL1PuppiCorrectedEmulatorMHT,
+    l1tSC8PFL1PuppiEmulator, l1tSC8PFL1PuppiCorrectedEmulator
 )
 
 L1TPFJetsExtendedTask = cms.Task(
-    l1tLayer2DeregionizerExtended, l1tSCPFL1PuppiExtended, l1tSCPFL1PuppiExtendedEmulator, l1tSCPFL1PuppiExtendedCorrectedEmulator
+    l1tLayer2DeregionizerExtended, l1tSC4PFL1PuppiExtended, l1tSC4PFL1PuppiExtendedEmulator, l1tSC4PFL1PuppiExtendedCorrectedEmulator
 )
 
 L1TPFJetsEmulationTask = cms.Task(
-    l1tLayer2Deregionizer, l1tSCPFL1PuppiEmulator, l1tSCPFL1PuppiCorrectedEmulator, l1tSCPFL1PuppiCorrectedEmulatorMHT
+    l1tLayer2Deregionizer, l1tSC4PFL1PuppiEmulator, l1tSC4PFL1PuppiCorrectedEmulator, l1tSC4PFL1PuppiCorrectedEmulatorMHT,
+    l1tSC8PFL1PuppiEmulator, l1tSC8PFL1PuppiCorrectedEmulator
 )
-