CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions | Private Member Functions | Private Attributes | Static Private Attributes
L1GtDataEmulAnalyzer Class Reference

#include <L1GtDataEmulAnalyzer.h>

Inheritance diagram for L1GtDataEmulAnalyzer:
edm::EDAnalyzer edm::EDConsumerBase

Public Member Functions

 L1GtDataEmulAnalyzer (const edm::ParameterSet &)
 
 ~L1GtDataEmulAnalyzer ()
 
- Public Member Functions inherited from edm::EDAnalyzer
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
 EDAnalyzer ()
 
ModuleDescription const & moduleDescription () const
 
std::string workerType () const
 
virtual ~EDAnalyzer ()
 
- Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo > consumesInfo () const
 
 EDConsumerBase ()
 
ProductHolderIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
 
std::vector
< ProductHolderIndexAndSkipBit >
const & 		itemsToGetFromEvent () const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const
 
void modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
 
bool registeredToConsume (ProductHolderIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
void updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
 
virtual ~EDConsumerBase ()
 

Private Member Functions

virtual void analyze (const edm::Event &, const edm::EventSetup &)
 analyze each event More...
 
virtual void beginJob ()
 
void bookHistograms ()
 book all histograms for the module More...
 
virtual void compareDaqRecord (const edm::Event &, const edm::EventSetup &)
 L1 GT DAQ record comparison. More...
 
virtual void compareEvmRecord (const edm::Event &, const edm::EventSetup &)
 L1 GT EVM record comparison. More...
 
virtual void compareFDL (const edm::Event &, const edm::EventSetup &, const L1GtFdlWord &, const L1GtFdlWord &, const int)
 compare the FDL board More...
 
virtual void compareGt_Gct (const edm::Event &, const edm::EventSetup &)
 
virtual void compareGTFE (const edm::Event &, const edm::EventSetup &, const L1GtfeWord &, const L1GtfeWord &)
 compare the GTFE board More...
 
virtual void comparePSB (const edm::Event &, const edm::EventSetup &, const L1GtPsbWord &, const L1GtPsbWord &)
 compare the PSB board More...
 
virtual void compareTCS (const edm::Event &, const edm::EventSetup &, const L1TcsWord &, const L1TcsWord &)
 compare the TCS board More...
 
virtual void endJob ()
 end of job More...
 

Private Attributes

TH1F * m_fdlDataAlgoDecision [TotalBxInEvent][2]
 
TH1F * m_fdlDataAlgoDecision_Err [2]
 
TH1F * m_fdlDataAlgoDecisionMask [TotalBxInEvent][2]
 
TH1F * m_fdlDataEmul [TotalBxInEvent][2]
 FDL (0 for DAQ, 1 for EVM record) More...
 
TH1F * m_fdlDataEmul_Err [2]
 
TH1F * m_fdlDataEmulAlgoDecision [TotalBxInEvent][2]
 
TH1F * m_fdlDataEmulAlgoDecision_Err [2]
 
TH1F * m_fdlDataEmulAlgoDecisionMask [TotalBxInEvent][2]
 
TH1F * m_fdlDataEmulTechDecision [TotalBxInEvent][2]
 
TH1F * m_fdlDataEmulTechDecision_Err [2]
 
TH1F * m_fdlDataEmulTechDecisionMask [TotalBxInEvent][2]
 
TH1F * m_fdlDataTechDecision [TotalBxInEvent][2]
 
TH1F * m_fdlDataTechDecision_Err [2]
 
TH1F * m_fdlDataTechDecisionMask [TotalBxInEvent][2]
 
TH1F * m_fdlEmulAlgoDecision [TotalBxInEvent][2]
 
TH1F * m_fdlEmulAlgoDecision_Err [2]
 
TH1F * m_fdlEmulAlgoDecisionMask [TotalBxInEvent][2]
 
TH1F * m_fdlEmulTechDecision [TotalBxInEvent][2]
 
TH1F * m_fdlEmulTechDecision_Err [2]
 
TH1F * m_fdlEmulTechDecisionMask [TotalBxInEvent][2]
 
TH1F * m_gtfeDataEmul
 histograms More...
 
edm::InputTag m_l1GctDataInputTag
 input tag for the L1 GCT hardware record More...
 
edm::InputTag m_l1GtDataInputTag
 input tag for the L1 GT hardware DAQ/EVM record More...
 
edm::InputTag m_l1GtEmulInputTag
 input tag for the L1 GT emulator DAQ/EVM record More...
 
const L1GtTriggerMenu * m_l1GtMenu
 trigger menu More...
 
unsigned long long m_l1GtMenuCacheID
 
const L1GtTriggerMask * m_l1GtTmAlgo
 trigger masks More...
 
unsigned long long m_l1GtTmAlgoCacheID
 
const L1GtTriggerMask * m_l1GtTmTech
 
unsigned long long m_l1GtTmTechCacheID
 
std::ostringstream m_myCoutStream
 
int m_nrDataEventError
 counters More...
 
int m_nrEmulEventError
 
std::vector< unsigned int > m_triggerMaskAlgoTrig
 
std::vector< unsigned int > m_triggerMaskTechTrig
 

Static Private Attributes

static const int TotalBxInEvent = 5
 

Additional Inherited Members

- Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer ModuleType
 
- Public Types inherited from edm::EDConsumerBase
typedef ProductLabels Labels
 
- Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (ConfigurationDescriptions &)
 
- Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > consumes (edm::InputTag const &tag)
 
EDGetToken consumes (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken consumes (TypeToGet const &id, edm::InputTag const &tag)
 
ConsumesCollector consumesCollector ()
 Use a ConsumesCollector to gather consumes information from helper functions. More...
 
template<typename ProductType , BranchType B = InEvent>
void consumesMany ()
 
void consumesMany (const TypeToGet &id)
 
template<BranchType B>
void consumesMany (const TypeToGet &id)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > mayConsume (edm::InputTag const &tag)
 
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 

Detailed Description

Description: compare hardware records with emulator records for L1 GT record.

Implementation: Get the L1 GT records from data and from emulator. Compare every board between data and emulator.

Author
: Vasile Mihai Ghete - HEPHY Vienna

Definition at line 48 of file L1GtDataEmulAnalyzer.h.

Constructor & Destructor Documentation

L1GtDataEmulAnalyzer::L1GtDataEmulAnalyzer ( const edm::ParameterSet &  parSet)
explicit

Definition at line 49 of file L1GtDataEmulAnalyzer.cc.

References bookHistograms(), edm::ParameterSet::getParameter(), LogDebug, m_l1GctDataInputTag, m_l1GtDataInputTag, m_l1GtEmulInputTag, m_l1GtMenuCacheID, m_l1GtTmAlgoCacheID, m_l1GtTmTechCacheID, m_nrDataEventError, and m_nrEmulEventError.

49  {
50 
51  // input tag for the L1 GT hardware DAQ/EVM record
52  m_l1GtDataInputTag = parSet.getParameter<edm::InputTag>("L1GtDataInputTag");
53 
54  // input tag for the L1 GT emulator DAQ/EVM record
55  m_l1GtEmulInputTag = parSet.getParameter<edm::InputTag>("L1GtEmulInputTag");
56 
57  // input tag for the L1 GCT hardware record
58  m_l1GctDataInputTag
59  = parSet.getParameter<edm::InputTag>("L1GctDataInputTag");
60 
61  LogDebug("L1GtDataEmulAnalyzer")
62  << "\nInput tag for the L1 GT hardware records: "
63  << m_l1GtDataInputTag
64  << "\nInput tag for the L1 GT emulator records: "
65  << m_l1GtEmulInputTag
66  << "\nInput tag for the L1 GCT hardware record: "
67  << m_l1GctDataInputTag << std::endl;
68 
69  // initialize counters
70  m_nrDataEventError = 0;
71  m_nrEmulEventError = 0;
72 
73  // cache
74  m_l1GtMenuCacheID = 0ULL;
75 
76  m_l1GtTmAlgoCacheID = 0ULL;
77  m_l1GtTmTechCacheID = 0ULL;
78 
79 
80  // book histograms
81  bookHistograms();
82 
83 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
L1GtDataEmulAnalyzer::m_l1GtTmTechCacheID
unsigned long long m_l1GtTmTechCacheID
Definition: L1GtDataEmulAnalyzer.h:126
L1GtDataEmulAnalyzer::m_l1GtEmulInputTag
edm::InputTag m_l1GtEmulInputTag
input tag for the L1 GT emulator DAQ/EVM record
Definition: L1GtDataEmulAnalyzer.h:100
L1GtDataEmulAnalyzer::bookHistograms
void bookHistograms()
book all histograms for the module
Definition: L1GtDataEmulAnalyzer.cc:1278
L1GtDataEmulAnalyzer::m_l1GtDataInputTag
edm::InputTag m_l1GtDataInputTag
input tag for the L1 GT hardware DAQ/EVM record
Definition: L1GtDataEmulAnalyzer.h:97
L1GtDataEmulAnalyzer::m_l1GtMenuCacheID
unsigned long long m_l1GtMenuCacheID
Definition: L1GtDataEmulAnalyzer.h:119
L1GtDataEmulAnalyzer::m_l1GtTmAlgoCacheID
unsigned long long m_l1GtTmAlgoCacheID
Definition: L1GtDataEmulAnalyzer.h:123
L1GtDataEmulAnalyzer::m_l1GctDataInputTag
edm::InputTag m_l1GctDataInputTag
input tag for the L1 GCT hardware record
Definition: L1GtDataEmulAnalyzer.h:103
L1GtDataEmulAnalyzer::~L1GtDataEmulAnalyzer ( )

Definition at line 86 of file L1GtDataEmulAnalyzer.cc.

86  {
87  // empty
88 }

Member Function Documentation

void L1GtDataEmulAnalyzer::analyze ( const edm::Event &  iEvent,
const edm::EventSetup &  evSetup 
)
privatevirtual

analyze each event

Implements edm::EDAnalyzer.

Definition at line 1263 of file L1GtDataEmulAnalyzer.cc.

References compareDaqRecord(), compareEvmRecord(), and compareGt_Gct().

1264  {
1265 
1266  // L1 GT DAQ record comparison
1267  compareDaqRecord(iEvent, evSetup);
1268 
1269  // L1 GT EVM record comparison
1270  compareEvmRecord(iEvent, evSetup);
1271 
1272  // GCT collections from L1 GT PSB versus unpacked GCT
1273  compareGt_Gct(iEvent, evSetup);
1274 
1275 }
L1GtDataEmulAnalyzer::compareDaqRecord
virtual void compareDaqRecord(const edm::Event &, const edm::EventSetup &)
L1 GT DAQ record comparison.
Definition: L1GtDataEmulAnalyzer.cc:1101
L1GtDataEmulAnalyzer::compareGt_Gct
virtual void compareGt_Gct(const edm::Event &, const edm::EventSetup &)
Definition: L1GtDataEmulAnalyzer.cc:1255
L1GtDataEmulAnalyzer::compareEvmRecord
virtual void compareEvmRecord(const edm::Event &, const edm::EventSetup &)
L1 GT EVM record comparison.
Definition: L1GtDataEmulAnalyzer.cc:1246
void L1GtDataEmulAnalyzer::beginJob ( void  )
privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 93 of file L1GtDataEmulAnalyzer.cc.

93  {
94  // empty
95 }
void L1GtDataEmulAnalyzer::bookHistograms ( )
private

book all histograms for the module

Definition at line 1278 of file L1GtDataEmulAnalyzer.cc.

References m_fdlDataAlgoDecision, m_fdlDataAlgoDecision_Err, m_fdlDataAlgoDecisionMask, m_fdlDataEmul, m_fdlDataEmul_Err, m_fdlDataEmulAlgoDecision, m_fdlDataEmulAlgoDecision_Err, m_fdlDataEmulAlgoDecisionMask, m_fdlDataEmulTechDecision, m_fdlDataEmulTechDecision_Err, m_fdlDataEmulTechDecisionMask, m_fdlDataTechDecision, m_fdlDataTechDecision_Err, m_fdlDataTechDecisionMask, m_fdlEmulAlgoDecision, m_fdlEmulAlgoDecision_Err, m_fdlEmulAlgoDecisionMask, m_fdlEmulTechDecision, m_fdlEmulTechDecision_Err, m_fdlEmulTechDecisionMask, m_gtfeDataEmul, TFileDirectory::make(), TFileService::mkdir(), L1GlobalTriggerReadoutSetup::NumberPhysTriggers, L1GlobalTriggerReadoutSetup::NumberTechnicalTriggers, contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, and TotalBxInEvent.

Referenced by L1GtDataEmulAnalyzer().

1278  {
1279  // histogram service
1280  edm::Service<TFileService> histServ;
1281 
1282  // histograms
1283 
1284  // GTFE histograms
1285  TFileDirectory gtfeHist = histServ->mkdir("GTFE");
1286  m_gtfeDataEmul = gtfeHist.make<TH1F>("gtfeDataEmul", "GTFE data vs emul",
1287  6, 0., 6.);
1288  m_gtfeDataEmul->GetXaxis()->SetBinLabel(1, "BoardId");
1289  m_gtfeDataEmul->GetXaxis()->SetBinLabel(2, "RecordLength");
1290  m_gtfeDataEmul->GetXaxis()->SetBinLabel(3, "BxNr");
1291  m_gtfeDataEmul->GetXaxis()->SetBinLabel(4, "SetupVersion");
1292  m_gtfeDataEmul->GetXaxis()->SetBinLabel(5, "DaqActiveBoards");
1293  m_gtfeDataEmul->GetXaxis()->SetBinLabel(6, "TotalTriggerNr");
1294 
1295  // FDL histograms
1296 
1297  TFileDirectory fdlHist = histServ->mkdir("FDL");
1298 
1299  const unsigned int numberTechTriggers =
1300  L1GlobalTriggerReadoutSetup::NumberTechnicalTriggers;
1301 
1302  const unsigned int numberAlgoTriggers =
1303  L1GlobalTriggerReadoutSetup::NumberPhysTriggers;
1304 
1305  for (int iRec = 0; iRec < 2; ++iRec) {
1306 
1307  std::string recString;
1308  if (iRec == 0) {
1309  recString = "Daq";
1310  }
1311  else {
1312  recString = "Evm";
1313  }
1314 
1315  std::string hName;
1316  const char* histName;
1317 
1318  for (int iHist = 0; iHist < TotalBxInEvent; ++iHist) {
1319 
1320  // convert [0, TotalBxInEvent] to [-X, +X] and add to histogram name
1321  int iIndex = iHist - ((TotalBxInEvent + 1)/2 -1);
1322  int hIndex = (iIndex + 16)%16;
1323 
1324  std::stringstream ss;
1325  std::string str;
1326  ss << std::uppercase << std::hex << hIndex;
1327  ss >> str;
1328 
1329  hName = recString + "FdlDataEmul_" + str;
1330  histName = hName.c_str();
1331 
1332  std::string hTitle = "FDL data vs emul mismatch for BxInEvent = "
1333  + str;
1334  const char* histTitle = hTitle.c_str();
1335 
1336  //
1337 
1338  m_fdlDataEmul[iHist][iRec] = fdlHist.make<TH1F>(histName, histTitle,
1339  13, 0., 13.);
1340  m_fdlDataEmul[iHist][iRec]->GetXaxis()->SetBinLabel(1, "BoardId");
1341  m_fdlDataEmul[iHist][iRec]->GetXaxis()->SetBinLabel(2, "BxInEvent");
1342  m_fdlDataEmul[iHist][iRec]->GetXaxis()->SetBinLabel(3, "BxNr");
1343  m_fdlDataEmul[iHist][iRec]->GetXaxis()->SetBinLabel(4, "EventNr");
1344  m_fdlDataEmul[iHist][iRec]->GetXaxis()->SetBinLabel(5, "TechTrigger");
1345  m_fdlDataEmul[iHist][iRec]->GetXaxis()->SetBinLabel(6, "TechTriggerMask");
1346  m_fdlDataEmul[iHist][iRec]->GetXaxis()->SetBinLabel(7, "AlgoTrigger");
1347  m_fdlDataEmul[iHist][iRec]->GetXaxis()->SetBinLabel(8, "AlgoTriggerMask");
1348  m_fdlDataEmul[iHist][iRec]->GetXaxis()->SetBinLabel(9, "AlgoExtend");
1349  m_fdlDataEmul[iHist][iRec]->GetXaxis()->SetBinLabel(10, "NoAlgo");
1350  m_fdlDataEmul[iHist][iRec]->GetXaxis()->SetBinLabel(11, "FinalORAllParts");
1351  m_fdlDataEmul[iHist][iRec]->GetXaxis()->SetBinLabel(12, "FinalORPhysPart");
1352  m_fdlDataEmul[iHist][iRec]->GetXaxis()->SetBinLabel(13, "LocalBxNr");
1353 
1354  // algorithm decision
1355  // data
1356  hName = recString + "FdlDataAlgoDecision_" + str;
1357  histName = hName.c_str();
1358 
1359  hTitle = "Data: algorithm decision word for BxInEvent = " + str;
1360  histTitle = hTitle.c_str();
1361 
1362  m_fdlDataAlgoDecision[iHist][iRec] = fdlHist.make<TH1F>(histName,
1363  histTitle, numberAlgoTriggers, 0., numberAlgoTriggers);
1364 
1365  // emul
1366  hName = recString + "FdlEmulAlgoDecision_" + str;
1367  histName = hName.c_str();
1368 
1369  hTitle = "Emul: algorithm decision word for BxInEvent = " + str;
1370  histTitle = hTitle.c_str();
1371 
1372  m_fdlEmulAlgoDecision[iHist][iRec] = fdlHist.make<TH1F>(histName,
1373  histTitle, numberAlgoTriggers, 0., numberAlgoTriggers);
1374 
1375  // algorithm decision after masking (partition physics)
1376  // data
1377  hName = recString + "FdlDataAlgoDecisionMask_" + str;
1378  histName = hName.c_str();
1379 
1380  hTitle
1381  = "Data, physics partition: algorithm decision word after mask for BxInEvent = "
1382  + str;
1383  histTitle = hTitle.c_str();
1384 
1385  m_fdlDataAlgoDecisionMask[iHist][iRec] = fdlHist.make<TH1F>(histName,
1386  histTitle, numberAlgoTriggers, 0., numberAlgoTriggers);
1387 
1388  // emul
1389  hName = recString + "FdlEmulAlgoDecisionMask_" + str;
1390  histName = hName.c_str();
1391 
1392  hTitle
1393  = "Emul, physics partition: algorithm decision word after mask for BxInEvent = "
1394  + str;
1395  histTitle = hTitle.c_str();
1396 
1397  m_fdlEmulAlgoDecisionMask[iHist][iRec] = fdlHist.make<TH1F>(histName,
1398  histTitle, numberAlgoTriggers, 0., numberAlgoTriggers);
1399 
1400  //
1401  hName = recString + "FdlDataEmulAlgoDecision_" + str;
1402  histName = hName.c_str();
1403 
1404  hTitle
1405  = "Data vs emul: non-matching algorithm decision word for BxInEvent = "
1406  + str;
1407  histTitle = hTitle.c_str();
1408 
1409  m_fdlDataEmulAlgoDecision[iHist][iRec] = fdlHist.make<TH1F>(
1410  histName, histTitle, numberAlgoTriggers, 0.,
1411  numberAlgoTriggers);
1412 
1413  //
1414  hName = recString + "FdlDataEmulAlgoDecisionMask_" + str;
1415  histName = hName.c_str();
1416 
1417  hTitle
1418  = "Data vs emul, physics partition: non-matching algorithm decision word after mask for BxInEvent = "
1419  + str;
1420  histTitle = hTitle.c_str();
1421 
1422  m_fdlDataEmulAlgoDecisionMask[iHist][iRec] = fdlHist.make<TH1F>(
1423  histName, histTitle, numberAlgoTriggers, 0.,
1424  numberAlgoTriggers);
1425 
1426  // technical trigger decision
1427  // data
1428  hName = recString + "FdlDataTechDecision_" + str;
1429  histName = hName.c_str();
1430 
1431  hTitle = "Data technical trigger decision word for BxInEvent = "
1432  + str;
1433  histTitle = hTitle.c_str();
1434 
1435  m_fdlDataTechDecision[iHist][iRec] = fdlHist.make<TH1F>(histName,
1436  histTitle, numberTechTriggers, 0., numberTechTriggers);
1437 
1438  // emul
1439  hName = recString + "FdlEmulTechDecision_" + str;
1440  histName = hName.c_str();
1441 
1442  hTitle = "Emul: technical trigger decision word for BxInEvent = "
1443  + str;
1444  histTitle = hTitle.c_str();
1445 
1446  m_fdlEmulTechDecision[iHist][iRec] = fdlHist.make<TH1F>(histName,
1447  histTitle, numberTechTriggers, 0., numberTechTriggers);
1448 
1449  // technical trigger decision after masking (partition physics)
1450  hName = recString + "FdlDataTechDecisionMask_" + str;
1451  histName = hName.c_str();
1452 
1453  hTitle
1454  = "Data technical trigger decision word after mask for BxInEvent = "
1455  + str;
1456  histTitle = hTitle.c_str();
1457 
1458  m_fdlDataTechDecisionMask[iHist][iRec] = fdlHist.make<TH1F>(histName,
1459  histTitle, numberTechTriggers, 0., numberTechTriggers);
1460 
1461  //
1462  hName = recString + "FdlEmulTechDecisionMask_" + str;
1463  histName = hName.c_str();
1464 
1465  hTitle
1466  = "Emul: technical trigger decision word after mask for BxInEvent = "
1467  + str;
1468  histTitle = hTitle.c_str();
1469 
1470  m_fdlEmulTechDecisionMask[iHist][iRec] = fdlHist.make<TH1F>(histName,
1471  histTitle, numberTechTriggers, 0., numberTechTriggers);
1472 
1473  //
1474  hName = recString + "FdlDataEmulTechDecision_" + str;
1475  histName = hName.c_str();
1476 
1477  hTitle
1478  = "Data vs emul: non-matching technical trigger decision word for BxInEvent = "
1479  + str;
1480  histTitle = hTitle.c_str();
1481 
1482  m_fdlDataEmulTechDecision[iHist][iRec] = fdlHist.make<TH1F>(
1483  histName, histTitle, numberTechTriggers, 0.,
1484  numberTechTriggers);
1485 
1486  hName = recString + "FdlDataEmulTechDecisionMask_" + str;
1487  histName = hName.c_str();
1488 
1489  hTitle
1490  = "Data vs emul: non-matching technical trigger decision word after mask for BxInEvent = "
1491  + str;
1492  histTitle = hTitle.c_str();
1493 
1494  m_fdlDataEmulTechDecisionMask[iHist][iRec] = fdlHist.make<TH1F>(
1495  histName, histTitle, numberTechTriggers, 0.,
1496  numberTechTriggers);
1497 
1498  }
1499 
1500  hName = recString + "FdlDataEmul_Err";
1501  histName = hName.c_str();
1502 
1503  m_fdlDataEmul_Err[iRec] = fdlHist.make<TH1F>(histName,
1504  "FDL data vs emul: non-matching BxInEvent", 13, 0., 13.);
1505  m_fdlDataEmul_Err[iRec]->GetXaxis()->SetBinLabel(1, "BoardId");
1506  m_fdlDataEmul_Err[iRec]->GetXaxis()->SetBinLabel(2, "BxInEvent");
1507  m_fdlDataEmul_Err[iRec]->GetXaxis()->SetBinLabel(3, "BxNr");
1508  m_fdlDataEmul_Err[iRec]->GetXaxis()->SetBinLabel(4, "EventNr");
1509  m_fdlDataEmul_Err[iRec]->GetXaxis()->SetBinLabel(5, "TechTrigger");
1510  m_fdlDataEmul_Err[iRec]->GetXaxis()->SetBinLabel(6, "TechTriggerMask");
1511  m_fdlDataEmul_Err[iRec]->GetXaxis()->SetBinLabel(7, "AlgoTrigger");
1512  m_fdlDataEmul_Err[iRec]->GetXaxis()->SetBinLabel(8, "AlgoTriggerMask");
1513  m_fdlDataEmul_Err[iRec]->GetXaxis()->SetBinLabel(9, "AlgoExtend");
1514  m_fdlDataEmul_Err[iRec]->GetXaxis()->SetBinLabel(10, "NoAlgo");
1515  m_fdlDataEmul_Err[iRec]->GetXaxis()->SetBinLabel(11, "FinalORAllParts");
1516  m_fdlDataEmul_Err[iRec]->GetXaxis()->SetBinLabel(12, "FinalORPhysPart");
1517  m_fdlDataEmul_Err[iRec]->GetXaxis()->SetBinLabel(13, "LocalBxNr");
1518 
1519  hName = recString + "FdlDataAlgoDecision_Err";
1520  histName = hName.c_str();
1521 
1522  m_fdlDataAlgoDecision_Err[iRec]
1523  = fdlHist.make<TH1F>(
1524  histName,
1525  "Data: algorithm trigger decision word, non-matching BxInEvent",
1526  numberAlgoTriggers, 0., numberAlgoTriggers);
1527 
1528  //
1529  hName = recString + "FdlEmulAlgoDecision_Err";
1530  histName = hName.c_str();
1531 
1532  m_fdlEmulAlgoDecision_Err[iRec]
1533  = fdlHist.make<TH1F>(
1534  histName,
1535  "Emul: algorithm trigger decision word, non-matching BxInEvent",
1536  numberAlgoTriggers, 0., numberAlgoTriggers);
1537 
1538  hName = recString + "FdlDataEmulAlgoDecision_Err";
1539  histName = hName.c_str();
1540 
1541  m_fdlDataEmulAlgoDecision_Err[iRec]
1542  = fdlHist.make<TH1F>(
1543  histName,
1544  "Data vs emul: algorithm trigger decision word, non-matching BxInEvent",
1545  numberAlgoTriggers, 0., numberAlgoTriggers);
1546 
1547  //
1548  hName = recString + "FdlDataTechDecision_Err";
1549  histName = hName.c_str();
1550 
1551  m_fdlDataTechDecision_Err[iRec]
1552  = fdlHist.make<TH1F>(
1553  histName,
1554  "Data: technical trigger decision word, non-matching BxInEvent",
1555  numberTechTriggers, 0., numberTechTriggers);
1556 
1557  hName = recString + "FdlEmulTechDecision_Err";
1558  histName = hName.c_str();
1559 
1560  m_fdlEmulTechDecision_Err[iRec]
1561  = fdlHist.make<TH1F>(
1562  histName,
1563  "Emul: technical trigger decision word, non-matching BxInEvent",
1564  numberTechTriggers, 0., numberTechTriggers);
1565 
1566  hName = recString + "FdlDataEmulTechDecision_Err";
1567  histName = hName.c_str();
1568 
1569  m_fdlDataEmulTechDecision_Err[iRec]
1570  = fdlHist.make<TH1F>(
1571  histName,
1572  "Data vs emul: technical trigger decision word, non-matching BxInEvent",
1573  numberTechTriggers, 0., numberTechTriggers);
1574 
1575  }
1576 }
L1GtDataEmulAnalyzer::m_gtfeDataEmul
TH1F * m_gtfeDataEmul
histograms
Definition: L1GtDataEmulAnalyzer.h:136
L1GtDataEmulAnalyzer::m_fdlEmulTechDecision
TH1F * m_fdlEmulTechDecision[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:153
L1GtDataEmulAnalyzer::m_fdlDataEmul
TH1F * m_fdlDataEmul[TotalBxInEvent][2]
FDL (0 for DAQ, 1 for EVM record)
Definition: L1GtDataEmulAnalyzer.h:141
L1GtDataEmulAnalyzer::m_fdlEmulAlgoDecision
TH1F * m_fdlEmulAlgoDecision[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:144
L1GlobalTriggerReadoutSetup::NumberTechnicalTriggers
static const unsigned int NumberTechnicalTriggers
Definition: L1GlobalTriggerReadoutSetup.h:41
L1GtDataEmulAnalyzer::m_fdlDataEmulAlgoDecisionMask
TH1F * m_fdlDataEmulAlgoDecisionMask[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:150
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
L1GtDataEmulAnalyzer::m_fdlEmulAlgoDecisionMask
TH1F * m_fdlEmulAlgoDecisionMask[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:147
L1GtDataEmulAnalyzer::m_fdlDataEmulTechDecisionMask
TH1F * m_fdlDataEmulTechDecisionMask[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:159
L1GlobalTriggerReadoutSetup::NumberPhysTriggers
static const unsigned int NumberPhysTriggers
Definition: L1GlobalTriggerReadoutSetup.h:39
TFileDirectory::make
T * make(const Args &...args) const
make new ROOT object
Definition: TFileDirectory.h:59
L1GtDataEmulAnalyzer::m_fdlDataAlgoDecisionMask
TH1F * m_fdlDataAlgoDecisionMask[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:146
L1GtDataEmulAnalyzer::m_fdlEmulTechDecisionMask
TH1F * m_fdlEmulTechDecisionMask[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:156
L1GtDataEmulAnalyzer::m_fdlDataEmulTechDecision
TH1F * m_fdlDataEmulTechDecision[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:158
L1GtDataEmulAnalyzer::m_fdlDataAlgoDecision
TH1F * m_fdlDataAlgoDecision[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:143
L1GtDataEmulAnalyzer::TotalBxInEvent
static const int TotalBxInEvent
Definition: L1GtDataEmulAnalyzer.h:138
TFileService::mkdir
TFileDirectory mkdir(const std::string &dir, const std::string &descr="")
create a new subdirectory
Definition: TFileService.h:69
L1GtDataEmulAnalyzer::m_fdlDataEmulAlgoDecision
TH1F * m_fdlDataEmulAlgoDecision[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:149
L1GtDataEmulAnalyzer::m_fdlDataTechDecisionMask
TH1F * m_fdlDataTechDecisionMask[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:155
L1GtDataEmulAnalyzer::m_fdlDataTechDecision
TH1F * m_fdlDataTechDecision[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:152
void L1GtDataEmulAnalyzer::compareDaqRecord ( const edm::Event &  iEvent,
const edm::EventSetup &  evSetup 
)
privatevirtual

L1 GT DAQ record comparison.

Definition at line 1101 of file L1GtDataEmulAnalyzer.cc.

References L1GtPsbWord::boardId(), L1GtPsbWord::bxInEvent(), compareFDL(), compareGTFE(), comparePSB(), TauDecayModes::dec, edm::Event::getByLabel(), edm::HandleBase::isValid(), LogDebug, m_l1GtDataInputTag, m_l1GtEmulInputTag, m_myCoutStream, m_nrDataEventError, and m_nrEmulEventError.

Referenced by analyze().

1102  {
1103 
1104  // formal index for DAQ record
1105  int iRec = 0;
1106 
1107  // get the L1 GT hardware DAQ record L1GlobalTriggerReadoutRecord
1108  edm::Handle<L1GlobalTriggerReadoutRecord> gtReadoutRecordData;
1109  iEvent.getByLabel(m_l1GtDataInputTag, gtReadoutRecordData);
1110 
1111  bool validData = false;
1112 
1113  if (!gtReadoutRecordData.isValid()) {
1114  m_nrDataEventError++;
1115  }
1116  else {
1117  validData = true;
1118  }
1119 
1120  // get the L1 GT emulator DAQ record L1GlobalTriggerReadoutRecord
1121  edm::Handle<L1GlobalTriggerReadoutRecord> gtReadoutRecordEmul;
1122  iEvent.getByLabel(m_l1GtEmulInputTag, gtReadoutRecordEmul);
1123 
1124  bool validEmul = false;
1125 
1126  if (!gtReadoutRecordEmul.isValid()) {
1127  m_nrEmulEventError++;
1128  }
1129  else {
1130  validEmul = true;
1131  }
1132 
1133  if ((!validData) || (!validEmul)) {
1134  edm::LogWarning("L1GtDataEmulAnalyzer") << "\n Valid data:"
1135  << validData << "\n Valid emulator:" << validEmul << std::endl;
1136  }
1137 
1138  // compare GTFE
1139  const L1GtfeWord& gtfeBlockData = gtReadoutRecordData->gtfeWord();
1140  const L1GtfeWord& gtfeBlockEmul = gtReadoutRecordEmul->gtfeWord();
1141 
1142  compareGTFE(iEvent, evSetup, gtfeBlockData, gtfeBlockEmul);
1143 
1144  // FDL comparison
1145  const std::vector<L1GtFdlWord>& gtFdlVectorData =
1146  gtReadoutRecordData->gtFdlVector();
1147  const std::vector<L1GtFdlWord>& gtFdlVectorEmul =
1148  gtReadoutRecordEmul->gtFdlVector();
1149 
1150  int gtFdlVectorDataSize = gtFdlVectorData.size();
1151  int gtFdlVectorEmulSize = gtFdlVectorEmul.size();
1152 
1153  if (gtFdlVectorDataSize == gtFdlVectorEmulSize) {
1154  m_myCoutStream << "\nData and emulated FDL vector size: identical.\n";
1155  m_myCoutStream << " Size: " << gtFdlVectorDataSize << std::endl;
1156 
1157  for (int iFdl = 0; iFdl < gtFdlVectorDataSize; ++iFdl) {
1158 
1159  const L1GtFdlWord& fdlBlockData = gtFdlVectorData[iFdl];
1160  const L1GtFdlWord& fdlBlockEmul = gtFdlVectorEmul[iFdl];
1161 
1162  compareFDL(iEvent, evSetup, fdlBlockData, fdlBlockEmul, iRec);
1163  }
1164  }
1165  else {
1166  m_myCoutStream << "\nData and emulated FDL vector size: different.\n";
1167  m_myCoutStream << " Data: size = " << gtFdlVectorDataSize << std::endl;
1168  m_myCoutStream << " Emul: size = " << gtFdlVectorEmulSize << std::endl;
1169 
1170  }
1171 
1172  LogDebug("L1GtDataEmulAnalyzer") << m_myCoutStream.str() << std::endl;
1173 
1174  m_myCoutStream.str("");
1175  m_myCoutStream.clear();
1176 
1177  // PSB comparison
1178  const std::vector<L1GtPsbWord>& gtPsbVectorData =
1179  gtReadoutRecordData->gtPsbVector();
1180  const std::vector<L1GtPsbWord>& gtPsbVectorEmul =
1181  gtReadoutRecordEmul->gtPsbVector();
1182 
1183  int gtPsbVectorDataSize = gtPsbVectorData.size();
1184  int gtPsbVectorEmulSize = gtPsbVectorEmul.size();
1185 
1186  if (gtPsbVectorDataSize == gtPsbVectorEmulSize) {
1187  m_myCoutStream << "\nData and emulated PSB vector size: identical.\n";
1188  m_myCoutStream << " Size: " << gtPsbVectorDataSize << std::endl;
1189  }
1190  else {
1191  m_myCoutStream << "\nData and emulated PSB vector size: different.\n";
1192  m_myCoutStream << " Data: size = " << gtPsbVectorDataSize << std::endl;
1193  m_myCoutStream << " Emul: size = " << gtPsbVectorEmulSize << std::endl;
1194 
1195  }
1196 
1197  // the order of PSB block in the gtPsbVector is different in emulator and in data
1198  // in emulator: all active PSB in one BxInEvent, ordered L1A-1, L1A, L1A+1
1199  // in unpacker: every PSB in all BxInEvent
1200  for (int iPsb = 0; iPsb < gtPsbVectorDataSize; ++iPsb) {
1201 
1202  const L1GtPsbWord& psbBlockData = gtPsbVectorData[iPsb];
1203  const boost::uint16_t boardIdData = psbBlockData.boardId();
1204  const int bxInEventData = psbBlockData.bxInEvent();
1205 
1206  // search the corresponding PSB in the emulated record using the
1207  // BoardId and the BxInEvent
1208 
1209  bool foundPSB = false;
1210 
1211  for (int iPsbF = 0; iPsbF < gtPsbVectorEmulSize; ++iPsbF) {
1212 
1213  const L1GtPsbWord& psbBlockEmul = gtPsbVectorEmul[iPsbF];
1214  const boost::uint16_t boardIdEmul = psbBlockEmul.boardId();
1215  const int bxInEventEmul = psbBlockEmul.bxInEvent();
1216 
1217  if ((boardIdEmul == boardIdData)
1218  && (bxInEventData == bxInEventEmul)) {
1219 
1220  foundPSB = true;
1221 
1222  // compare the boards
1223  comparePSB(iEvent, evSetup, psbBlockData, psbBlockEmul);
1224  }
1225 
1226  }
1227 
1228  if (!foundPSB) {
1229  m_myCoutStream << "\nNo emulated PSB with boardId() = " << std::hex
1230  << "0x" << std::setw(4) << std::setfill('0') << boardIdData
1231  << std::setfill(' ') << std::dec << " and BxInEvent = "
1232  << bxInEventData << " was found";
1233 
1234  }
1235 
1236  }
1237 
1238  edm::LogInfo("L1GtDataEmulAnalyzer") << m_myCoutStream.str() << std::endl;
1239 
1240  m_myCoutStream.str("");
1241  m_myCoutStream.clear();
1242 
1243 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
L1GtPsbWord::boardId
const cms_uint16_t boardId() const
get/set board ID
Definition: L1GtPsbWord.h:66
L1GtDataEmulAnalyzer::compareGTFE
virtual void compareGTFE(const edm::Event &, const edm::EventSetup &, const L1GtfeWord &, const L1GtfeWord &)
compare the GTFE board
Definition: L1GtDataEmulAnalyzer.cc:98
L1GtDataEmulAnalyzer::m_l1GtEmulInputTag
edm::InputTag m_l1GtEmulInputTag
input tag for the L1 GT emulator DAQ/EVM record
Definition: L1GtDataEmulAnalyzer.h:100
L1GtDataEmulAnalyzer::m_myCoutStream
std::ostringstream m_myCoutStream
Definition: L1GtDataEmulAnalyzer.h:109
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:75
edm::Event::getByLabel
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
Definition: Event.h:413
L1GtPsbWord::bxInEvent
const int bxInEvent() const
get/set bunch cross in the GT event record
Definition: L1GtPsbWord.h:87
L1GtDataEmulAnalyzer::m_l1GtDataInputTag
edm::InputTag m_l1GtDataInputTag
input tag for the L1 GT hardware DAQ/EVM record
Definition: L1GtDataEmulAnalyzer.h:97
L1GtDataEmulAnalyzer::compareFDL
virtual void compareFDL(const edm::Event &, const edm::EventSetup &, const L1GtFdlWord &, const L1GtFdlWord &, const int)
compare the FDL board
Definition: L1GtDataEmulAnalyzer.cc:255
L1GtDataEmulAnalyzer::comparePSB
virtual void comparePSB(const edm::Event &, const edm::EventSetup &, const L1GtPsbWord &, const L1GtPsbWord &)
compare the PSB board
Definition: L1GtDataEmulAnalyzer.cc:906
void L1GtDataEmulAnalyzer::compareEvmRecord ( const edm::Event &  iEvent,
const edm::EventSetup &   
)
privatevirtual

L1 GT EVM record comparison.

Definition at line 1246 of file L1GtDataEmulAnalyzer.cc.

Referenced by analyze().

1247  {
1248 
1249  // FIXME
1250 
1251 }
void L1GtDataEmulAnalyzer::compareFDL ( const edm::Event &  iEvent,
const edm::EventSetup &  evSetup,
const L1GtFdlWord &  fdlBlockData,
const L1GtFdlWord &  fdlBlockEmul,
const int  iRec 
)
privatevirtual

compare the FDL board

Definition at line 255 of file L1GtDataEmulAnalyzer.cc.

References L1GtFdlWord::boardId(), L1GtFdlWord::bxInEvent(), L1GtFdlWord::bxNr(), TauDecayModes::dec, L1GtFdlWord::eventNr(), L1GtFdlWord::finalOR(), edm::EventSetup::get(), L1GtTriggerMenu::gtAlgorithmMap(), L1GtFdlWord::gtDecisionWord(), L1GtFdlWord::gtDecisionWordExtended(), L1GtFdlWord::gtTechnicalTriggerWord(), L1GtTriggerMask::gtTriggerMask(), L1GtFdlWord::localBxNr(), LogDebug, m_fdlDataAlgoDecision, m_fdlDataAlgoDecision_Err, m_fdlDataAlgoDecisionMask, m_fdlDataEmul, m_fdlDataEmul_Err, m_fdlDataEmulAlgoDecision, m_fdlDataEmulAlgoDecision_Err, m_fdlDataEmulAlgoDecisionMask, m_fdlDataEmulTechDecision, m_fdlDataEmulTechDecision_Err, m_fdlDataEmulTechDecisionMask, m_fdlDataTechDecision, m_fdlDataTechDecision_Err, m_fdlDataTechDecisionMask, m_fdlEmulAlgoDecision, m_fdlEmulAlgoDecision_Err, m_fdlEmulAlgoDecisionMask, m_fdlEmulTechDecision, m_fdlEmulTechDecision_Err, m_fdlEmulTechDecisionMask, m_l1GtMenu, m_l1GtMenuCacheID, m_l1GtTmAlgo, m_l1GtTmAlgoCacheID, m_l1GtTmTech, m_l1GtTmTechCacheID, m_myCoutStream, m_triggerMaskAlgoTrig, m_triggerMaskTechTrig, L1GtFdlWord::noAlgo(), L1GtFdlWord::print(), L1GtFdlWord::printGtDecisionWord(), L1GtFdlWord::printGtDecisionWordExtended(), L1GtFdlWord::printGtTechnicalTriggerWord(), edm::ESHandle< class >::product(), AlCaHLTBitMon_QueryRunRegistry::string, and TotalBxInEvent.

Referenced by compareDaqRecord().

257  {
258 
259  // index of physics partition
260  int PhysicsPartition = 0;
261 
262  //
263  std::string recString;
264  if (iRec == 0) {
265  recString = "Daq";
266  }
267  else {
268  recString = "Evm";
269  }
270 
271  if (fdlBlockData == fdlBlockEmul) {
272  m_myCoutStream << "\n" << recString
273  << " Data and emulated FDL blocks: identical.\n";
274  fdlBlockData.print(m_myCoutStream);
275 
276  }
277  else {
278  m_myCoutStream << "\n" << recString
279  << " Data and emulated FDL blocks: different.\n";
280 
281  m_myCoutStream << "\nData: FDL block\n";
282  fdlBlockData.print(m_myCoutStream);
283 
284  m_myCoutStream << "\nEmul: FDL block\n";
285  fdlBlockEmul.print(m_myCoutStream);
286 
287  }
288 
289  LogDebug("L1GtDataEmulAnalyzer") << m_myCoutStream.str() << std::endl;
290 
291  m_myCoutStream.str("");
292  m_myCoutStream.clear();
293 
294  // get bunch cross in the GT event record -
295  // move it first as histograms are BxInEvent dependent
296  const int bxInEventData = fdlBlockData.bxInEvent();
297  const int bxInEventEmul = fdlBlockEmul.bxInEvent();
298 
299  bool matchBxInEvent = false;
300 
301  if (bxInEventData == bxInEventEmul) {
302  m_myCoutStream << "\n" << recString
303  << " Data and emulated FDL bxInEvent identical.";
304  m_myCoutStream << "\n bxInEvent() = " << bxInEventData;
305  m_myCoutStream << "\n";
306  matchBxInEvent = true;
307 
308  }
309  else {
310  m_myCoutStream << "\n" << recString
311  << " Data and emulated FDL bxInEvent different.";
312  m_myCoutStream << "\n Data: bxInEvent() = " << bxInEventData;
313  m_myCoutStream << "\n Emul: bxInEvent() = " << bxInEventEmul;
314  m_myCoutStream << "\n";
315 
316  m_fdlDataEmul_Err[iRec]->Fill(1);
317  }
318 
319  LogDebug("L1GtDataEmulAnalyzer") << m_myCoutStream.str() << std::endl;
320  m_myCoutStream.str("");
321  m_myCoutStream.clear();
322 
323  // symmetrize
324  bool validBxInEvent = false;
325  int histIndex = bxInEventData + (TotalBxInEvent + 1)/2 -1;
326  if ((histIndex <= TotalBxInEvent) && (histIndex >= 0)) {
327  validBxInEvent = true;
328  }
329 
330  // get / update the trigger menu from the EventSetup
331  // local cache & check on cacheIdentifier
332 
333  unsigned long long l1GtMenuCacheID = evSetup.get<L1GtTriggerMenuRcd>().cacheIdentifier();
334 
335  if (m_l1GtMenuCacheID != l1GtMenuCacheID) {
336 
337  edm::ESHandle< L1GtTriggerMenu> l1GtMenu;
338  evSetup.get< L1GtTriggerMenuRcd>().get(l1GtMenu) ;
339  m_l1GtMenu = l1GtMenu.product();
340 
341  m_l1GtMenuCacheID = l1GtMenuCacheID;
342 
343  }
344  // get / update the trigger mask from the EventSetup
345  // local cache & check on cacheIdentifier
346 
347  unsigned long long l1GtTmAlgoCacheID =
348  evSetup.get<L1GtTriggerMaskAlgoTrigRcd>().cacheIdentifier();
349 
350  if (m_l1GtTmAlgoCacheID != l1GtTmAlgoCacheID) {
351 
352  edm::ESHandle< L1GtTriggerMask > l1GtTmAlgo;
353  evSetup.get< L1GtTriggerMaskAlgoTrigRcd >().get( l1GtTmAlgo );
354  m_l1GtTmAlgo = l1GtTmAlgo.product();
355 
356  m_triggerMaskAlgoTrig = m_l1GtTmAlgo->gtTriggerMask();
357 
358  m_l1GtTmAlgoCacheID = l1GtTmAlgoCacheID;
359 
360  }
361 
362 
363  unsigned long long l1GtTmTechCacheID =
364  evSetup.get<L1GtTriggerMaskTechTrigRcd>().cacheIdentifier();
365 
366  if (m_l1GtTmTechCacheID != l1GtTmTechCacheID) {
367 
368  edm::ESHandle< L1GtTriggerMask > l1GtTmTech;
369  evSetup.get< L1GtTriggerMaskTechTrigRcd >().get( l1GtTmTech );
370  m_l1GtTmTech = l1GtTmTech.product();
371 
372  m_triggerMaskTechTrig = m_l1GtTmTech->gtTriggerMask();
373 
374  m_l1GtTmTechCacheID = l1GtTmTechCacheID;
375 
376  }
377 
378 
379  // loop over algorithms and increase the corresponding counters
380  // FIXME put it back in cache
381  // FIXME when the menu changes, make a copy of histograms, and clear the old one
382  // otherwise the labels are wrong
383  const AlgorithmMap& algorithmMap = m_l1GtMenu->gtAlgorithmMap();
384 
385  for (CItAlgo itAlgo = algorithmMap.begin(); itAlgo != algorithmMap.end(); itAlgo++) {
386 
387  std::string aName = itAlgo->first;
388  const char* algName = aName.c_str();
389  int algBitNumber = (itAlgo->second).algoBitNumber();
390 
391  (m_fdlDataAlgoDecision[histIndex][iRec])->GetXaxis()->SetBinLabel(algBitNumber + 1, algName);
392  m_fdlDataAlgoDecision_Err[iRec]->GetXaxis()->SetBinLabel(algBitNumber + 1, algName);
393 
394  m_fdlEmulAlgoDecision[histIndex][iRec]->GetXaxis()->SetBinLabel(algBitNumber + 1, algName);
395  m_fdlEmulAlgoDecision_Err[iRec]->GetXaxis()->SetBinLabel(algBitNumber + 1, algName);
396 
397  m_fdlDataEmulAlgoDecision[histIndex][iRec]->GetXaxis()->SetBinLabel(algBitNumber + 1, algName);
398  m_fdlDataEmulAlgoDecision_Err[iRec]->GetXaxis()->SetBinLabel(algBitNumber + 1, algName);
399 
400  }
401 
402  // get BoardId value
403  const boost::uint16_t boardIdData = fdlBlockData.boardId();
404  const boost::uint16_t boardIdEmul = fdlBlockEmul.boardId();
405 
406  if (boardIdData == boardIdEmul) {
407  m_myCoutStream << "\n" << recString
408  << " Data and emulated FDL boardId identical.";
409  m_myCoutStream << "\n boardId() = " << std::hex << "0x" << std::setw(4)
410  << std::setfill('0') << boardIdData << std::setfill(' ')
411  << std::dec;
412  m_myCoutStream << "\n";
413 
414  }
415  else {
416  m_myCoutStream << "\n" << recString
417  << " Data and emulated FDL boardId different.";
418  m_myCoutStream << "\n Data: boardId() = " << std::hex << "0x"
419  << std::setw(4) << std::setfill('0') << boardIdData
420  << std::setfill(' ') << std::dec;
421  m_myCoutStream << "\n Emul: boardId() = " << std::hex << "0x"
422  << std::setw(4) << std::setfill('0') << boardIdEmul
423  << std::setfill(' ') << std::dec;
424  m_myCoutStream << "\n";
425 
426  if (matchBxInEvent && validBxInEvent) {
427  m_fdlDataEmul[histIndex][iRec]->Fill(0);
428  }
429  else {
430  m_fdlDataEmul_Err[iRec]->Fill(0);
431  }
432 
433  }
434 
435  LogDebug("L1GtDataEmulAnalyzer") << m_myCoutStream.str() << std::endl;
436  m_myCoutStream.str("");
437  m_myCoutStream.clear();
438 
439  // get BxNr - bunch cross number of the actual bx
440  const boost::uint16_t bxNrData = fdlBlockData.bxNr();
441  const boost::uint16_t bxNrEmul = fdlBlockEmul.bxNr();
442 
443  if (bxNrData == bxNrEmul) {
444  m_myCoutStream << "\n" << recString
445  << " Data and emulated FDL bxNr identical.";
446  m_myCoutStream << "\n bxNr() = " << bxNrData;
447  m_myCoutStream << "\n";
448 
449  }
450  else {
451  m_myCoutStream << "\n" << recString
452  << " Data and emulated FDL bxNr different.";
453  m_myCoutStream << "\n Data: bxNr() = " << bxNrData;
454  m_myCoutStream << "\n Emul: bxNr() = " << bxNrEmul;
455  m_myCoutStream << "\n";
456 
457  if (matchBxInEvent && validBxInEvent) {
458  m_fdlDataEmul[histIndex][iRec]->Fill(2);
459  }
460  else {
461  m_fdlDataEmul_Err[iRec]->Fill(2);
462  }
463  }
464 
465  LogDebug("L1GtDataEmulAnalyzer") << m_myCoutStream.str() << std::endl;
466  m_myCoutStream.str("");
467  m_myCoutStream.clear();
468 
469  // get event number since last L1 reset generated in FDL
470  const boost::uint32_t eventNrData = fdlBlockData.eventNr();
471  const boost::uint32_t eventNrEmul = fdlBlockEmul.eventNr();
472 
473  if (eventNrData == eventNrEmul) {
474  m_myCoutStream << "\n" << recString
475  << " Data and emulated FDL eventNr identical.";
476  m_myCoutStream << "\n eventNr() = " << eventNrData;
477  m_myCoutStream << "\n";
478 
479  }
480  else {
481  m_myCoutStream << "\n" << recString
482  << " Data and emulated FDL eventNr different.";
483  m_myCoutStream << "\n Data: eventNr() = " << eventNrData;
484  m_myCoutStream << "\n Emul: eventNr() = " << eventNrEmul;
485  m_myCoutStream << "\n";
486 
487  if (matchBxInEvent && validBxInEvent) {
488  m_fdlDataEmul[histIndex][iRec]->Fill(3);
489  }
490  else {
491  m_fdlDataEmul_Err[iRec]->Fill(3);
492  }
493 
494  }
495 
496  LogDebug("L1GtDataEmulAnalyzer") << m_myCoutStream.str() << std::endl;
497  m_myCoutStream.str("");
498  m_myCoutStream.clear();
499 
500  // get technical trigger bits
501  const TechnicalTriggerWord gtTechnicalTriggerWordData =
502  fdlBlockData.gtTechnicalTriggerWord();
503  const TechnicalTriggerWord gtTechnicalTriggerWordEmul =
504  fdlBlockEmul.gtTechnicalTriggerWord();
505 
506  int nTechBits = gtTechnicalTriggerWordData.size();
507 
508  TechnicalTriggerWord gtTechnicalTriggerWordDataMask(nTechBits);
509  TechnicalTriggerWord gtTechnicalTriggerWordEmulMask(nTechBits);
510 
511  unsigned int triggerMask = 0;
512  unsigned int bitValue = 0;
513 
514  if (matchBxInEvent && validBxInEvent) {
515  for (int iBit = 0; iBit < nTechBits; ++iBit) {
516 
517  triggerMask = (m_triggerMaskTechTrig.at(iBit)) & (1
518  << PhysicsPartition);
519 
520  if (gtTechnicalTriggerWordData[iBit]) {
521  m_fdlDataTechDecision[histIndex][iRec]->Fill(iBit);
522 
523  bitValue = (triggerMask) ? 0 : 1;
524  gtTechnicalTriggerWordDataMask[iBit] = bitValue;
525  if (bitValue) {
526  m_fdlDataTechDecisionMask[histIndex][iRec]->Fill(iBit);
527  }
528  }
529 
530  if (gtTechnicalTriggerWordEmul.at(iBit)) {
531  m_fdlEmulTechDecision[histIndex][iRec]->Fill(iBit);
532 
533  bitValue = (triggerMask) ? 0 : 1;
534  gtTechnicalTriggerWordEmulMask[iBit] = bitValue;
535  if (bitValue) {
536  m_fdlEmulTechDecisionMask[histIndex][iRec]->Fill(iBit);
537  }
538  }
539  }
540  }
541  else {
542  for (int iBit = 0; iBit < nTechBits; ++iBit) {
543 
544  if (gtTechnicalTriggerWordData[iBit]) {
545  m_fdlDataTechDecision_Err[iRec]->Fill(iBit);
546  }
547 
548  if (gtTechnicalTriggerWordEmul.at(iBit)) {
549  m_fdlEmulTechDecision_Err[iRec]->Fill(iBit);
550  }
551  }
552  }
553 
554  if (gtTechnicalTriggerWordData == gtTechnicalTriggerWordEmul) {
555  m_myCoutStream << "\n" << recString
556  << " Data and emulated FDL gtTechnicalTriggerWord identical.\n";
557  fdlBlockData.printGtTechnicalTriggerWord(m_myCoutStream);
558  m_myCoutStream << "\n";
559 
560  }
561  else {
562  m_myCoutStream << "\n" << recString
563  << " Data and emulated FDL gtTechnicalTriggerWord different.";
564  m_myCoutStream << "\n Data: ";
565  fdlBlockData.printGtTechnicalTriggerWord(m_myCoutStream);
566  m_myCoutStream << "\n Emul: ";
567  fdlBlockEmul.printGtTechnicalTriggerWord(m_myCoutStream);
568  m_myCoutStream << "\n";
569 
570  if (matchBxInEvent && validBxInEvent) {
571  m_fdlDataEmul[histIndex][iRec]->Fill(4);
572  }
573  else {
574  m_fdlDataEmul_Err[iRec]->Fill(4);
575  }
576 
577  if (matchBxInEvent && validBxInEvent) {
578  for (int iBit = 0; iBit < nTechBits; ++iBit) {
579  if (gtTechnicalTriggerWordData[iBit]
580  != gtTechnicalTriggerWordEmul.at(iBit)) {
581  m_fdlDataEmulTechDecision[histIndex][iRec]->Fill(iBit);
582  }
583  }
584  }
585  else {
586  for (int iBit = 0; iBit < nTechBits; ++iBit) {
587  if (gtTechnicalTriggerWordData[iBit]
588  != gtTechnicalTriggerWordEmul.at(iBit)) {
589  m_fdlDataEmulTechDecision_Err[iRec]->Fill(iBit);
590  }
591  }
592  }
593  }
594 
595  LogDebug("L1GtDataEmulAnalyzer") << m_myCoutStream.str() << std::endl;
596  m_myCoutStream.str("");
597  m_myCoutStream.clear();
598 
599  if (gtTechnicalTriggerWordDataMask == gtTechnicalTriggerWordEmulMask) {
600  m_myCoutStream << "\n" << recString
601  << " Data and emulated FDL gtTechnicalTriggerWord after mask identical.\n";
602  m_myCoutStream << "\n";
603 
604  }
605  else {
606  m_myCoutStream << "\n" << recString
607  << " Data and emulated FDL gtTechnicalTriggerWord after mask different.";
608  m_myCoutStream << "\n Data: ";
609  m_myCoutStream << "\n Emul: ";
610  m_myCoutStream << "\n";
611 
612  if (matchBxInEvent && validBxInEvent) {
613  m_fdlDataEmul[histIndex][iRec]->Fill(5);
614  }
615  else {
616  m_fdlDataEmul_Err[iRec]->Fill(5);
617  }
618 
619  if (matchBxInEvent && validBxInEvent) {
620  for (int iBit = 0; iBit < nTechBits; ++iBit) {
621  if (gtTechnicalTriggerWordData[iBit]
622  != gtTechnicalTriggerWordEmul.at(iBit)) {
623  m_fdlDataEmulTechDecisionMask[histIndex][iRec]->Fill(iBit);
624  }
625  }
626  }
627  }
628 
629  LogDebug("L1GtDataEmulAnalyzer") << m_myCoutStream.str() << std::endl;
630  m_myCoutStream.str("");
631  m_myCoutStream.clear();
632 
633  // get algorithms bits (decision word)
634  const DecisionWord gtDecisionWordData = fdlBlockData.gtDecisionWord();
635  const DecisionWord gtDecisionWordEmul = fdlBlockEmul.gtDecisionWord();
636 
637  int nAlgoBits = gtDecisionWordData.size();
638 
639  DecisionWord gtDecisionWordDataMask(nAlgoBits);
640  DecisionWord gtDecisionWordEmulMask(nAlgoBits);
641 
642  if (matchBxInEvent && validBxInEvent) {
643 
644  for (int iBit = 0; iBit < nAlgoBits; ++iBit) {
645 
646  triggerMask = (m_triggerMaskAlgoTrig.at(iBit))
647  & (1 << PhysicsPartition);
648 
649  if (gtDecisionWordData[iBit]) {
650  m_fdlDataAlgoDecision[histIndex][iRec]->Fill(iBit);
651 
652  bitValue = (triggerMask) ? 0 : 1;
653  gtDecisionWordDataMask[iBit] = bitValue;
654  if (bitValue) {
655  m_fdlDataAlgoDecisionMask[histIndex][iRec]->Fill(iBit);
656  }
657  }
658 
659  if (gtDecisionWordEmul.at(iBit)) {
660  m_fdlEmulAlgoDecision[histIndex][iRec]->Fill(iBit);
661 
662  bitValue = (triggerMask) ? 0 : 1;
663  gtDecisionWordEmulMask[iBit] = bitValue;
664  if (bitValue) {
665  m_fdlEmulAlgoDecisionMask[histIndex][iRec]->Fill(iBit);
666  }
667  }
668  }
669  }
670  else {
671  for (int iBit = 0; iBit < nAlgoBits; ++iBit) {
672  if (gtDecisionWordData[iBit]) {
673  m_fdlDataAlgoDecision_Err[iRec]->Fill(iBit);
674  }
675  }
676 
677  for (int iBit = 0; iBit < nAlgoBits; ++iBit) {
678  if (gtDecisionWordEmul.at(iBit)) {
679  m_fdlEmulAlgoDecision_Err[iRec]->Fill(iBit);
680  }
681  }
682  }
683 
684  if (gtDecisionWordData == gtDecisionWordEmul) {
685  m_myCoutStream << "\n" << recString
686  << " Data and emulated FDL gtDecisionWord identical.";
687  fdlBlockData.printGtDecisionWord(m_myCoutStream);
688  m_myCoutStream << "\n";
689 
690  }
691  else {
692  m_myCoutStream << "\n" << recString
693  << " Data and emulated FDL gtDecisionWord different.";
694  m_myCoutStream << "\n Data: ";
695  fdlBlockData.printGtDecisionWord(m_myCoutStream);
696  m_myCoutStream << "\n Emul: ";
697  fdlBlockEmul.printGtDecisionWord(m_myCoutStream);
698  m_myCoutStream << "\n";
699 
700  if (matchBxInEvent && validBxInEvent) {
701  m_fdlDataEmul[histIndex][iRec]->Fill(6);
702  }
703  else {
704  m_fdlDataEmul_Err[iRec]->Fill(6);
705  }
706 
707  if (matchBxInEvent && validBxInEvent) {
708  for (int iBit = 0; iBit < nAlgoBits; ++iBit) {
709  if (gtDecisionWordData[iBit] != gtDecisionWordEmul.at(iBit)) {
710  m_fdlDataEmulAlgoDecision[histIndex][iRec]->Fill(iBit);
711  }
712  }
713  }
714  else {
715  for (int iBit = 0; iBit < nAlgoBits; ++iBit) {
716  if (gtDecisionWordData[iBit] != gtDecisionWordEmul.at(iBit)) {
717  m_fdlDataEmulAlgoDecision_Err[iRec]->Fill(iBit);
718  }
719  }
720  }
721 
722  }
723 
724  if (gtDecisionWordDataMask == gtDecisionWordEmulMask) {
725  m_myCoutStream << "\n" << recString
726  << " Data and emulated FDL gtDecisionWord after mask identical.";
727  m_myCoutStream << "\n";
728 
729  }
730  else {
731  m_myCoutStream << "\n" << recString
732  << " Data and emulated FDL gtDecisionWord after mask different.";
733  m_myCoutStream << "\n Data: ";
734  m_myCoutStream << "\n Emul: ";
735  m_myCoutStream << "\n";
736 
737  if (matchBxInEvent && validBxInEvent) {
738  m_fdlDataEmul[histIndex][iRec]->Fill(7);
739  }
740  else {
741  m_fdlDataEmul_Err[iRec]->Fill(7);
742  }
743 
744  if (matchBxInEvent && validBxInEvent) {
745  for (int iBit = 0; iBit < nAlgoBits; ++iBit) {
746  if (gtDecisionWordDataMask[iBit] != gtDecisionWordEmulMask.at(iBit)) {
747  m_fdlDataEmulAlgoDecisionMask[histIndex][iRec]->Fill(iBit);
748  }
749  }
750  }
751 
752  }
753 
754  // get extended algorithms bits (extended decision word)
755  const DecisionWordExtended gtDecisionWordExtendedData =
756  fdlBlockData.gtDecisionWordExtended();
757  const DecisionWordExtended gtDecisionWordExtendedEmul =
758  fdlBlockEmul.gtDecisionWordExtended();
759 
760  if (gtDecisionWordExtendedData == gtDecisionWordExtendedEmul) {
761  m_myCoutStream << "\n" << recString
762  << " Data and emulated FDL gtDecisionWordExtended identical.\n";
763  fdlBlockData.printGtDecisionWordExtended(m_myCoutStream);
764  m_myCoutStream << "\n";
765 
766  }
767  else {
768  m_myCoutStream << "\n" << recString
769  << " Data and emulated FDL gtDecisionWordExtended different.\n";
770  m_myCoutStream << "\n Data: ";
771  fdlBlockData.printGtDecisionWordExtended(m_myCoutStream);
772  m_myCoutStream << "\n Emul: ";
773  fdlBlockEmul.printGtDecisionWordExtended(m_myCoutStream);
774  m_myCoutStream << "\n";
775 
776  if (matchBxInEvent && validBxInEvent) {
777  m_fdlDataEmul[histIndex][iRec]->Fill(8);
778  }
779  else {
780  m_fdlDataEmul_Err[iRec]->Fill(8);
781  }
782 
783  }
784 
785  // get NoAlgo
786  const boost::uint16_t noAlgoData = fdlBlockData.noAlgo();
787  const boost::uint16_t noAlgoEmul = fdlBlockEmul.noAlgo();
788 
789  if (noAlgoData == noAlgoEmul) {
790  m_myCoutStream << "\n" << recString
791  << " Data and emulated FDL noAlgo identical.";
792  m_myCoutStream << "\n noAlgo() = " << noAlgoData;
793  m_myCoutStream << "\n";
794 
795  }
796  else {
797  m_myCoutStream << "\n" << recString
798  << " Data and emulated FDL noAlgo different.";
799  m_myCoutStream << "\n Data: noAlgo() = " << noAlgoData;
800  m_myCoutStream << "\n Emul: noAlgo() = " << noAlgoEmul;
801  m_myCoutStream << "\n";
802 
803  if (matchBxInEvent && validBxInEvent) {
804  m_fdlDataEmul[histIndex][iRec]->Fill(9);
805  }
806  else {
807  m_fdlDataEmul_Err[iRec]->Fill(9);
808  }
809 
810  }
811 
812  // get "Final OR" bits
813  const boost::uint16_t finalORData = fdlBlockData.finalOR();
814  const boost::uint16_t finalOREmul = fdlBlockEmul.finalOR();
815 
816  if (finalORData == finalOREmul) {
817  m_myCoutStream << "\n" << recString
818  << " Data and emulated FDL finalOR identical.";
819  m_myCoutStream << "\n finalOR() = " << std::hex << "0x" << std::setw(2)
820  << std::setfill('0') << finalORData << std::setfill(' ')
821  << std::dec;
822  m_myCoutStream << "\n";
823 
824  }
825  else {
826  m_myCoutStream << "\n" << recString
827  << " Data and emulated FDL finalOR different.";
828  m_myCoutStream << "\n Data: finalOR() = " << std::hex << "0x"
829  << std::setw(2) << std::setfill('0') << finalORData
830  << std::setfill(' ') << std::dec;
831  m_myCoutStream << "\n Emul: finalOR() = " << std::hex << "0x"
832  << std::setw(2) << std::setfill('0') << finalOREmul
833  << std::setfill(' ') << std::dec;
834  m_myCoutStream << "\n";
835 
836  if (matchBxInEvent && validBxInEvent) {
837  m_fdlDataEmul[histIndex][iRec]->Fill(10);
838  }
839  else {
840  m_fdlDataEmul_Err[iRec]->Fill(10);
841  }
842 
843  }
844 
845  // get "Final OR" for physics partition
846  const int finalORPhysData = finalORData & (1 << PhysicsPartition);
847  const int finalORPhysEmul = finalOREmul & (1 << PhysicsPartition);
848 
849  if (finalORPhysData == finalORPhysEmul) {
850  m_myCoutStream << "\n" << recString
851  << " Data and emulated FDL finalOR for the physics partition identical.";
852  m_myCoutStream << "\n finalOR() = " << finalORPhysData;
853  m_myCoutStream << "\n";
854 
855  }
856  else {
857  m_myCoutStream << "\n" << recString
858  << " Data and emulated FDL finalOR for the physics partition different.";
859  m_myCoutStream << "\n Data: finalOR() = " << finalORPhysData;
860  m_myCoutStream << "\n Emul: finalOR() = " << finalORPhysEmul;
861  m_myCoutStream << "\n";
862 
863  if (matchBxInEvent && validBxInEvent) {
864  m_fdlDataEmul[histIndex][iRec]->Fill(11);
865  }
866  else {
867  m_fdlDataEmul_Err[iRec]->Fill(11);
868  }
869 
870  }
871 
872  // get local bunch cross number of the actual bx
873  const boost::uint16_t localBxNrData = fdlBlockData.localBxNr();
874  const boost::uint16_t localBxNrEmul = fdlBlockEmul.localBxNr();
875 
876  if (localBxNrData == localBxNrEmul) {
877  m_myCoutStream << "\n" << recString
878  << " Data and emulated FDL localBxNr identical.";
879  m_myCoutStream << "\n localBxNr() = " << localBxNrData;
880  m_myCoutStream << "\n";
881 
882  }
883  else {
884  m_myCoutStream << "\n" << recString
885  << " Data and emulated FDL localBxNr different.";
886  m_myCoutStream << "\n Data: localBxNr() = " << localBxNrData;
887  m_myCoutStream << "\n Emul: localBxNr() = " << localBxNrEmul;
888  m_myCoutStream << "\n";
889 
890  if (matchBxInEvent && validBxInEvent) {
891  m_fdlDataEmul[histIndex][iRec]->Fill(12);
892  }
893  else {
894  m_fdlDataEmul_Err[iRec]->Fill(12);
895  }
896 
897  }
898 
899  edm::LogInfo("L1GtDataEmulAnalyzer") << m_myCoutStream.str() << std::endl;
900  m_myCoutStream.str("");
901  m_myCoutStream.clear();
902 
903 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
L1GtFdlWord::gtTechnicalTriggerWord
const TechnicalTriggerWord & gtTechnicalTriggerWord() const
get/set technical trigger bits
Definition: L1GtFdlWord.h:149
L1GtFdlWord::noAlgo
const cms_uint16_t noAlgo() const
get/set NoAlgo
Definition: L1GtFdlWord.h:286
L1GtDataEmulAnalyzer::m_fdlEmulTechDecision
TH1F * m_fdlEmulTechDecision[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:153
L1GtDataEmulAnalyzer::m_fdlDataEmul
TH1F * m_fdlDataEmul[TotalBxInEvent][2]
FDL (0 for DAQ, 1 for EVM record)
Definition: L1GtDataEmulAnalyzer.h:141
L1GtDataEmulAnalyzer::m_fdlEmulAlgoDecision
TH1F * m_fdlEmulAlgoDecision[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:144
L1GtDataEmulAnalyzer::m_triggerMaskTechTrig
std::vector< unsigned int > m_triggerMaskTechTrig
Definition: L1GtDataEmulAnalyzer.h:129
AlgorithmMap
std::map< std::string, L1GtAlgorithm > AlgorithmMap
map containing the algorithms
Definition: L1GtTriggerMenuFwd.h:31
L1GtDataEmulAnalyzer::m_fdlDataEmulAlgoDecisionMask
TH1F * m_fdlDataEmulAlgoDecisionMask[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:150
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
L1GtDataEmulAnalyzer::m_l1GtTmTechCacheID
unsigned long long m_l1GtTmTechCacheID
Definition: L1GtDataEmulAnalyzer.h:126
L1GtDataEmulAnalyzer::m_fdlEmulAlgoDecisionMask
TH1F * m_fdlEmulAlgoDecisionMask[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:147
CItAlgo
AlgorithmMap::const_iterator CItAlgo
iterators through map containing the algorithms
Definition: L1GtTriggerMenuFwd.h:38
L1GtFdlWord::bxNr
const cms_uint16_t bxNr() const
get/set BxNr - bunch cross number of the actual bx
Definition: L1GtFdlWord.h:110
L1GtFdlWord::boardId
const cms_uint16_t boardId() const
get/set board ID
Definition: L1GtFdlWord.h:69
L1GtFdlWord::printGtDecisionWord
void printGtDecisionWord(std::ostream &myCout) const
Definition: L1GtFdlWord.cc:345
L1GtFdlWord::eventNr
const cms_uint32_t eventNr() const
get/set event number since last L1 reset generated in FDL
Definition: L1GtFdlWord.h:130
DecisionWordExtended
std::vector< bool > DecisionWordExtended
Definition: L1GlobalTriggerReadoutSetupFwd.h:38
L1GtTriggerMask::gtTriggerMask
const std::vector< unsigned int > & gtTriggerMask() const
get the trigger mask
Definition: L1GtTriggerMask.h:51
DecisionWord
std::vector< bool > DecisionWord
typedefs
Definition: L1GlobalTriggerReadoutSetupFwd.h:34
L1GtDataEmulAnalyzer::m_fdlDataEmulTechDecisionMask
TH1F * m_fdlDataEmulTechDecisionMask[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:159
L1GtFdlWord::bxInEvent
const int bxInEvent() const
get/set bunch cross in the GT event record
Definition: L1GtFdlWord.h:90
L1GtFdlWord::printGtDecisionWordExtended
void printGtDecisionWordExtended(std::ostream &myCout) const
Definition: L1GtFdlWord.cc:503
TechnicalTriggerWord
std::vector< bool > TechnicalTriggerWord
technical trigger bits (64 bits)
Definition: L1GlobalTriggerReadoutSetupFwd.h:41
L1GtDataEmulAnalyzer::m_myCoutStream
std::ostringstream m_myCoutStream
Definition: L1GtDataEmulAnalyzer.h:109
L1GtDataEmulAnalyzer::m_fdlDataAlgoDecisionMask
TH1F * m_fdlDataAlgoDecisionMask[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:146
L1GtDataEmulAnalyzer::m_fdlEmulTechDecisionMask
TH1F * m_fdlEmulTechDecisionMask[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:156
L1GtDataEmulAnalyzer::m_l1GtMenu
const L1GtTriggerMenu * m_l1GtMenu
trigger menu
Definition: L1GtDataEmulAnalyzer.h:118
L1GtDataEmulAnalyzer::m_triggerMaskAlgoTrig
std::vector< unsigned int > m_triggerMaskAlgoTrig
Definition: L1GtDataEmulAnalyzer.h:128
L1GtDataEmulAnalyzer::m_fdlDataEmulTechDecision
TH1F * m_fdlDataEmulTechDecision[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:158
L1GtFdlWord::print
void print(std::ostream &myCout) const
pretty print the content of a L1GtFdlWord
Definition: L1GtFdlWord.cc:766
L1GtDataEmulAnalyzer::m_l1GtTmAlgo
const L1GtTriggerMask * m_l1GtTmAlgo
trigger masks
Definition: L1GtDataEmulAnalyzer.h:122
L1GtDataEmulAnalyzer::m_fdlDataAlgoDecision
TH1F * m_fdlDataAlgoDecision[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:143
L1GtDataEmulAnalyzer::TotalBxInEvent
static const int TotalBxInEvent
Definition: L1GtDataEmulAnalyzer.h:138
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
L1GtDataEmulAnalyzer::m_fdlDataEmulAlgoDecision
TH1F * m_fdlDataEmulAlgoDecision[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:149
L1GtFdlWord::gtDecisionWord
const DecisionWord & gtDecisionWord() const
get/set/print algorithms bits (decision word)
Definition: L1GtFdlWord.h:171
L1GtDataEmulAnalyzer::m_l1GtMenuCacheID
unsigned long long m_l1GtMenuCacheID
Definition: L1GtDataEmulAnalyzer.h:119
L1GtDataEmulAnalyzer::m_fdlDataTechDecisionMask
TH1F * m_fdlDataTechDecisionMask[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:155
L1GtFdlWord::printGtTechnicalTriggerWord
void printGtTechnicalTriggerWord(std::ostream &myCout) const
Definition: L1GtFdlWord.cc:271
L1GtTriggerMenu::gtAlgorithmMap
const AlgorithmMap & gtAlgorithmMap() const
get / set the algorithm map (by name)
Definition: L1GtTriggerMenu.h:241
L1GtFdlWord::gtDecisionWordExtended
const DecisionWordExtended & gtDecisionWordExtended() const
get/set extended algorithms bits (extended decision word)
Definition: L1GtFdlWord.h:203
L1GtDataEmulAnalyzer::m_l1GtTmTech
const L1GtTriggerMask * m_l1GtTmTech
Definition: L1GtDataEmulAnalyzer.h:125
L1GtDataEmulAnalyzer::m_fdlDataTechDecision
TH1F * m_fdlDataTechDecision[TotalBxInEvent][2]
Definition: L1GtDataEmulAnalyzer.h:152
L1GtDataEmulAnalyzer::m_l1GtTmAlgoCacheID
unsigned long long m_l1GtTmAlgoCacheID
Definition: L1GtDataEmulAnalyzer.h:123
L1GtFdlWord::localBxNr
const cms_uint16_t localBxNr() const
get/set local bunch cross number of the actual bx
Definition: L1GtFdlWord.h:372
L1GtFdlWord::finalOR
const cms_uint16_t finalOR() const
get/set &quot;Final OR&quot; bits
Definition: L1GtFdlWord.h:306
void L1GtDataEmulAnalyzer::compareGt_Gct ( const edm::Event &  iEvent,
const edm::EventSetup &   
)
privatevirtual

compare the GCT collections obtained from L1 GT PSB with the input GCT collections

Definition at line 1255 of file L1GtDataEmulAnalyzer.cc.

Referenced by analyze().

1256  {
1257 
1258  // FIXME
1259 
1260 }
void L1GtDataEmulAnalyzer::compareGTFE ( const edm::Event &  iEvent,
const edm::EventSetup &  evSetup,
const L1GtfeWord &  gtfeBlockData,
const L1GtfeWord &  gtfeBlockEmul 
)
privatevirtual

compare the GTFE board

get record length: 3 bx for standard, 5 bx for debug

get bunch cross number as counted in the GTFE board

get setup version

get boards contributing to EVM respectively DAQ record

get total number of L1A sent since start of run

Definition at line 98 of file L1GtDataEmulAnalyzer.cc.

References L1GtfeWord::activeBoards(), L1GtfeWord::boardId(), L1GtfeWord::bxNr(), TauDecayModes::dec, LogDebug, m_gtfeDataEmul, m_myCoutStream, L1GtfeWord::print(), L1GtfeWord::recordLength(), L1GtfeWord::setupVersion(), and L1GtfeWord::totalTriggerNr().

Referenced by compareDaqRecord().

100  {
101 
102  if (gtfeBlockData == gtfeBlockEmul) {
103  m_myCoutStream << "\nData and emulated GTFE blocks: identical.\n";
104  gtfeBlockData.print(m_myCoutStream);
105  }
106  else {
107  m_myCoutStream << "\nData and emulated GTFE blocks: different.\n";
108 
109  m_myCoutStream << "\nData: GTFE block\n";
110  gtfeBlockData.print(m_myCoutStream);
111 
112  m_myCoutStream << "\nEmul: GTFE block\n";
113  gtfeBlockEmul.print(m_myCoutStream);
114 
115  }
116 
117  LogDebug("L1GtDataEmulAnalyzer") << m_myCoutStream.str() << std::endl;
118 
119  m_myCoutStream.str("");
120  m_myCoutStream.clear();
121 
122  // get BoardId value
123  const boost::uint16_t boardIdData = gtfeBlockData.boardId();
124  const boost::uint16_t boardIdEmul = gtfeBlockEmul.boardId();
125 
126  if (boardIdData == boardIdEmul) {
127  m_myCoutStream << "\nData and emulated GTFE boardId identical.";
128  m_myCoutStream << "\n boardId() = " << std::hex << "0x" << std::setw(4)
129  << std::setfill('0') << boardIdData << std::setfill(' ')
130  << std::dec;
131  m_myCoutStream << "\n";
132 
133  }
134  else {
135  m_myCoutStream << "\nData and emulated GTFE boardId different.";
136  m_myCoutStream << "\n Data: boardId() = " << std::hex << "0x"
137  << std::setw(4) << std::setfill('0') << boardIdData
138  << std::setfill(' ') << std::dec;
139  m_myCoutStream << "\n Emul: boardId() = " << std::hex << "0x"
140  << std::setw(4) << std::setfill('0') << boardIdEmul
141  << std::setfill(' ') << std::dec;
142  m_myCoutStream << "\n";
143  m_gtfeDataEmul->Fill(0);
144 
145  }
146 
148  const boost::uint16_t recordLengthData = gtfeBlockData.recordLength();
149  const boost::uint16_t recordLengthEmul = gtfeBlockEmul.recordLength();
150 
151  if (recordLengthData == recordLengthEmul) {
152  m_myCoutStream << "\nData and emulated GTFE recordLength identical.";
153  m_myCoutStream << "\n recordLength() = " << recordLengthData;
154  m_myCoutStream << "\n";
155 
156  }
157  else {
158  m_myCoutStream << "\nData and emulated GTFE recordLength different.";
159  m_myCoutStream << "\n Data: recordLength() = " << recordLengthData;
160  m_myCoutStream << "\n Emul: recordLength() = " << recordLengthEmul;
161  m_myCoutStream << "\n";
162  m_gtfeDataEmul->Fill(1);
163 
164  }
165 
167  const boost::uint16_t bxNrData = gtfeBlockData.bxNr();
168  const boost::uint16_t bxNrEmul = gtfeBlockEmul.bxNr();
169 
170  if (bxNrData == bxNrEmul) {
171  m_myCoutStream << "\nData and emulated GTFE bxNr identical.";
172  m_myCoutStream << "\n bxNr() = " << bxNrData;
173  m_myCoutStream << "\n";
174 
175  }
176  else {
177  m_myCoutStream << "\nData and emulated GTFE bxNr different.";
178  m_myCoutStream << "\n Data: bxNr() = " << bxNrData;
179  m_myCoutStream << "\n Emul: bxNr() = " << bxNrEmul;
180  m_myCoutStream << "\n";
181  m_gtfeDataEmul->Fill(2);
182 
183  }
184 
186  const boost::uint32_t setupVersionData = gtfeBlockData.setupVersion();
187  const boost::uint32_t setupVersionEmul = gtfeBlockEmul.setupVersion();
188 
189  if (setupVersionData == setupVersionEmul) {
190  m_myCoutStream << "\nData and emulated GTFE setupVersion identical.";
191  m_myCoutStream << "\n setupVersion() = " << setupVersionData;
192  m_myCoutStream << "\n";
193 
194  }
195  else {
196  m_myCoutStream << "\nData and emulated GTFE setupVersion different.";
197  m_myCoutStream << "\n Data: setupVersion() = " << setupVersionData;
198  m_myCoutStream << "\n Emul: setupVersion() = " << setupVersionEmul;
199  m_myCoutStream << "\n";
200  m_gtfeDataEmul->Fill(3);
201 
202  }
203 
205  const boost::uint16_t activeBoardsData = gtfeBlockData.activeBoards();
206  const boost::uint16_t activeBoardsEmul = gtfeBlockEmul.activeBoards();
207 
208  if (activeBoardsData == activeBoardsEmul) {
209  m_myCoutStream << "\nData and emulated GTFE activeBoards identical.";
210  m_myCoutStream << "\n activeBoards() = " << std::hex << "0x"
211  << std::setw(4) << std::setfill('0') << activeBoardsData
212  << std::setfill(' ') << std::dec;
213  m_myCoutStream << "\n";
214 
215  }
216  else {
217  m_myCoutStream << "\nData and emulated GTFE activeBoards different.";
218  m_myCoutStream << "\n Data: activeBoards() = " << std::hex << "0x"
219  << std::setw(4) << std::setfill('0') << activeBoardsData
220  << std::setfill(' ') << std::dec;
221  m_myCoutStream << "\n Emul: activeBoards() = " << std::hex << "0x"
222  << std::setw(4) << std::setfill('0') << activeBoardsEmul
223  << std::setfill(' ') << std::dec;
224  m_myCoutStream << "\n";
225  m_gtfeDataEmul->Fill(4);
226 
227  }
228 
230  const boost::uint32_t totalTriggerNrData = gtfeBlockData.totalTriggerNr();
231  const boost::uint32_t totalTriggerNrEmul = gtfeBlockEmul.totalTriggerNr();
232 
233  if (totalTriggerNrData == totalTriggerNrEmul) {
234  m_myCoutStream << "\nData and emulated GTFE totalTriggerNr identical.";
235  m_myCoutStream << "\n totalTriggerNr() = " << totalTriggerNrData;
236  m_myCoutStream << "\n";
237 
238  }
239  else {
240  m_myCoutStream << "\nData and emulated GTFE totalTriggerNr different.";
241  m_myCoutStream << "\n Data: totalTriggerNr() = " << totalTriggerNrData;
242  m_myCoutStream << "\n Emul: totalTriggerNr() = " << totalTriggerNrEmul;
243  m_myCoutStream << "\n";
244  m_gtfeDataEmul->Fill(5);
245 
246  }
247 
248  edm::LogInfo("L1GtDataEmulAnalyzer") << m_myCoutStream.str() << std::endl;
249  m_myCoutStream.str("");
250  m_myCoutStream.clear();
251 
252 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
L1GtDataEmulAnalyzer::m_gtfeDataEmul
TH1F * m_gtfeDataEmul
histograms
Definition: L1GtDataEmulAnalyzer.h:136
L1GtfeWord::print
virtual void print(std::ostream &myCout) const
pretty print the content of a L1GtfeWord
Definition: L1GtfeWord.cc:321
L1GtfeWord::recordLength
const cms_uint16_t recordLength() const
get/set record length for alternative 0
Definition: L1GtfeWord.h:104
L1GtfeWord::totalTriggerNr
const cms_uint32_t totalTriggerNr() const
get/set total number of L1A sent since start of run
Definition: L1GtfeWord.h:211
L1GtDataEmulAnalyzer::m_myCoutStream
std::ostringstream m_myCoutStream
Definition: L1GtDataEmulAnalyzer.h:109
L1GtfeWord::activeBoards
const cms_uint16_t activeBoards() const
get/set boards contributing to EVM respectively DAQ record
Definition: L1GtfeWord.h:163
L1GtfeWord::bxNr
const cms_uint16_t bxNr() const
get/set bunch cross number as counted in the GTFE board
Definition: L1GtfeWord.h:122
L1GtfeWord::boardId
const cms_uint16_t boardId() const
get/set board ID
Definition: L1GtfeWord.h:65
L1GtfeWord::setupVersion
const cms_uint32_t setupVersion() const
get/set setup version
Definition: L1GtfeWord.h:140
void L1GtDataEmulAnalyzer::comparePSB ( const edm::Event &  iEvent,
const edm::EventSetup &  evSetup,
const L1GtPsbWord &  psbBlockData,
const L1GtPsbWord &  psbBlockEmul 
)
privatevirtual

compare the PSB board

get/set A_DATA_CH_IA

get/set B_DATA_CH_IB

Definition at line 906 of file L1GtDataEmulAnalyzer.cc.

References L1GtPsbWord::aData(), L1GtPsbWord::bData(), L1GtPsbWord::boardId(), L1GtPsbWord::bxInEvent(), L1GtPsbWord::bxNr(), TauDecayModes::dec, L1GtPsbWord::eventNr(), L1GtPsbWord::localBxNr(), LogDebug, m_myCoutStream, L1GtPsbWord::NumberAData, L1GtPsbWord::NumberBData, and L1GtPsbWord::print().

Referenced by compareDaqRecord().

908  {
909 
910  if (psbBlockData == psbBlockEmul) {
911  m_myCoutStream << "\nData and emulated PSB blocks: identical.\n";
912  psbBlockData.print(m_myCoutStream);
913 
914  }
915  else {
916  m_myCoutStream << "\nData and emulated PSB blocks: different.\n";
917 
918  m_myCoutStream << "\nData: PSB block\n";
919  psbBlockData.print(m_myCoutStream);
920 
921  m_myCoutStream << "\nEmul: PSB block\n";
922  psbBlockEmul.print(m_myCoutStream);
923 
924  }
925 
926  LogDebug("L1GtDataEmulAnalyzer") << m_myCoutStream.str() << std::endl;
927 
928  m_myCoutStream.str("");
929  m_myCoutStream.clear();
930 
931  // get BoardId value
932  const boost::uint16_t boardIdData = psbBlockData.boardId();
933  const boost::uint16_t boardIdEmul = psbBlockEmul.boardId();
934 
935  if (boardIdData == boardIdEmul) {
936  m_myCoutStream << "\nData and emulated PSB boardId identical.";
937  m_myCoutStream << "\n boardId() = " << std::hex << "0x" << std::setw(4)
938  << std::setfill('0') << boardIdData << std::setfill(' ')
939  << std::dec;
940  m_myCoutStream << "\n";
941 
942  }
943  else {
944  m_myCoutStream << "\nData and emulated PSB boardId different.";
945  m_myCoutStream << "\n Data: boardId() = " << std::hex << "0x"
946  << std::setw(4) << std::setfill('0') << boardIdData
947  << std::setfill(' ') << std::dec;
948  m_myCoutStream << "\n Emul: boardId() = " << std::hex << "0x"
949  << std::setw(4) << std::setfill('0') << boardIdEmul
950  << std::setfill(' ') << std::dec;
951  m_myCoutStream << "\n";
952 
953  }
954 
955  // get bunch cross in the GT event record
956  const int bxInEventData = psbBlockData.bxInEvent();
957  const int bxInEventEmul = psbBlockEmul.bxInEvent();
958 
959  if (bxInEventData == bxInEventEmul) {
960  m_myCoutStream << "\nData and emulated PSB bxInEvent identical.";
961  m_myCoutStream << "\n bxInEvent() = " << bxInEventData;
962  m_myCoutStream << "\n";
963 
964  }
965  else {
966  m_myCoutStream << "\nData and emulated PSB bxInEvent different.";
967  m_myCoutStream << "\n Data: bxInEvent() = " << bxInEventData;
968  m_myCoutStream << "\n Emul: bxInEvent() = " << bxInEventEmul;
969  m_myCoutStream << "\n";
970 
971  }
972 
973  // get BxNr - bunch cross number of the actual bx
974  const boost::uint16_t bxNrData = psbBlockData.bxNr();
975  const boost::uint16_t bxNrEmul = psbBlockEmul.bxNr();
976 
977  if (bxNrData == bxNrEmul) {
978  m_myCoutStream << "\nData and emulated PSB bxNr identical.";
979  m_myCoutStream << "\n bxNr() = " << bxNrData;
980  m_myCoutStream << "\n";
981 
982  }
983  else {
984  m_myCoutStream << "\nData and emulated PSB bxNr different.";
985  m_myCoutStream << "\n Data: bxNr() = " << bxNrData;
986  m_myCoutStream << "\n Emul: bxNr() = " << bxNrEmul;
987  m_myCoutStream << "\n";
988 
989  }
990 
991  // get event number since last L1 reset generated in FDL
992  const boost::uint32_t eventNrData = psbBlockData.eventNr();
993  const boost::uint32_t eventNrEmul = psbBlockEmul.eventNr();
994 
995  if (eventNrData == eventNrEmul) {
996  m_myCoutStream << "\nData and emulated PSB eventNr identical.";
997  m_myCoutStream << "\n eventNr() = " << eventNrData;
998  m_myCoutStream << "\n";
999 
1000  }
1001  else {
1002  m_myCoutStream << "\nData and emulated PSB eventNr different.";
1003  m_myCoutStream << "\n Data: eventNr() = " << eventNrData;
1004  m_myCoutStream << "\n Emul: eventNr() = " << eventNrEmul;
1005  m_myCoutStream << "\n";
1006 
1007  }
1008 
1010  boost::uint16_t valData;
1011  boost::uint16_t valEmul;
1012 
1013  for (int iA = 0; iA < psbBlockData.NumberAData; ++iA) {
1014  valData = psbBlockData.aData(iA);
1015  valEmul = psbBlockEmul.aData(iA);
1016 
1017  if (valData == valEmul) {
1018  m_myCoutStream << "\nData and emulated PSB aData(" << iA
1019  << ") identical.";
1020  m_myCoutStream << "\n aData(iA) = " << std::hex << "0x"
1021  << std::setw(4) << std::setfill('0') << valData
1022  << std::setfill(' ') << std::dec;
1023  m_myCoutStream << "\n";
1024 
1025  }
1026  else {
1027  m_myCoutStream << "\nData and emulated PSB aData(" << iA
1028  << ") different.";
1029  m_myCoutStream << "\n Data: aData(iA) = " << std::hex << "0x"
1030  << std::setw(4) << std::setfill('0') << valData
1031  << std::setfill(' ') << std::dec;
1032  m_myCoutStream << "\n Emul: aData(iA) = "<< std::hex << "0x"
1033  << std::setw(4) << std::setfill('0') << valEmul
1034  << std::setfill(' ') << std::dec;
1035  m_myCoutStream << "\n";
1036 
1037  }
1038 
1039  }
1040 
1042  for (int iB = 0; iB < psbBlockData.NumberBData; ++iB) {
1043  valData = psbBlockData.bData(iB);
1044  valEmul = psbBlockEmul.bData(iB);
1045 
1046  if (valData == valEmul) {
1047  m_myCoutStream << "\nData and emulated PSB bData(" << iB
1048  << ") identical.";
1049  m_myCoutStream << "\n bData(iA) = " << std::hex << "0x"
1050  << std::setw(4) << std::setfill('0') << valData
1051  << std::setfill(' ') << std::dec;
1052  m_myCoutStream << "\n";
1053 
1054  }
1055  else {
1056  m_myCoutStream << "\nData and emulated PSB bData(" << iB
1057  << ") different.";
1058  m_myCoutStream << "\n Data: bData(iA) = " << std::hex << "0x"
1059  << std::setw(4) << std::setfill('0') << valData
1060  << std::setfill(' ') << std::dec;
1061  m_myCoutStream << "\n Emul: bData(iA) = "<< std::hex << "0x"
1062  << std::setw(4) << std::setfill('0') << valEmul
1063  << std::setfill(' ') << std::dec;
1064  m_myCoutStream << "\n";
1065 
1066  }
1067 
1068  }
1069 
1070  // get local bunch cross number of the actual bx
1071  const boost::uint16_t localBxNrData = psbBlockData.localBxNr();
1072  const boost::uint16_t localBxNrEmul = psbBlockEmul.localBxNr();
1073 
1074  if (localBxNrData == localBxNrEmul) {
1075  m_myCoutStream << "\nData and emulated PSB localBxNr identical.";
1076  m_myCoutStream << "\n localBxNr() = " << localBxNrData;
1077  m_myCoutStream << "\n";
1078 
1079  }
1080  else {
1081  m_myCoutStream << "\nData and emulated PSB localBxNr different.";
1082  m_myCoutStream << "\n Data: localBxNr() = " << localBxNrData;
1083  m_myCoutStream << "\n Emul: localBxNr() = " << localBxNrEmul;
1084  m_myCoutStream << "\n";
1085 
1086  }
1087 
1088  edm::LogInfo("L1GtDataEmulAnalyzer") << m_myCoutStream.str() << std::endl;
1089  m_myCoutStream.str("");
1090  m_myCoutStream.clear();
1091 
1092 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
L1GtPsbWord::bData
const cms_uint16_t bData(int iB) const
get/set B_DATA_CH_IB
Definition: L1GtPsbWord.cc:323
L1GtPsbWord::bxNr
const cms_uint16_t bxNr() const
get/set bunch cross number of the actual bx
Definition: L1GtPsbWord.h:108
L1GtPsbWord::boardId
const cms_uint16_t boardId() const
get/set board ID
Definition: L1GtPsbWord.h:66
L1GtPsbWord::aData
const cms_uint16_t aData(int iA) const
get/set A_DATA_CH_IA
Definition: L1GtPsbWord.cc:228
L1GtDataEmulAnalyzer::m_myCoutStream
std::ostringstream m_myCoutStream
Definition: L1GtDataEmulAnalyzer.h:109
L1GtPsbWord::localBxNr
const cms_uint16_t localBxNr() const
get/set local bunch cross number of the actual bx
Definition: L1GtPsbWord.h:178
L1GtPsbWord::print
void print(std::ostream &myCout) const
pretty print
Definition: L1GtPsbWord.cc:453
L1GtPsbWord::eventNr
const cms_uint32_t eventNr() const
get/set event number since last L1 reset generated in PSB
Definition: L1GtPsbWord.h:129
L1GtPsbWord::NumberBData
static const int NumberBData
Definition: L1GtPsbWord.h:35
L1GtPsbWord::bxInEvent
const int bxInEvent() const
get/set bunch cross in the GT event record
Definition: L1GtPsbWord.h:87
L1GtPsbWord::NumberAData
static const int NumberAData
Definition: L1GtPsbWord.h:34
void L1GtDataEmulAnalyzer::compareTCS ( const edm::Event &  iEvent,
const edm::EventSetup &  evSetup,
const L1TcsWord &  ,
const L1TcsWord &   
)
privatevirtual

compare the TCS board

Definition at line 1095 of file L1GtDataEmulAnalyzer.cc.

1096  {
1097  // empty
1098 }
void L1GtDataEmulAnalyzer::endJob ( void  )
privatevirtual

end of job

Reimplemented from edm::EDAnalyzer.

Definition at line 1579 of file L1GtDataEmulAnalyzer.cc.

1579  {
1580 
1581  // empty
1582 
1583 }

Member Data Documentation

TH1F* L1GtDataEmulAnalyzer::m_fdlDataAlgoDecision[TotalBxInEvent][2]
private

Definition at line 143 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlDataAlgoDecision_Err[2]
private

Definition at line 163 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlDataAlgoDecisionMask[TotalBxInEvent][2]
private

Definition at line 146 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlDataEmul[TotalBxInEvent][2]
private

FDL (0 for DAQ, 1 for EVM record)

Definition at line 141 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlDataEmul_Err[2]
private

Definition at line 161 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlDataEmulAlgoDecision[TotalBxInEvent][2]
private

Definition at line 149 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlDataEmulAlgoDecision_Err[2]
private

Definition at line 165 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlDataEmulAlgoDecisionMask[TotalBxInEvent][2]
private

Definition at line 150 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlDataEmulTechDecision[TotalBxInEvent][2]
private

Definition at line 158 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlDataEmulTechDecision_Err[2]
private

Definition at line 169 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlDataEmulTechDecisionMask[TotalBxInEvent][2]
private

Definition at line 159 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlDataTechDecision[TotalBxInEvent][2]
private

Definition at line 152 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlDataTechDecision_Err[2]
private

Definition at line 167 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlDataTechDecisionMask[TotalBxInEvent][2]
private

Definition at line 155 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlEmulAlgoDecision[TotalBxInEvent][2]
private

Definition at line 144 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlEmulAlgoDecision_Err[2]
private

Definition at line 164 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlEmulAlgoDecisionMask[TotalBxInEvent][2]
private

Definition at line 147 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlEmulTechDecision[TotalBxInEvent][2]
private

Definition at line 153 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlEmulTechDecision_Err[2]
private

Definition at line 168 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_fdlEmulTechDecisionMask[TotalBxInEvent][2]
private

Definition at line 156 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

TH1F* L1GtDataEmulAnalyzer::m_gtfeDataEmul
private

histograms

GTFE

Definition at line 136 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareGTFE().

edm::InputTag L1GtDataEmulAnalyzer::m_l1GctDataInputTag
private

input tag for the L1 GCT hardware record

Definition at line 103 of file L1GtDataEmulAnalyzer.h.

Referenced by L1GtDataEmulAnalyzer().

edm::InputTag L1GtDataEmulAnalyzer::m_l1GtDataInputTag
private

input tag for the L1 GT hardware DAQ/EVM record

Definition at line 97 of file L1GtDataEmulAnalyzer.h.

Referenced by compareDaqRecord(), and L1GtDataEmulAnalyzer().

edm::InputTag L1GtDataEmulAnalyzer::m_l1GtEmulInputTag
private

input tag for the L1 GT emulator DAQ/EVM record

Definition at line 100 of file L1GtDataEmulAnalyzer.h.

Referenced by compareDaqRecord(), and L1GtDataEmulAnalyzer().

const L1GtTriggerMenu* L1GtDataEmulAnalyzer::m_l1GtMenu
private

trigger menu

Definition at line 118 of file L1GtDataEmulAnalyzer.h.

Referenced by compareFDL().

unsigned long long L1GtDataEmulAnalyzer::m_l1GtMenuCacheID
private

Definition at line 119 of file L1GtDataEmulAnalyzer.h.

Referenced by compareFDL(), and L1GtDataEmulAnalyzer().

const L1GtTriggerMask* L1GtDataEmulAnalyzer::m_l1GtTmAlgo
private

trigger masks

Definition at line 122 of file L1GtDataEmulAnalyzer.h.

Referenced by compareFDL().

unsigned long long L1GtDataEmulAnalyzer::m_l1GtTmAlgoCacheID
private

Definition at line 123 of file L1GtDataEmulAnalyzer.h.

Referenced by compareFDL(), and L1GtDataEmulAnalyzer().

const L1GtTriggerMask* L1GtDataEmulAnalyzer::m_l1GtTmTech
private

Definition at line 125 of file L1GtDataEmulAnalyzer.h.

Referenced by compareFDL().

unsigned long long L1GtDataEmulAnalyzer::m_l1GtTmTechCacheID
private

Definition at line 126 of file L1GtDataEmulAnalyzer.h.

Referenced by compareFDL(), and L1GtDataEmulAnalyzer().

std::ostringstream L1GtDataEmulAnalyzer::m_myCoutStream
private

an output stream to print into it can then be directed to whatever log level is desired

Definition at line 109 of file L1GtDataEmulAnalyzer.h.

Referenced by compareDaqRecord(), compareFDL(), compareGTFE(), and comparePSB().

int L1GtDataEmulAnalyzer::m_nrDataEventError
private

counters

Definition at line 112 of file L1GtDataEmulAnalyzer.h.

Referenced by compareDaqRecord(), and L1GtDataEmulAnalyzer().

int L1GtDataEmulAnalyzer::m_nrEmulEventError
private

Definition at line 113 of file L1GtDataEmulAnalyzer.h.

Referenced by compareDaqRecord(), and L1GtDataEmulAnalyzer().

std::vector<unsigned int> L1GtDataEmulAnalyzer::m_triggerMaskAlgoTrig
private

Definition at line 128 of file L1GtDataEmulAnalyzer.h.

Referenced by compareFDL().

std::vector<unsigned int> L1GtDataEmulAnalyzer::m_triggerMaskTechTrig
private

Definition at line 129 of file L1GtDataEmulAnalyzer.h.

Referenced by compareFDL().

const int L1GtDataEmulAnalyzer::TotalBxInEvent = 5
staticprivate

Definition at line 138 of file L1GtDataEmulAnalyzer.h.

Referenced by bookHistograms(), and compareFDL().

Generated for CMSSW Reference Manual by doxygen 1.8.5