#include <L1Trigger/L1TCaloLayer1/plugins/L1TCaloLayer1.cc>

Inheritance diagram for L1TCaloLayer1:

Public Member Functions
	L1TCaloLayer1 (const edm::ParameterSet &)

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
void	beginRun (edm::Run const &, edm::EventSetup const &) override

void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
std::vector< std::array < std::array< std::array < uint32_t, nEtBins > , nCalSideBins >, nCalEtaBins > >	ecalLUT

edm::EDGetTokenT < EcalTrigPrimDigiCollection >	ecalTPSource

std::vector< unsigned int >	ePhiMap

int	fwVersion

std::vector< std::array < std::array< std::array < uint32_t, nEtBins > , nCalSideBins >, nCalEtaBins > >	hcalLUT

edm::EDGetTokenT < HcalTrigPrimDigiCollection >	hcalTPSource

std::vector< std::array < std::array< uint32_t, nEtBins >, nHfEtaBins > >	hfLUT

std::vector< unsigned int >	hfPhiMap

std::vector< unsigned int >	hPhiMap

std::unique_ptr< UCTLayer1 >	layer1

const L1TCaloLayer1FetchLUTsTokens	lutsTokens

edm::EDPutTokenT < L1CaloRegionCollection >	regionPutToken

edm::EDPutTokenT < CaloTowerBxCollection >	towerPutToken

std::vector< UCTTower * >	twrList

bool	unpackEcalMask

bool	unpackHcalMask

bool	useCalib

bool	useECALLUT

bool	useHCALLUT

bool	useHFLUT

bool	useLSB

bool	verbose

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 58 of file L1TCaloLayer1.cc.

Constructor & Destructor Documentation

L1TCaloLayer1::L1TCaloLayer1 ( const edm::ParameterSet & iConfig )

explicit

Definition at line 115 of file L1TCaloLayer1.cc.

References a, b, ePhiMap, fwVersion, edm::ParameterSet::getParameter(), hfPhiMap, hPhiMap, layer1, lutsTokens, regionPutToken, HLT_FULL_cff::towers, twrList, unpackEcalMask, unpackHcalMask, useCalib, useECALLUT, useHCALLUT, useHFLUT, useLSB, and verbose.

     : ecalTPSource(consumes<EcalTrigPrimDigiCollection>(iConfig.getParameter<edm::InputTag>("ecalToken"))),
       hcalTPSource(consumes<HcalTrigPrimDigiCollection>(iConfig.getParameter<edm::InputTag>("hcalToken"))),
       towerPutToken{produces<CaloTowerBxCollection>()},
       regionPutToken{produces<L1CaloRegionCollection>()},
       lutsTokens{esConsumes<edm::Transition::BeginRun>(),
                  esConsumes<edm::Transition::BeginRun>(),
                  esConsumes<edm::Transition::BeginRun>()},
       ePhiMap(72 * 2, 0),
       hPhiMap(72 * 2, 0),
       hfPhiMap(72 * 2, 0),
       useLSB(iConfig.getParameter<bool>("useLSB")),
       useCalib(iConfig.getParameter<bool>("useCalib")),
       useECALLUT(iConfig.getParameter<bool>("useECALLUT")),
       useHCALLUT(iConfig.getParameter<bool>("useHCALLUT")),
       useHFLUT(iConfig.getParameter<bool>("useHFLUT")),
       verbose(iConfig.getParameter<bool>("verbose")),
       unpackHcalMask(iConfig.getParameter<bool>("unpackHcalMask")),
       unpackEcalMask(iConfig.getParameter<bool>("unpackEcalMask")),
       fwVersion(iConfig.getParameter<int>("firmwareVersion")) {
   // See UCTLayer1.hh for firmware version definitions
   layer1 = std::make_unique<UCTLayer1>(fwVersion);
 
   vector<UCTCrate*> crates = layer1->getCrates();
   for (uint32_t crt = 0; crt < crates.size(); crt++) {
     vector<UCTCard*> cards = crates[crt]->getCards();
     for (uint32_t crd = 0; crd < cards.size(); crd++) {
       vector<UCTRegion*> regions = cards[crd]->getRegions();
       for (uint32_t rgn = 0; rgn < regions.size(); rgn++) {
         vector<UCTTower*> towers = regions[rgn]->getTowers();
         for (uint32_t twr = 0; twr < towers.size(); twr++) {
           twrList.push_back(towers[twr]);
         }
       }
     }
   }
 
   // This sort corresponds to the sort condition on
   // the output CaloTowerBxCollection
   std::sort(twrList.begin(), twrList.end(), [](UCTTower* a, UCTTower* b) {
     return CaloTools::caloTowerHash(a->caloEta(), a->caloPhi()) < CaloTools::caloTowerHash(b->caloEta(), b->caloPhi());
   });
 }

Member Function Documentation

void L1TCaloLayer1::beginRun	(	edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overrideprivate

Definition at line 294 of file L1TCaloLayer1.cc.

References ecalLUT, ePhiMap, fwVersion, hcalLUT, hfLUT, hfPhiMap, hPhiMap, L1TCaloLayer1FetchLUTs(), LOG_ERROR, lutsTokens, twrList, useCalib, useECALLUT, useHCALLUT, useHFLUT, and useLSB.

                                                                             {
   if (!L1TCaloLayer1FetchLUTs(lutsTokens,
                               iSetup,
                               ecalLUT,
                               hcalLUT,
                               hfLUT,
                               ePhiMap,
                               hPhiMap,
                               hfPhiMap,
                               useLSB,
                               useCalib,
                               useECALLUT,
                               useHCALLUT,
                               useHFLUT,
                               fwVersion)) {
     LOG_ERROR << "L1TCaloLayer1::beginRun: failed to fetch LUTS - using unity" << std::endl;
     std::array<std::array<std::array<uint32_t, nEtBins>, nCalSideBins>, nCalEtaBins> eCalLayer1EtaSideEtArray;
     std::array<std::array<std::array<uint32_t, nEtBins>, nCalSideBins>, nCalEtaBins> hCalLayer1EtaSideEtArray;
     std::array<std::array<uint32_t, nEtBins>, nHfEtaBins> hfLayer1EtaEtArray;
     ecalLUT.push_back(eCalLayer1EtaSideEtArray);
     hcalLUT.push_back(hCalLayer1EtaSideEtArray);
     hfLUT.push_back(hfLayer1EtaEtArray);
   }
   for (uint32_t twr = 0; twr < twrList.size(); twr++) {
     // Map goes minus 1 .. 72 plus 1 .. 72 -> 0 .. 143
     int iphi = twrList[twr]->caloPhi();
     int ieta = twrList[twr]->caloEta();
     if (ieta < 0) {
       iphi -= 1;
     } else {
       iphi += 71;
     }
     twrList[twr]->setECALLUT(&ecalLUT[ePhiMap[iphi]]);
     twrList[twr]->setHCALLUT(&hcalLUT[hPhiMap[iphi]]);
     twrList[twr]->setHFLUT(&hfLUT[hfPhiMap[iphi]]);
   }
 }

void L1TCaloLayer1::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 357 of file L1TCaloLayer1.cc.

References edm::ConfigurationDescriptions::addDefault(), submitPVResolutionJobs::desc, and edm::ParameterSetDescription::setUnknown().

                                                                                {
   //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.setUnknown();
   descriptions.addDefault(desc);
 }

void L1TCaloLayer1::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 164 of file L1TCaloLayer1.cc.

References funct::abs(), ecalTPSource, edm::Event::emplace(), g, edm::Event::getByToken(), hcalTPSource, layer1, LOG_ERROR, eostools::move(), HLT_FULL_cff::region, regionPutToken, l1t::L1Candidate::setHwEta(), l1t::CaloTower::setHwEtEm(), l1t::CaloTower::setHwEtHad(), l1t::CaloTower::setHwEtRatio(), l1t::L1Candidate::setHwPhi(), l1t::L1Candidate::setHwPt(), l1t::L1Candidate::setHwQual(), submitPVValidationJobs::t, towerPutToken, twrList, unpackEcalMask, and unpackHcalMask.

                                                                          {
   using namespace edm;
 
   edm::Handle<EcalTrigPrimDigiCollection> ecalTPs;
   iEvent.getByToken(ecalTPSource, ecalTPs);
   edm::Handle<HcalTrigPrimDigiCollection> hcalTPs;
   iEvent.getByToken(hcalTPSource, hcalTPs);
 
   CaloTowerBxCollection towersColl;
   L1CaloRegionCollection rgnCollection;
 
   uint32_t expectedTotalET = 0;
   if (!layer1->clearEvent()) {
     LOG_ERROR << "UCT: Failed to clear event" << std::endl;
     return;
   }
 
   for (const auto& ecalTp : *ecalTPs) {
     if (unpackEcalMask && ((ecalTp.sample(0).raw() >> 13) & 0x1))
       continue;
     int caloEta = ecalTp.id().ieta();
     int caloPhi = ecalTp.id().iphi();
     int et = ecalTp.compressedEt();
     bool fgVeto = ecalTp.fineGrain();
     UCTTowerIndex t = UCTTowerIndex(caloEta, caloPhi);
     if (!layer1->setECALData(t, fgVeto, et)) {
       LOG_ERROR << "UCT: Failed loading an ECAL tower" << std::endl;
       return;
     }
     expectedTotalET += et;
   }
 
   if (hcalTPs.isValid()) {
     for (const auto& hcalTp : *hcalTPs) {
       if (unpackHcalMask && ((hcalTp.sample(0).raw() >> 13) & 0x1))
         continue;
       int caloEta = hcalTp.id().ieta();
       uint32_t absCaloEta = std::abs(caloEta);
       // Tower 29 is not used by Layer-1
       if (absCaloEta == 29) {
         continue;
       }
       // Prevent usage of HF TPs with Layer-1 emulator if HCAL TPs are old style
       else if (hcalTp.id().version() == 0 && absCaloEta > 29) {
         continue;
       } else if (absCaloEta <= 41) {
         int caloPhi = hcalTp.id().iphi();
         int et = hcalTp.SOI_compressedEt();
         bool fg = hcalTp.t0().fineGrain(0);   // depth
         bool fg2 = hcalTp.t0().fineGrain(1);  // prompt
         bool fg3 = hcalTp.t0().fineGrain(2);  // delay 1
         bool fg4 = hcalTp.t0().fineGrain(3);  // delay 2
         // note that hcalTp.t0().fineGrain(4) and hcalTp.t0().fineGrain(5) are the reserved MIP bits (not used for LLP logic)
         if (caloPhi <= 72) {
           UCTTowerIndex t = UCTTowerIndex(caloEta, caloPhi);
           uint32_t featureBits = 0;
           if (absCaloEta > 29) {
             if (fg)
               featureBits |= 0b01;
             // fg2 should only be set for HF
             if (fg2)
               featureBits |= 0b10;
           } else
             featureBits |= (fg | ((!fg2) & (fg3 | fg4)));  // depth | (!prompt & (delay1 | delay2))
           if (!layer1->setHCALData(t, featureBits, et)) {
             LOG_ERROR << "caloEta = " << caloEta << "; caloPhi =" << caloPhi << std::endl;
             LOG_ERROR << "UCT: Failed loading an HCAL tower" << std::endl;
             return;
           }
           expectedTotalET += et;
         } else {
           LOG_ERROR << "Illegal Tower: caloEta = " << caloEta << "; caloPhi =" << caloPhi << "; et = " << et
                     << std::endl;
         }
       } else {
         LOG_ERROR << "Illegal Tower: caloEta = " << caloEta << std::endl;
       }
     }
   }
 
   //Process
   if (!layer1->process()) {
     LOG_ERROR << "UCT: Failed to process layer 1" << std::endl;
   }
 
   int theBX = 0;  // Currently we only read and process the "hit" BX only
 
   for (uint32_t twr = 0; twr < twrList.size(); twr++) {
     CaloTower caloTower;
     caloTower.setHwPt(twrList[twr]->et());          // Bits 0-8 of the 16-bit word per the interface protocol document
     caloTower.setHwEtRatio(twrList[twr]->er());     // Bits 9-11 of the 16-bit word per the interface protocol document
     caloTower.setHwQual(twrList[twr]->miscBits());  // Bits 12-15 of the 16-bit word per the interface protocol document
     caloTower.setHwEta(twrList[twr]->caloEta());    // caloEta = 1-28 and 30-41
     caloTower.setHwPhi(twrList[twr]->caloPhi());    // caloPhi = 1-72
     caloTower.setHwEtEm(twrList[twr]->getEcalET());   // This is provided as a courtesy - not available to hardware
     caloTower.setHwEtHad(twrList[twr]->getHcalET());  // This is provided as a courtesy - not available to hardware
     towersColl.push_back(theBX, caloTower);
   }
 
   iEvent.emplace(towerPutToken, std::move(towersColl));
 
   UCTGeometry g;
   vector<UCTCrate*> crates = layer1->getCrates();
   for (uint32_t crt = 0; crt < crates.size(); crt++) {
     vector<UCTCard*> cards = crates[crt]->getCards();
     for (uint32_t crd = 0; crd < cards.size(); crd++) {
       vector<UCTRegion*> regions = cards[crd]->getRegions();
       for (uint32_t rgn = 0; rgn < regions.size(); rgn++) {
         uint32_t rawData = regions[rgn]->rawData();
         uint32_t regionData = rawData & 0x0000FFFF;
         uint32_t crate = regions[rgn]->getCrate();
         uint32_t card = regions[rgn]->getCard();
         uint32_t region = regions[rgn]->getRegion();
         bool negativeEta = regions[rgn]->isNegativeEta();
         uint32_t rPhi = g.getUCTRegionPhiIndex(crate, card);
         if (region < NRegionsInCard) {  // We only store the Barrel and Endcap - HF has changed in the upgrade
           uint32_t rEta =
               10 -
               region;  // UCT region is 0-6 for B/E but GCT eta goes 0-21, 0-3 -HF, 4-10 -B/E, 11-17 +B/E, 18-21 +HF
           if (!negativeEta)
             rEta = 11 + region;  // Positive eta portion is offset by 11
           rgnCollection.push_back(L1CaloRegion((uint16_t)regionData, (unsigned)rEta, (unsigned)rPhi, (int16_t)0));
         }
       }
     }
   }
   iEvent.emplace(regionPutToken, std::move(rgnCollection));
 }