#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	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () 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 59 of file L1TCaloLayer1.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 118 of file L1TCaloLayer1.cc.

References a, b, ePhiMap, fwVersion, hfPhiMap, hPhiMap, layer1, regionPutToken, 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 292 of file L1TCaloLayer1.cc.

References ecalLUT, ePhiMap, fwVersion, hcalLUT, hfLUT, hfPhiMap, hPhiMap, 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 167 of file L1TCaloLayer1.cc.

References funct::abs(), ecalTPSource, edm::Event::emplace(), stringResolutionProvider_cfi::et, g, edm::Event::getByToken(), hcalTPSource, edm::HandleBase::isValid(), layer1, LOG_ERROR, eostools::move(), BXVector< T >::push_back(), regionPutToken, l1t::L1Candidate::setHwEta(), l1t::CaloTower::setHwEtEm(), l1t::CaloTower::setHwEtHad(), l1t::CaloTower::setHwEtRatio(), l1t::L1Candidate::setHwPhi(), l1t::L1Candidate::setHwPt(), l1t::L1Candidate::setHwQual(), lumiQTWidget::t, towerPutToken, twrList, unpackEcalMask, unpackHcalMask, and globals_cff::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));
 
 }