CMSSW Reference Manual

L1GlobalTrigger::L1GlobalTrigger ( const edm::ParameterSet & parSet ) [explicit]

Definition at line 91 of file L1GlobalTrigger.cc.

References lat::endl(), edm::isDebugEnabled(), it, LogTrace, m_activeBoardsGtDaq, m_activeBoardsGtEvm, m_bstLengthBytes, m_caloGctInputTag, m_castorInputTag, m_emulateBxInEvent, m_gtFDL, m_gtGTL, m_gtPSB, m_ifCaloEtaNumberBits, m_ifMuEtaNumberBits, m_l1GtBMCacheID, m_l1GtParCacheID, m_l1GtPfAlgoCacheID, m_l1GtPfTechCacheID, m_l1GtStableParCacheID, m_l1GtTmAlgoCacheID, m_l1GtTmTechCacheID, m_l1GtTmVetoAlgoCacheID, m_l1GtTmVetoTechCacheID, m_muGmtInputTag, m_nrL1CenJet, m_nrL1ForJet, m_nrL1IsoEG, m_nrL1JetCounts, m_nrL1Mu, m_nrL1NoIsoEG, m_nrL1TauJet, m_numberDaqPartitions, m_numberPhysTriggers, m_numberTechnicalTriggers, m_produceL1GtDaqRecord, m_produceL1GtEvmRecord, m_produceL1GtObjectMapRecord, m_psBstLengthBytes, m_readTechnicalTriggerRecords, m_technicalTriggersInputTags, m_totalBxInEvent, and m_writePsbL1GtDaqRecord.

00091                                                               :
00092             m_muGmtInputTag(parSet.getParameter<edm::InputTag> ("GmtInputTag")),
00093             m_caloGctInputTag(parSet.getParameter<edm::InputTag> ("GctInputTag")),
00094             m_castorInputTag(parSet.getParameter<edm::InputTag> ("CastorInputTag")),
00095             m_technicalTriggersInputTags(parSet.getParameter<std::vector<edm::InputTag> > (
00096                     "TechnicalTriggersInputTags")),
00097             m_produceL1GtDaqRecord(parSet.getParameter<bool> ("ProduceL1GtDaqRecord")),
00098             m_produceL1GtEvmRecord(parSet.getParameter<bool> ("ProduceL1GtEvmRecord")),
00099             m_produceL1GtObjectMapRecord(parSet.getParameter<bool> ("ProduceL1GtObjectMapRecord")),
00100             m_writePsbL1GtDaqRecord(parSet.getParameter<bool> ("WritePsbL1GtDaqRecord")),
00101             m_readTechnicalTriggerRecords(parSet.getParameter<bool> ("ReadTechnicalTriggerRecords")),
00102             m_emulateBxInEvent(parSet.getParameter<int> ("EmulateBxInEvent")), m_psBstLengthBytes(
00103                     parSet.getParameter<int> ("BstLengthBytes"))
00104 
00105 {
00106 
00107     if (edm::isDebugEnabled()) {
00108 
00109         LogTrace("L1GlobalTrigger") << "\nInput tag for muon collection from GMT:         "
00110                 << m_muGmtInputTag << "\nInput tag for calorimeter collections from GCT: "
00111                 << m_caloGctInputTag << "\nInput tag for CASTOR record                     "
00112                 << m_castorInputTag << "\nInput tag for technical triggers:                "
00113                 << std::endl;
00114 
00115         // loop over all producers of technical trigger records
00116         for (std::vector<edm::InputTag>::const_iterator it = m_technicalTriggersInputTags.begin(); it
00117                 != m_technicalTriggersInputTags.end(); it++) {
00118             LogTrace("L1GlobalTrigger") << "\n  " << ( *it ) << std::endl;
00119         }
00120 
00121         LogTrace("L1GlobalTrigger") << "\nProduce the L1 GT DAQ readout record:           "
00122                 << m_produceL1GtDaqRecord << "\nProduce the L1 GT EVM readout record:           "
00123                 << m_produceL1GtEvmRecord << "\nProduce the L1 GT Object Map record:            "
00124                 << m_produceL1GtObjectMapRecord << " \n"
00125                 << "\nWrite Psb content to L1 GT DAQ Record:          " << m_writePsbL1GtDaqRecord
00126                 << " \n" << "\nRead technical trigger records:                 "
00127                 << m_readTechnicalTriggerRecords << " \n"
00128                 << "\nNumber of BxInEvent to be emulated:             " << m_emulateBxInEvent
00129                 << " \n" << "\nLength of BST message [bytes]:                  "
00130                 << m_psBstLengthBytes << "\n" << std::endl;
00131     }
00132 
00133 
00134     if ( ( m_emulateBxInEvent > 0 ) && ( ( m_emulateBxInEvent % 2 ) == 0 )) {
00135         m_emulateBxInEvent = m_emulateBxInEvent - 1;
00136 
00137         edm::LogInfo("L1GlobalTrigger")
00138                 << "\nWARNING: Number of bunch crossing to be emulated rounded to: "
00139                 << m_emulateBxInEvent << "\n         The number must be an odd number!\n"
00140                 << std::endl;
00141     }
00142 
00143     // register products
00144     if (m_produceL1GtDaqRecord) {
00145         produces<L1GlobalTriggerReadoutRecord>();
00146     }
00147 
00148     if (m_produceL1GtEvmRecord) {
00149         produces<L1GlobalTriggerEvmReadoutRecord>();
00150     }
00151 
00152     if (m_produceL1GtObjectMapRecord) {
00153         produces<L1GlobalTriggerObjectMapRecord>();
00154     }
00155 
00156     // create new PSBs
00157     m_gtPSB = new L1GlobalTriggerPSB();
00158 
00159     // create new GTL
00160     m_gtGTL = new L1GlobalTriggerGTL();
00161 
00162     // create new FDL
00163     m_gtFDL = new L1GlobalTriggerFDL();
00164 
00165     // initialize cached IDs
00166 
00167     //
00168     m_l1GtStableParCacheID = 0ULL;
00169 
00170     m_numberPhysTriggers = 0;
00171     m_numberTechnicalTriggers = 0;
00172     m_numberDaqPartitions = 0;
00173 
00174     m_nrL1Mu = 0;
00175 
00176     m_nrL1NoIsoEG = 0;
00177     m_nrL1IsoEG = 0;
00178 
00179     m_nrL1CenJet = 0;
00180     m_nrL1ForJet = 0;
00181     m_nrL1TauJet = 0;
00182 
00183     m_nrL1JetCounts = 0;
00184 
00185     m_ifMuEtaNumberBits = 0;
00186     m_ifCaloEtaNumberBits = 0;
00187 
00188     //
00189     m_l1GtParCacheID = 0ULL;
00190 
00191     m_totalBxInEvent = 0;
00192 
00193     m_activeBoardsGtDaq = 0;
00194     m_activeBoardsGtEvm = 0;
00195     m_bstLengthBytes = 0;
00196 
00197     //
00198     m_l1GtBMCacheID = 0ULL;
00199 
00200     //
00201     m_l1GtPfAlgoCacheID = 0ULL;
00202     m_l1GtPfTechCacheID = 0ULL;
00203 
00204     m_l1GtTmAlgoCacheID = 0ULL;
00205     m_l1GtTmTechCacheID = 0ULL;
00206 
00207     m_l1GtTmVetoAlgoCacheID = 0ULL;
00208     m_l1GtTmVetoTechCacheID = 0ULL;
00209 
00210 }

L1GlobalTrigger::~L1GlobalTrigger ( )

Definition at line 213 of file L1GlobalTrigger.cc.

References m_gtFDL, m_gtGTL, and m_gtPSB.

00214 {
00215 
00216     delete m_gtPSB;
00217     delete m_gtGTL;
00218     delete m_gtFDL;
00219 }

const L1GlobalTriggerFDL* L1GlobalTrigger::gtFDL ( ) const [inline]

Definition at line 80 of file L1GlobalTrigger.h.

References m_gtFDL.

00081     {
00082         return m_gtFDL;
00083     }

const L1GlobalTriggerGTL* L1GlobalTrigger::gtGTL ( ) const [inline]

Definition at line 74 of file L1GlobalTrigger.h.

References m_gtGTL.

00075     {
00076         return m_gtGTL;
00077     }

const L1GlobalTriggerPSB* L1GlobalTrigger::gtPSB ( ) const [inline]

Definition at line 68 of file L1GlobalTrigger.h.

References m_gtPSB.

00069     {
00070         return m_gtPSB;
00071     }

void L1GlobalTrigger::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	evSetup
	)			`[virtual]`

length of BST message (in bytes) for L1 GT EVM record

receive technical trigger

Implements edm::EDProducer.

Definition at line 224 of file L1GlobalTrigger.cc.

00225 {
00226 
00227     // process event iEvent
00228 
00229         // get / update the stable parameters from the EventSetup
00230     // local cache & check on cacheIdentifier
00231 
00232     unsigned long long l1GtStableParCacheID =
00233             evSetup.get<L1GtStableParametersRcd>().cacheIdentifier();
00234 
00235     if (m_l1GtStableParCacheID != l1GtStableParCacheID) {
00236 
00237         edm::ESHandle< L1GtStableParameters > l1GtStablePar;
00238         evSetup.get< L1GtStableParametersRcd >().get( l1GtStablePar );
00239         m_l1GtStablePar = l1GtStablePar.product();
00240 
00241         // number of physics triggers
00242         m_numberPhysTriggers = m_l1GtStablePar->gtNumberPhysTriggers();
00243 
00244         // number of technical triggers
00245         m_numberTechnicalTriggers = m_l1GtStablePar->gtNumberTechnicalTriggers();
00246 
00247         // number of DAQ partitions
00248         m_numberDaqPartitions = 8; // FIXME add it to stable parameters
00249 
00250         // number of objects of each type
00251         //    { Mu, NoIsoEG, IsoEG, CenJet, ForJet, TauJet, ETM, ETT, HTT, JetCounts };
00252         m_nrL1Mu = static_cast<int> (m_l1GtStablePar->gtNumberL1Mu());
00253 
00254         m_nrL1NoIsoEG = static_cast<int> (m_l1GtStablePar->gtNumberL1NoIsoEG());
00255         m_nrL1IsoEG = static_cast<int> (m_l1GtStablePar->gtNumberL1IsoEG());
00256 
00257         m_nrL1CenJet = static_cast<int> (m_l1GtStablePar->gtNumberL1CenJet());
00258         m_nrL1ForJet = static_cast<int> (m_l1GtStablePar->gtNumberL1ForJet());
00259         m_nrL1TauJet = static_cast<int> (m_l1GtStablePar->gtNumberL1TauJet());
00260 
00261         m_nrL1JetCounts = static_cast<int> (m_l1GtStablePar->gtNumberL1JetCounts());
00262 
00263         // ... the rest of the objects are global
00264 
00265         m_ifMuEtaNumberBits = static_cast<int> (m_l1GtStablePar->gtIfMuEtaNumberBits());
00266         m_ifCaloEtaNumberBits = static_cast<int> (m_l1GtStablePar->gtIfCaloEtaNumberBits());
00267 
00268         // (re)initialize L1GlobalTriggerGTL
00269         m_gtGTL->init(m_nrL1Mu, m_numberPhysTriggers);
00270 
00271         // (re)initialize L1GlobalTriggerPSB
00272         m_gtPSB->init(m_nrL1NoIsoEG, m_nrL1IsoEG,
00273                 m_nrL1CenJet, m_nrL1ForJet, m_nrL1TauJet,
00274                 m_numberTechnicalTriggers);
00275 
00276         //
00277         m_l1GtStableParCacheID = l1GtStableParCacheID;
00278 
00279     }
00280 
00281     // get / update the parameters from the EventSetup
00282     // local cache & check on cacheIdentifier
00283 
00284     unsigned long long l1GtParCacheID = evSetup.get<L1GtParametersRcd>().cacheIdentifier();
00285 
00286     if (m_l1GtParCacheID != l1GtParCacheID) {
00287 
00288         edm::ESHandle< L1GtParameters > l1GtPar;
00289         evSetup.get< L1GtParametersRcd >().get( l1GtPar );
00290         m_l1GtPar = l1GtPar.product();
00291 
00292         //    total number of Bx's in the event coming from EventSetup
00293         m_totalBxInEvent = m_l1GtPar->gtTotalBxInEvent();
00294 
00295         //    active boards in L1 GT DAQ record and in L1 GT EVM record
00296         m_activeBoardsGtDaq = m_l1GtPar->gtDaqActiveBoards();
00297         m_activeBoardsGtEvm = m_l1GtPar->gtEvmActiveBoards();
00298 
00300         m_bstLengthBytes = m_l1GtPar->gtBstLengthBytes();
00301 
00302 
00303         m_l1GtParCacheID = l1GtParCacheID;
00304 
00305     }
00306 
00307     // negative value: emulate TotalBxInEvent as given in EventSetup
00308     if (m_emulateBxInEvent < 0) {
00309         m_emulateBxInEvent = m_totalBxInEvent;
00310     }
00311 
00312     int minBxInEvent = (m_emulateBxInEvent + 1)/2 - m_emulateBxInEvent;
00313     int maxBxInEvent = (m_emulateBxInEvent + 1)/2 - 1;
00314 
00315     LogDebug("L1GlobalTrigger")
00316     << "\nTotal number of bunch crosses to put in the GT readout record: "
00317     << m_emulateBxInEvent << " = " << "["
00318     << minBxInEvent << ", " << maxBxInEvent << "] BX\n"
00319     << "\n  Active boards in L1 GT DAQ record (hex format) = "
00320     << std::hex << std::setw(sizeof(m_activeBoardsGtDaq)*2) << std::setfill('0')
00321     << m_activeBoardsGtDaq
00322     << std::dec << std::setfill(' ')
00323     << std::endl;
00324 
00325     // get / update the board maps from the EventSetup
00326     // local cache & check on cacheIdentifier
00327 
00328     typedef std::vector<L1GtBoard>::const_iterator CItBoardMaps;
00329 
00330     unsigned long long l1GtBMCacheID = evSetup.get<L1GtBoardMapsRcd>().cacheIdentifier();
00331 
00332     if (m_l1GtBMCacheID != l1GtBMCacheID) {
00333 
00334         edm::ESHandle< L1GtBoardMaps > l1GtBM;
00335         evSetup.get< L1GtBoardMapsRcd >().get( l1GtBM );
00336         m_l1GtBM = l1GtBM.product();
00337 
00338         m_l1GtBMCacheID = l1GtBMCacheID;
00339 
00340     }
00341 
00342     // TODO need changes in CondFormats to cache the maps
00343     const std::vector<L1GtBoard>& boardMaps = m_l1GtBM->gtBoardMaps();
00344 
00345     // get / update the prescale factors from the EventSetup
00346     // local cache & check on cacheIdentifier
00347 
00348     unsigned long long l1GtPfAlgoCacheID =
00349         evSetup.get<L1GtPrescaleFactorsAlgoTrigRcd>().cacheIdentifier();
00350 
00351     if (m_l1GtPfAlgoCacheID != l1GtPfAlgoCacheID) {
00352 
00353         edm::ESHandle< L1GtPrescaleFactors > l1GtPfAlgo;
00354         evSetup.get< L1GtPrescaleFactorsAlgoTrigRcd >().get( l1GtPfAlgo );
00355         m_l1GtPfAlgo = l1GtPfAlgo.product();
00356 
00357         m_prescaleFactorsAlgoTrig = &(m_l1GtPfAlgo->gtPrescaleFactors());
00358 
00359         m_l1GtPfAlgoCacheID = l1GtPfAlgoCacheID;
00360 
00361     }
00362 
00363     unsigned long long l1GtPfTechCacheID =
00364         evSetup.get<L1GtPrescaleFactorsTechTrigRcd>().cacheIdentifier();
00365 
00366     if (m_l1GtPfTechCacheID != l1GtPfTechCacheID) {
00367 
00368         edm::ESHandle< L1GtPrescaleFactors > l1GtPfTech;
00369         evSetup.get< L1GtPrescaleFactorsTechTrigRcd >().get( l1GtPfTech );
00370         m_l1GtPfTech = l1GtPfTech.product();
00371 
00372         m_prescaleFactorsTechTrig = &(m_l1GtPfTech->gtPrescaleFactors());
00373 
00374         m_l1GtPfTechCacheID = l1GtPfTechCacheID;
00375 
00376     }
00377 
00378 
00379     // get / update the trigger mask from the EventSetup
00380     // local cache & check on cacheIdentifier
00381 
00382     unsigned long long l1GtTmAlgoCacheID =
00383         evSetup.get<L1GtTriggerMaskAlgoTrigRcd>().cacheIdentifier();
00384 
00385     if (m_l1GtTmAlgoCacheID != l1GtTmAlgoCacheID) {
00386 
00387         edm::ESHandle< L1GtTriggerMask > l1GtTmAlgo;
00388         evSetup.get< L1GtTriggerMaskAlgoTrigRcd >().get( l1GtTmAlgo );
00389         m_l1GtTmAlgo = l1GtTmAlgo.product();
00390 
00391         m_triggerMaskAlgoTrig = m_l1GtTmAlgo->gtTriggerMask();
00392 
00393         m_l1GtTmAlgoCacheID = l1GtTmAlgoCacheID;
00394 
00395     }
00396 
00397 
00398     unsigned long long l1GtTmTechCacheID =
00399         evSetup.get<L1GtTriggerMaskTechTrigRcd>().cacheIdentifier();
00400 
00401     if (m_l1GtTmTechCacheID != l1GtTmTechCacheID) {
00402 
00403         edm::ESHandle< L1GtTriggerMask > l1GtTmTech;
00404         evSetup.get< L1GtTriggerMaskTechTrigRcd >().get( l1GtTmTech );
00405         m_l1GtTmTech = l1GtTmTech.product();
00406 
00407         m_triggerMaskTechTrig = m_l1GtTmTech->gtTriggerMask();
00408 
00409         m_l1GtTmTechCacheID = l1GtTmTechCacheID;
00410 
00411     }
00412 
00413     unsigned long long l1GtTmVetoAlgoCacheID =
00414         evSetup.get<L1GtTriggerMaskVetoAlgoTrigRcd>().cacheIdentifier();
00415 
00416     if (m_l1GtTmVetoAlgoCacheID != l1GtTmVetoAlgoCacheID) {
00417 
00418         edm::ESHandle< L1GtTriggerMask > l1GtTmVetoAlgo;
00419         evSetup.get< L1GtTriggerMaskVetoAlgoTrigRcd >().get( l1GtTmVetoAlgo );
00420         m_l1GtTmVetoAlgo = l1GtTmVetoAlgo.product();
00421 
00422         m_triggerMaskVetoAlgoTrig = m_l1GtTmVetoAlgo->gtTriggerMask();
00423 
00424         m_l1GtTmVetoAlgoCacheID = l1GtTmVetoAlgoCacheID;
00425 
00426     }
00427 
00428 
00429     unsigned long long l1GtTmVetoTechCacheID =
00430         evSetup.get<L1GtTriggerMaskVetoTechTrigRcd>().cacheIdentifier();
00431 
00432     if (m_l1GtTmVetoTechCacheID != l1GtTmVetoTechCacheID) {
00433 
00434         edm::ESHandle< L1GtTriggerMask > l1GtTmVetoTech;
00435         evSetup.get< L1GtTriggerMaskVetoTechTrigRcd >().get( l1GtTmVetoTech );
00436         m_l1GtTmVetoTech = l1GtTmVetoTech.product();
00437 
00438         m_triggerMaskVetoTechTrig = m_l1GtTmVetoTech->gtTriggerMask();
00439 
00440         m_l1GtTmVetoTechCacheID = l1GtTmVetoTechCacheID;
00441 
00442     }
00443 
00444     // loop over blocks in the GT DAQ record receiving data, count them if they are active
00445     // all board type are defined in CondFormats/L1TObjects/L1GtFwd
00446     // enum L1GtBoardType { GTFE, FDL, PSB, GMT, TCS, TIM };
00447     // &
00448     // set the active flag for each object type received from GMT and GCT
00449     // all objects in the GT system are defined in enum L1GtObject from
00450     // DataFormats/L1Trigger/L1GlobalTriggerReadoutSetupFwd
00451 
00452     int daqNrGtfeBoards = 0;
00453 
00454     int daqNrFdlBoards = 0;
00455     int daqNrPsbBoards = 0;
00456     int daqNrGmtBoards = 0;
00457     int daqNrTcsBoards = 0;
00458     int daqNrTimBoards = 0;
00459 
00460     //
00461     bool receiveMu = false;
00462     bool receiveNoIsoEG = false;
00463     bool receiveIsoEG = false;
00464     bool receiveCenJet = false;
00465     bool receiveForJet = false;
00466     bool receiveTauJet = false;
00467     bool receiveETM = false;
00468     bool receiveETT = false;
00469     bool receiveHTT = false;
00470     bool receiveJetCounts = false;
00471     bool receiveHfBitCounts = false;
00472     bool receiveHfRingEtSums = false;
00473 
00474     bool receiveCastor = false;
00475 
00476     bool receiveTechTr = false;
00477 
00478     for (CItBoardMaps
00479             itBoard = boardMaps.begin();
00480             itBoard != boardMaps.end(); ++itBoard) {
00481 
00482         int iPosition = itBoard->gtPositionDaqRecord();
00483         if (iPosition > 0) {
00484 
00485             int iActiveBit = itBoard->gtBitDaqActiveBoards();
00486             bool activeBoard = false;
00487 
00488             if (iActiveBit >= 0) {
00489                 activeBoard = m_activeBoardsGtDaq & (1 << iActiveBit);
00490             }
00491 
00492             // use board if: in the record, but not in ActiveBoardsMap (iActiveBit < 0)
00493             //               in the record and ActiveBoardsMap, and active
00494             if ((iActiveBit < 0) || activeBoard) {
00495 
00496                 switch (itBoard->gtBoardType()) {
00497 
00498                     case GTFE: {
00499                             daqNrGtfeBoards++;
00500                         }
00501 
00502                         break;
00503                     case FDL: {
00504                             daqNrFdlBoards++;
00505                         }
00506 
00507                         break;
00508                     case PSB: {
00509                             daqNrPsbBoards++;
00510 
00511                             // get the objects coming to this PSB
00512                             std::vector<L1GtPsbQuad> quadInPsb = itBoard->gtQuadInPsb();
00513                             for (std::vector<L1GtPsbQuad>::const_iterator
00514                                     itQuad = quadInPsb.begin();
00515                                     itQuad != quadInPsb.end(); ++itQuad) {
00516 
00517                                 switch (*itQuad) {
00518 
00519                                     case TechTr: {
00520                                             receiveTechTr = true;
00521                                         }
00522 
00523                                         break;
00524                                     case NoIsoEGQ: {
00525                                             receiveNoIsoEG = true;
00526                                         }
00527 
00528                                         break;
00529                                     case IsoEGQ: {
00530                                             receiveIsoEG = true;
00531                                         }
00532 
00533                                         break;
00534                                     case CenJetQ: {
00535                                             receiveCenJet = true;
00536                                         }
00537 
00538                                         break;
00539                                     case ForJetQ: {
00540                                             receiveForJet = true;
00541                                         }
00542 
00543                                         break;
00544                                     case TauJetQ: {
00545                                             receiveTauJet = true;
00546                                         }
00547 
00548                                         break;
00549                                     case ESumsQ: {
00550                                             receiveETM = true;
00551                                             receiveETT = true;
00552                                             receiveHTT = true;
00553                                         }
00554 
00555                                         break;
00556                                     case JetCountsQ: {
00557                                             receiveJetCounts = true;
00558                                         }
00559 
00560                                         break;
00561                                     case CastorQ: {
00562                                             receiveCastor = true;
00563                                         }
00564 
00565                                         break;
00566                                     case HfQ: {
00567                                             receiveHfBitCounts = true;
00568                                             receiveHfRingEtSums = true;
00569                                         }
00570 
00571                                         break;
00572                                         // FIXME add MIP/Iso bits
00573                                     default: {
00574                                             // do nothing
00575                                         }
00576 
00577                                         break;
00578                                 }
00579 
00580                             }
00581 
00582                         }
00583 
00584                         break;
00585                     case GMT: {
00586                             daqNrGmtBoards++;
00587                             receiveMu = true;
00588                         }
00589 
00590                         break;
00591                     case TCS: {
00592                             daqNrTcsBoards++;
00593                         }
00594 
00595                         break;
00596                     case TIM: {
00597                             daqNrTimBoards++;
00598                         }
00599 
00600                         break;
00601                     default: {
00602                             // do nothing, all blocks are given in GtBoardType enum
00603                         }
00604 
00605                         break;
00606                 }
00607             }
00608         }
00609 
00610     }
00611 
00612     // produce the L1GlobalTriggerReadoutRecord now, after we found how many
00613     // BxInEvent the record has and how many boards are active
00614     std::auto_ptr<L1GlobalTriggerReadoutRecord> gtDaqReadoutRecord(
00615         new L1GlobalTriggerReadoutRecord(
00616             m_emulateBxInEvent, daqNrFdlBoards, daqNrPsbBoards) );
00617 
00618 
00619     // * produce the L1GlobalTriggerEvmReadoutRecord
00620     std::auto_ptr<L1GlobalTriggerEvmReadoutRecord> gtEvmReadoutRecord(
00621         new L1GlobalTriggerEvmReadoutRecord(m_emulateBxInEvent, daqNrFdlBoards) );
00622     // daqNrFdlBoards OK, just reserve memory at this point
00623 
00624     // * produce the L1GlobalTriggerObjectMapRecord
00625     std::auto_ptr<L1GlobalTriggerObjectMapRecord> gtObjectMapRecord(
00626         new L1GlobalTriggerObjectMapRecord() );
00627 
00628 
00629     // fill the boards not depending on the BxInEvent in the L1 GT DAQ record
00630     // GMT, PSB and FDL depend on BxInEvent
00631 
00632     // fill in emulator the same bunch crossing (12 bits - hardwired number of bits...)
00633     // and the same local bunch crossing for all boards
00634     int bxCross = iEvent.bunchCrossing();
00635     boost::uint16_t bxCrossHw = 0;
00636     if ((bxCross & 0xFFF) == bxCross) {
00637         bxCrossHw = static_cast<boost::uint16_t> (bxCross);
00638     }
00639     else {
00640         bxCrossHw = 0; // Bx number too large, set to 0!
00641         LogDebug("L1GlobalTrigger")
00642             << "\nBunch cross number [hex] = "
00643             << std::hex << bxCross
00644             << "\n  larger than 12 bits. Set to 0! \n"
00645             << std::dec << std::endl;
00646     }
00647 
00648 
00649     if (m_produceL1GtDaqRecord) {
00650 
00651         for (CItBoardMaps
00652                 itBoard = boardMaps.begin();
00653                 itBoard != boardMaps.end(); ++itBoard) {
00654 
00655             int iPosition = itBoard->gtPositionDaqRecord();
00656             if (iPosition > 0) {
00657 
00658                 int iActiveBit = itBoard->gtBitDaqActiveBoards();
00659                 bool activeBoard = false;
00660 
00661                 if (iActiveBit >= 0) {
00662                     activeBoard = m_activeBoardsGtDaq & (1 << iActiveBit);
00663                 }
00664 
00665                 // use board if: in the record, but not in ActiveBoardsMap (iActiveBit < 0)
00666                 //               in the record and ActiveBoardsMap, and active
00667                 if ((iActiveBit < 0) || activeBoard) {
00668 
00669                     switch (itBoard->gtBoardType()) {
00670 
00671                         case GTFE: {
00672                                 L1GtfeWord gtfeWordValue;
00673 
00674                                 gtfeWordValue.setBoardId( itBoard->gtBoardId() );
00675 
00676                                 // cast int to boost::uint16_t
00677                                 // there are normally 3 or 5 BxInEvent
00678                                 gtfeWordValue.setRecordLength(
00679                                     static_cast<boost::uint16_t>(m_emulateBxInEvent));
00680 
00681                                 // bunch crossing
00682                                 gtfeWordValue.setBxNr(bxCrossHw);
00683 
00684                                 // set the list of active boards
00685                                 gtfeWordValue.setActiveBoards(m_activeBoardsGtDaq);
00686 
00687                                 // set the TOTAL_TRIGNR as read from iEvent
00688                                 // TODO check again - PTC stuff
00689 
00690                                 gtfeWordValue.setTotalTriggerNr(
00691                                     static_cast<boost::uint32_t>(iEvent.id().event()));
00692 
00693                                 // ** fill L1GtfeWord in GT DAQ record
00694 
00695                                 gtDaqReadoutRecord->setGtfeWord(gtfeWordValue);
00696                             }
00697 
00698                             break;
00699                         case TCS: {
00700                                 // nothing
00701                             }
00702 
00703                             break;
00704                         case TIM: {
00705                                 // nothing
00706                             }
00707 
00708                             break;
00709                         default: {
00710                                 // do nothing, all blocks are given in GtBoardType enum
00711                             }
00712 
00713                             break;
00714                     }
00715                 }
00716             }
00717 
00718         }
00719 
00720     }
00721 
00722     // fill the boards not depending on the BxInEvent in the L1 GT EVM record
00723 
00724     int evmNrFdlBoards = 0;
00725 
00726     if (m_produceL1GtEvmRecord) {
00727 
00728         // get the length of the BST message from parameter set or from event setup
00729 
00730         int bstLengthBytes = 0;
00731 
00732         if (m_psBstLengthBytes < 0) {
00733             // length from event setup
00734             bstLengthBytes = static_cast<int> (m_bstLengthBytes);
00735 
00736         } else {
00737             // length from parameter set
00738             bstLengthBytes = m_psBstLengthBytes;
00739         }
00740 
00741         LogTrace("L1GlobalTrigger")
00742         << "\n Length of BST message (in bytes): " << bstLengthBytes << "\n"
00743         << std::endl;
00744 
00745         for (CItBoardMaps
00746                 itBoard = boardMaps.begin();
00747                 itBoard != boardMaps.end(); ++itBoard) {
00748 
00749             int iPosition = itBoard->gtPositionEvmRecord();
00750             if (iPosition > 0) {
00751 
00752                 int iActiveBit = itBoard->gtBitEvmActiveBoards();
00753                 bool activeBoard = false;
00754 
00755                 if (iActiveBit >= 0) {
00756                     activeBoard = m_activeBoardsGtEvm & (1 << iActiveBit);
00757                 }
00758 
00759                 // use board if: in the record, but not in ActiveBoardsMap (iActiveBit < 0)
00760                 //               in the record and ActiveBoardsMap, and active
00761                 if ((iActiveBit < 0) || activeBoard) {
00762 
00763                     switch (itBoard->gtBoardType()) {
00764 
00765                         case GTFE: {
00766                                 L1GtfeExtWord gtfeWordValue(bstLengthBytes);
00767 
00768                                 gtfeWordValue.setBoardId(itBoard->gtBoardId() );
00769 
00770                                 // cast int to boost::uint16_t
00771                                 // there are normally 3 or 5 BxInEvent
00772                                 gtfeWordValue.setRecordLength(
00773                                     static_cast<boost::uint16_t>(m_emulateBxInEvent));
00774 
00775                                 // bunch crossing
00776                                 gtfeWordValue.setBxNr(bxCrossHw);
00777 
00778                                 // set the list of active boards
00779                                 gtfeWordValue.setActiveBoards(m_activeBoardsGtEvm);
00780 
00781                                 // set the TOTAL_TRIGNR as read from iEvent
00782                                 // TODO check again - PTC stuff
00783 
00784                                 gtfeWordValue.setTotalTriggerNr(
00785                                     static_cast<boost::uint32_t>(iEvent.id().event()));
00786 
00787                                 // set the GPS time to the value read from Timestamp
00788                                 edm::TimeValue_t evTime = iEvent.time().value();
00789 
00790                                 gtfeWordValue.setGpsTime(evTime);
00791 
00792                                 //LogDebug("L1GlobalTrigger")
00793                                 //<< "\nEvent timestamp value [hex] = " << std::hex << evTime
00794                                 //<< "\nBST retrieved value [hex]   = " << gtfeWordValue.gpsTime()
00795                                 //<< std::dec << std::endl;
00796 
00797                                 // source of BST message: DDDD simulated data
00798                                 boost::uint16_t bstSourceVal = 0xDDDD;
00799                                 gtfeWordValue.setBstSource(bstSourceVal);
00800 
00801                                 // ** fill L1GtfeWord in GT EVM record
00802 
00803                                 gtEvmReadoutRecord->setGtfeWord(gtfeWordValue);
00804                             }
00805 
00806                             break;
00807                         case FDL: {
00808                                 evmNrFdlBoards++;
00809                             }
00810 
00811                             break;
00812                         case TCS: {
00813 
00814                                 L1TcsWord tcsWordValue;
00815 
00816                                 tcsWordValue.setBoardId( itBoard->gtBoardId() );
00817 
00818                                 // bunch crossing
00819                                 tcsWordValue.setBxNr(bxCrossHw);
00820 
00821                                 boost::uint16_t trigType = 0x5; // 0101 simulated event
00822                                 tcsWordValue.setTriggerType(trigType);
00823 
00824                                 // luminosity segment number
00825                                 tcsWordValue.setLuminositySegmentNr(
00826                                         static_cast<boost::uint16_t>(iEvent.luminosityBlock()));
00827 
00828 
00829                                 // set the Event_Nr as read from iEvent
00830                                 tcsWordValue.setEventNr(
00831                                     static_cast<boost::uint32_t>(iEvent.id().event()));
00832 
00833                                 // orbit number
00834                                 tcsWordValue.setOrbitNr(
00835                                         static_cast<boost::uint64_t>(iEvent.orbitNumber()) );
00836 
00837                                 // ** fill L1TcsWord in the EVM record
00838 
00839                                 gtEvmReadoutRecord->setTcsWord(tcsWordValue);
00840 
00841                             }
00842 
00843                             break;
00844                         case TIM: {
00845                                 // nothing
00846                             }
00847 
00848                             break;
00849                         default: {
00850                                 // do nothing, all blocks are given in GtBoardType enum
00851                             }
00852 
00853                             break;
00854                     }
00855                 }
00856             }
00857 
00858         }
00859 
00860     }
00861 
00862     // get the prescale factor set used in the actual luminosity segment
00863     int pfAlgoSetIndex = 0; // FIXME
00864     const std::vector<int>& prescaleFactorsAlgoTrig =
00865         (*m_prescaleFactorsAlgoTrig).at(pfAlgoSetIndex);
00866 
00867     int pfTechSetIndex = 0; // FIXME
00868     const std::vector<int>& prescaleFactorsTechTrig =
00869         (*m_prescaleFactorsTechTrig).at(pfTechSetIndex);
00870 
00871     //
00872 
00873     // loop over BxInEvent
00874     for (int iBxInEvent = minBxInEvent; iBxInEvent <= maxBxInEvent;
00875             ++iBxInEvent) {
00876 
00877         // * receive GCT object data via PSBs
00878         //LogDebug("L1GlobalTrigger")
00879         //<< "\nL1GlobalTrigger : receiving PSB data for bx = " << iBxInEvent << "\n"
00880         //<< std::endl;
00881 
00882         m_gtPSB->receiveGctObjectData(
00883             iEvent,
00884             m_caloGctInputTag, iBxInEvent,
00885             receiveNoIsoEG, m_nrL1NoIsoEG,
00886             receiveIsoEG, m_nrL1IsoEG,
00887             receiveCenJet, m_nrL1CenJet,
00888             receiveForJet, m_nrL1ForJet,
00889             receiveTauJet, m_nrL1TauJet,
00890             receiveETM, receiveETT, receiveHTT,
00891             receiveJetCounts,
00892             receiveHfBitCounts,
00893             receiveHfRingEtSums);
00894 
00896         if (m_readTechnicalTriggerRecords) {
00897             m_gtPSB->receiveTechnicalTriggers(iEvent,
00898                     m_technicalTriggersInputTags, iBxInEvent, receiveTechTr,
00899                     m_numberTechnicalTriggers);
00900         }
00901 
00902         if (m_produceL1GtDaqRecord && m_writePsbL1GtDaqRecord) {
00903             m_gtPSB->fillPsbBlock(iEvent, m_activeBoardsGtDaq, boardMaps,
00904                     iBxInEvent, gtDaqReadoutRecord);
00905         }
00906 
00907         // * receive GMT object data via GTL
00908         //LogDebug("L1GlobalTrigger")
00909         //<< "\nL1GlobalTrigger : receiving GMT data for bx = " << iBxInEvent << "\n"
00910         //<< std::endl;
00911 
00912         m_gtGTL->receiveGmtObjectData(iEvent, m_muGmtInputTag, iBxInEvent,
00913                 receiveMu, m_nrL1Mu);
00914 
00915         // * run GTL
00916         //LogDebug("L1GlobalTrigger")
00917         //<< "\nL1GlobalTrigger : running GTL for bx = " << iBxInEvent << "\n"
00918         //<< std::endl;
00919 
00920         m_gtGTL->run(iEvent, evSetup, m_gtPSB,
00921             m_produceL1GtObjectMapRecord, iBxInEvent, gtObjectMapRecord,
00922             m_numberPhysTriggers,
00923             m_nrL1Mu,
00924             m_nrL1NoIsoEG,
00925             m_nrL1IsoEG,
00926             m_nrL1CenJet,
00927             m_nrL1ForJet,
00928             m_nrL1TauJet,
00929             m_nrL1JetCounts,
00930             m_ifMuEtaNumberBits,
00931             m_ifCaloEtaNumberBits,
00932             receiveCastor,
00933             m_castorInputTag);
00934 
00935         //LogDebug("L1GlobalTrigger")
00936         //<< "\n AlgorithmOR\n" << m_gtGTL->getAlgorithmOR() << "\n"
00937         //<< std::endl;
00938 
00939         // * run FDL
00940         //LogDebug("L1GlobalTrigger")
00941         //<< "\nL1GlobalTrigger : running FDL for bx = " << iBxInEvent << "\n"
00942         //<< std::endl;
00943 
00944         m_gtFDL->run(iEvent,
00945                 prescaleFactorsAlgoTrig, prescaleFactorsTechTrig,
00946                 m_triggerMaskAlgoTrig, m_triggerMaskTechTrig,
00947                 m_triggerMaskVetoAlgoTrig, m_triggerMaskVetoTechTrig,
00948                 boardMaps, m_emulateBxInEvent, iBxInEvent,
00949                 m_numberPhysTriggers, m_numberTechnicalTriggers,
00950                 m_numberDaqPartitions,
00951                 m_gtGTL, m_gtPSB,
00952                 pfAlgoSetIndex,
00953                 pfTechSetIndex);
00954 
00955         if (m_produceL1GtDaqRecord && (daqNrFdlBoards > 0)) {
00956             m_gtFDL->fillDaqFdlBlock(
00957                 m_activeBoardsGtDaq, boardMaps,
00958                 gtDaqReadoutRecord);
00959         }
00960 
00961 
00962         if (m_produceL1GtEvmRecord && (evmNrFdlBoards > 0)) {
00963             m_gtFDL->fillEvmFdlBlock(
00964                 m_activeBoardsGtEvm, boardMaps,
00965                 gtEvmReadoutRecord);
00966         }
00967 
00968         // reset
00969         m_gtPSB->reset();
00970         m_gtGTL->reset();
00971         m_gtFDL->reset();
00972 
00973         //LogDebug("L1GlobalTrigger") << "\n Reset PSB, GTL, FDL\n" << std::endl;
00974 
00975     }
00976 
00977 
00978     if ( receiveMu ) {
00979 
00980 
00981         //LogDebug("L1GlobalTrigger")
00982         //<< "\n**** "
00983         //<< "\n  Persistent reference for L1MuGMTReadoutCollection with input tag: "
00984         //<< m_muGmtInputTag
00985         //<< "\n**** \n"
00986         //<< std::endl;
00987 
00988         // get L1MuGMTReadoutCollection reference and set it in GT record
00989 
00990         edm::Handle<L1MuGMTReadoutCollection> gmtRcHandle;
00991         iEvent.getByLabel(m_muGmtInputTag, gmtRcHandle);
00992 
00993         if (!gmtRcHandle.isValid()) {
00994             edm::LogWarning("L1GlobalTrigger")
00995             << "\nWarning: L1MuGMTReadoutCollection with input tag " << m_muGmtInputTag
00996             << "\nrequested in configuration, but not found in the event.\n"
00997             << std::endl;
00998         }
00999         else {
01000 
01001             gtDaqReadoutRecord->setMuCollectionRefProd(gmtRcHandle);
01002 
01003 
01004         }
01005 
01006     }
01007 
01008     if ( edm::isDebugEnabled() ) {
01009 
01010         std::ostringstream myCoutStream;
01011         gtDaqReadoutRecord->print(myCoutStream);
01012         LogTrace("L1GlobalTrigger")
01013         << "\n The following L1 GT DAQ readout record was produced:\n"
01014         << myCoutStream.str() << "\n"
01015         << std::endl;
01016 
01017         myCoutStream.str("");
01018         myCoutStream.clear();
01019 
01020         gtEvmReadoutRecord->print(myCoutStream);
01021         LogTrace("L1GlobalTrigger")
01022         << "\n The following L1 GT EVM readout record was produced:\n"
01023         << myCoutStream.str() << "\n"
01024         << std::endl;
01025 
01026         myCoutStream.str("");
01027         myCoutStream.clear();
01028 
01029         const std::vector<L1GlobalTriggerObjectMap> objMapVec =
01030             gtObjectMapRecord->gtObjectMap();
01031 
01032         for (std::vector<L1GlobalTriggerObjectMap>::const_iterator
01033                 it = objMapVec.begin(); it != objMapVec.end(); ++it) {
01034 
01035             (*it).print(myCoutStream);
01036 
01037         }
01038 
01039 
01040         LogDebug("L1GlobalTrigger")
01041         << "Test gtObjectMapRecord in L1GlobalTrigger \n\n" << myCoutStream.str() << "\n\n"
01042         << std::endl;
01043 
01044         myCoutStream.str("");
01045         myCoutStream.clear();
01046 
01047     }
01048 
01049     // **
01050     // register products
01051     if (m_produceL1GtDaqRecord) {
01052         iEvent.put( gtDaqReadoutRecord );
01053     }
01054 
01055     if (m_produceL1GtEvmRecord) {
01056         iEvent.put( gtEvmReadoutRecord );
01057     }
01058 
01059     if (m_produceL1GtObjectMapRecord) {
01060         iEvent.put( gtObjectMapRecord );
01061     }
01062 
01063 }

boost::uint16_t L1GlobalTrigger::m_activeBoardsGtDaq [private]

active boards in L1 GT DAQ record and in L1 GT EVM record

Definition at line 129 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

boost::uint16_t L1GlobalTrigger::m_activeBoardsGtEvm [private]

Definition at line 130 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

unsigned int L1GlobalTrigger::m_bstLengthBytes [private]

length of BST record (in bytes) from event setup

Definition at line 133 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

edm::InputTag L1GlobalTrigger::m_caloGctInputTag [private]

input tag for calorimeter collections from GCT

Definition at line 180 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

edm::InputTag L1GlobalTrigger::m_castorInputTag [private]

input tag for CASTOR record

Definition at line 183 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

int L1GlobalTrigger::m_emulateBxInEvent [private]

number of "bunch crossing in the event" (BxInEvent) to be emulated symmetric around L1Accept (BxInEvent = 0): 1 (BxInEvent = 0); 3 (F 0 1) (standard record); 5 (E F 0 1 2) (debug record) even numbers (except 0) "rounded" to the nearest lower odd number

Definition at line 207 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

L1GlobalTriggerFDL* L1GlobalTrigger::m_gtFDL [private]

Definition at line 174 of file L1GlobalTrigger.h.

Referenced by gtFDL(), L1GlobalTrigger(), produce(), and ~L1GlobalTrigger().

L1GlobalTriggerGTL* L1GlobalTrigger::m_gtGTL [private]

Definition at line 173 of file L1GlobalTrigger.h.

Referenced by gtGTL(), L1GlobalTrigger(), produce(), and ~L1GlobalTrigger().

L1GlobalTriggerPSB* L1GlobalTrigger::m_gtPSB [private]

Definition at line 172 of file L1GlobalTrigger.h.

Referenced by gtPSB(), L1GlobalTrigger(), produce(), and ~L1GlobalTrigger().

int L1GlobalTrigger::m_ifCaloEtaNumberBits [private]

Definition at line 118 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

int L1GlobalTrigger::m_ifMuEtaNumberBits [private]

Definition at line 117 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

const L1GtBoardMaps* L1GlobalTrigger::m_l1GtBM [private]

board maps - cache only the record

Definition at line 136 of file L1GlobalTrigger.h.

Referenced by produce().

unsigned long long L1GlobalTrigger::m_l1GtBMCacheID [private]

Definition at line 137 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

const L1GtParameters* L1GlobalTrigger::m_l1GtPar [private]

parameters

Definition at line 122 of file L1GlobalTrigger.h.

Referenced by produce().

unsigned long long L1GlobalTrigger::m_l1GtParCacheID [private]

Definition at line 123 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

const L1GtPrescaleFactors* L1GlobalTrigger::m_l1GtPfAlgo [private]

prescale factors

Definition at line 141 of file L1GlobalTrigger.h.

Referenced by produce().

unsigned long long L1GlobalTrigger::m_l1GtPfAlgoCacheID [private]

Definition at line 142 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

const L1GtPrescaleFactors* L1GlobalTrigger::m_l1GtPfTech [private]

Definition at line 144 of file L1GlobalTrigger.h.

Referenced by produce().

unsigned long long L1GlobalTrigger::m_l1GtPfTechCacheID [private]

Definition at line 145 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

const L1GtStableParameters* L1GlobalTrigger::m_l1GtStablePar [private]

cached stuff

stable parameters

Definition at line 90 of file L1GlobalTrigger.h.

Referenced by produce().

unsigned long long L1GlobalTrigger::m_l1GtStableParCacheID [private]

Definition at line 91 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

const L1GtTriggerMask* L1GlobalTrigger::m_l1GtTmAlgo [private]

trigger masks & veto masks

Definition at line 151 of file L1GlobalTrigger.h.

Referenced by produce().

unsigned long long L1GlobalTrigger::m_l1GtTmAlgoCacheID [private]

Definition at line 152 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

const L1GtTriggerMask* L1GlobalTrigger::m_l1GtTmTech [private]

Definition at line 154 of file L1GlobalTrigger.h.

Referenced by produce().

unsigned long long L1GlobalTrigger::m_l1GtTmTechCacheID [private]

Definition at line 155 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

const L1GtTriggerMask* L1GlobalTrigger::m_l1GtTmVetoAlgo [private]

Definition at line 157 of file L1GlobalTrigger.h.

Referenced by produce().

unsigned long long L1GlobalTrigger::m_l1GtTmVetoAlgoCacheID [private]

Definition at line 158 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

const L1GtTriggerMask* L1GlobalTrigger::m_l1GtTmVetoTech [private]

Definition at line 160 of file L1GlobalTrigger.h.

Referenced by produce().

unsigned long long L1GlobalTrigger::m_l1GtTmVetoTechCacheID [private]

Definition at line 161 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

edm::InputTag L1GlobalTrigger::m_muGmtInputTag [private]

input tag for muon collection from GMT

Definition at line 177 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

int L1GlobalTrigger::m_nrL1CenJet [private]

Definition at line 109 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

int L1GlobalTrigger::m_nrL1ForJet [private]

Definition at line 110 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

int L1GlobalTrigger::m_nrL1IsoEG [private]

Definition at line 107 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

int L1GlobalTrigger::m_nrL1JetCounts [private]

Definition at line 113 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

int L1GlobalTrigger::m_nrL1Mu [private]

number of objects of each type { Mu, NoIsoEG, IsoEG, CenJet, ForJet, TauJet, ETM, ETT, HTT, JetCounts };

Definition at line 104 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

int L1GlobalTrigger::m_nrL1NoIsoEG [private]

Definition at line 106 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

int L1GlobalTrigger::m_nrL1TauJet [private]

Definition at line 111 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

unsigned int L1GlobalTrigger::m_numberDaqPartitions [private]

number of DAQ partitions

Definition at line 100 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

unsigned int L1GlobalTrigger::m_numberPhysTriggers [private]

number of physics triggers

Definition at line 94 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

unsigned int L1GlobalTrigger::m_numberTechnicalTriggers [private]

number of technical triggers

Definition at line 97 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

const std::vector<std::vector<int> >* L1GlobalTrigger::m_prescaleFactorsAlgoTrig [private]

Definition at line 147 of file L1GlobalTrigger.h.

Referenced by produce().

const std::vector<std::vector<int> >* L1GlobalTrigger::m_prescaleFactorsTechTrig [private]

Definition at line 148 of file L1GlobalTrigger.h.

Referenced by produce().

bool L1GlobalTrigger::m_produceL1GtDaqRecord [private]

logical flag to produce the L1 GT DAQ readout record

Definition at line 189 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

bool L1GlobalTrigger::m_produceL1GtEvmRecord [private]

logical flag to produce the L1 GT EVM readout record

Definition at line 192 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

bool L1GlobalTrigger::m_produceL1GtObjectMapRecord [private]

logical flag to produce the L1 GT object map record

Definition at line 195 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

int L1GlobalTrigger::m_psBstLengthBytes [private]

length of BST record (in bytes) from parameter set

Definition at line 210 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

bool L1GlobalTrigger::m_readTechnicalTriggerRecords [private]

logical flag to read the technical trigger records

Definition at line 201 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

std::vector<edm::InputTag> L1GlobalTrigger::m_technicalTriggersInputTags [private]

input tag for technical triggers

Definition at line 186 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

int L1GlobalTrigger::m_totalBxInEvent [private]

total number of Bx's in the event coming from EventSetup

Definition at line 126 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

std::vector<unsigned int> L1GlobalTrigger::m_triggerMaskAlgoTrig [private]

Definition at line 163 of file L1GlobalTrigger.h.

Referenced by produce().

std::vector<unsigned int> L1GlobalTrigger::m_triggerMaskTechTrig [private]

Definition at line 164 of file L1GlobalTrigger.h.

Referenced by produce().

std::vector<unsigned int> L1GlobalTrigger::m_triggerMaskVetoAlgoTrig [private]

Definition at line 166 of file L1GlobalTrigger.h.

Referenced by produce().

std::vector<unsigned int> L1GlobalTrigger::m_triggerMaskVetoTechTrig [private]

Definition at line 167 of file L1GlobalTrigger.h.

Referenced by produce().

bool L1GlobalTrigger::m_writePsbL1GtDaqRecord [private]

logical flag to write the PSB content in the L1 GT DAQ record

Definition at line 198 of file L1GlobalTrigger.h.

Referenced by L1GlobalTrigger(), and produce().

L1GlobalTrigger Class Reference

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


Public Member Functions
const L1GlobalTriggerFDL *	gtFDL () const
const L1GlobalTriggerGTL *	gtGTL () const
const L1GlobalTriggerPSB *	gtPSB () const
	L1GlobalTrigger (const edm::ParameterSet &)
virtual void	produce (edm::Event &, const edm::EventSetup &)
	~L1GlobalTrigger ()
Private Attributes
boost::uint16_t	m_activeBoardsGtDaq
	active boards in L1 GT DAQ record and in L1 GT EVM record
boost::uint16_t	m_activeBoardsGtEvm
unsigned int	m_bstLengthBytes
	length of BST record (in bytes) from event setup
edm::InputTag	m_caloGctInputTag
	input tag for calorimeter collections from GCT
edm::InputTag	m_castorInputTag
	input tag for CASTOR record
int	m_emulateBxInEvent
	number of "bunch crossing in the event" (BxInEvent) to be emulated symmetric around L1Accept (BxInEvent = 0): 1 (BxInEvent = 0); 3 (F 0 1) (standard record); 5 (E F 0 1 2) (debug record) even numbers (except 0) "rounded" to the nearest lower odd number
L1GlobalTriggerFDL *	m_gtFDL
L1GlobalTriggerGTL *	m_gtGTL
L1GlobalTriggerPSB *	m_gtPSB
int	m_ifCaloEtaNumberBits
int	m_ifMuEtaNumberBits
const L1GtBoardMaps *	m_l1GtBM
	board maps - cache only the record
unsigned long long	m_l1GtBMCacheID
const L1GtParameters *	m_l1GtPar
	parameters
unsigned long long	m_l1GtParCacheID
const L1GtPrescaleFactors *	m_l1GtPfAlgo
	prescale factors
unsigned long long	m_l1GtPfAlgoCacheID
const L1GtPrescaleFactors *	m_l1GtPfTech
unsigned long long	m_l1GtPfTechCacheID
const L1GtStableParameters *	m_l1GtStablePar
	cached stuff
unsigned long long	m_l1GtStableParCacheID
const L1GtTriggerMask *	m_l1GtTmAlgo
	trigger masks & veto masks
unsigned long long	m_l1GtTmAlgoCacheID
const L1GtTriggerMask *	m_l1GtTmTech
unsigned long long	m_l1GtTmTechCacheID
const L1GtTriggerMask *	m_l1GtTmVetoAlgo
unsigned long long	m_l1GtTmVetoAlgoCacheID
const L1GtTriggerMask *	m_l1GtTmVetoTech
unsigned long long	m_l1GtTmVetoTechCacheID
edm::InputTag	m_muGmtInputTag
	input tag for muon collection from GMT
int	m_nrL1CenJet
int	m_nrL1ForJet
int	m_nrL1IsoEG
int	m_nrL1JetCounts
int	m_nrL1Mu
	number of objects of each type { Mu, NoIsoEG, IsoEG, CenJet, ForJet, TauJet, ETM, ETT, HTT, JetCounts };
int	m_nrL1NoIsoEG
int	m_nrL1TauJet
unsigned int	m_numberDaqPartitions
	number of DAQ partitions
unsigned int	m_numberPhysTriggers
	number of physics triggers
unsigned int	m_numberTechnicalTriggers
	number of technical triggers
const std::vector< std::vector < int > > *	m_prescaleFactorsAlgoTrig
const std::vector< std::vector < int > > *	m_prescaleFactorsTechTrig
bool	m_produceL1GtDaqRecord
	logical flag to produce the L1 GT DAQ readout record
bool	m_produceL1GtEvmRecord
	logical flag to produce the L1 GT EVM readout record
bool	m_produceL1GtObjectMapRecord
	logical flag to produce the L1 GT object map record
int	m_psBstLengthBytes
	length of BST record (in bytes) from parameter set
bool	m_readTechnicalTriggerRecords
	logical flag to read the technical trigger records
std::vector< edm::InputTag >	m_technicalTriggersInputTags
	input tag for technical triggers
int	m_totalBxInEvent
	total number of Bx's in the event coming from EventSetup
std::vector< unsigned int >	m_triggerMaskAlgoTrig
std::vector< unsigned int >	m_triggerMaskTechTrig
std::vector< unsigned int >	m_triggerMaskVetoAlgoTrig
std::vector< unsigned int >	m_triggerMaskVetoTechTrig
bool	m_writePsbL1GtDaqRecord
	logical flag to write the PSB content in the L1 GT DAQ record