#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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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

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<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	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 114 of file L1TCaloLayer1.cc.

References a, b, ePhiMap, fwVersion, hfPhiMap, hPhiMap, layer1, regionPutToken, HLT_2018_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>()},
       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 &	,
		edm::EventSetup const &
	)

overrideprivate

Definition at line 284 of file L1TCaloLayer1.cc.

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

                                                                             {
   if (!L1TCaloLayer1FetchLUTs(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 346 of file L1TCaloLayer1.cc.

References edm::ConfigurationDescriptions::addDefault(), DEFINE_FWK_MODULE, 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 160 of file L1TCaloLayer1.cc.

References funct::abs(), ecalTPSource, edm::Event::emplace(), EgHLTOffHistBins_cfi::et, g, edm::Event::getByToken(), hcalTPSource, edm::HandleBase::isValid(), layer1, LOG_ERROR, eostools::move(), BXVector< T >::push_back(), l1tstage2_dqm_sourceclient-live_cfg::rawData, HLT_2018_cff::region, regionPutToken, l1t::L1Candidate::setHwEta(), l1t::CaloTower::setHwEtEm(), l1t::CaloTower::setHwEtHad(), l1t::CaloTower::setHwEtRatio(), l1t::L1Candidate::setHwPhi(), l1t::L1Candidate::setHwPt(), l1t::L1Candidate::setHwQual(), OrderedSet::t, towerPutToken, twrList, unpackEcalMask, unpackHcalMask, and testProducerWithPsetDescEmpty_cfi::x1.

                                                                          {
   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);
         bool fg2 = hcalTp.t0().fineGrain(1);
         if (caloPhi <= 72) {
           UCTTowerIndex t = UCTTowerIndex(caloEta, caloPhi);
           uint32_t featureBits = 0;
           if (fg)
             featureBits |= 0b01;
           // fg2 should only be set for HF
           if (absCaloEta > 29 && fg2)
             featureBits |= 0b10;
           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));
 }