CMS 3D CMS Logo
List of all members | Public Member Functions | Private Member Functions | Private Attributes
cscdqm::EventProcessor Class Reference

Object used to process Events and compute statistics. More...

#include <CSCDQM_EventProcessor.h>

Public Member Functions

 EventProcessor (Configuration *const p_config)
 Constructor. More...
 
void init ()
 Initialize EventProcessor: reading out config information. More...
 
unsigned int maskHWElements (std::vector< std::string > &tokens)
 Mask HW elements from the efficiency calculations. Can be applied on runtime! More...
 
void standbyEfficiencyHistos (HWStandbyType &standby)
 apply standby flags/parameters More...
 
void updateEfficiencyHistos ()
 Update Efficiency MOs. More...
 
void updateFractionHistos ()
 Update Fractional MOs. More...
 
void writeShifterHistograms ()
 
 ~EventProcessor ()
 Destructor. More...
 

Private Member Functions

void calcEMUFractionHisto (const HistoId &result, const HistoId &set, const HistoId &subset)
 Calculate fractional histogram. More...
 
const bool getCSCFromMap (const unsigned int &crateId, const unsigned int &dmbId, unsigned int &cscType, unsigned int &cscPosition) const
 Get CSC type and position from crate and dmb identifiers. More...
 
const bool getCSCHisto (const HistoId &histo, const HwId &crateID, const HwId &dmbSlot, const HwId &adId, MonitorObject *&me)
 Get CSC (Chamber) Level Monitoring Object with additional identifier. More...
 
const bool getCSCHisto (const HistoId &histo, const HwId &crateID, const HwId &dmbSlot, MonitorObject *&me)
 Get CSC (Chamber) Level Monitoring Object. More...
 
const bool getDDUHisto (const HistoId &histo, const HwId &dduID, MonitorObject *&me)
 Get DDU Level Monitoring Object. More...
 
const bool getEMUHisto (const HistoId &histo, MonitorObject *&me)
 Get EMU (Top Level) Monitoring Object. More...
 
const bool getFEDHisto (const HistoId &histo, const HwId &fedID, MonitorObject *&me)
 Get FED Level Monitoring Object. More...
 
const bool getParHisto (const HistoId &histo, MonitorObject *&me)
 Get Parameter Monitoring Object. More...
 
void preProcessEvent ()
 Common Local and Global DQM function to be called before processing Event. More...
 
void processCSC (const CSCEventData &data, const int dduID, const CSCDCCExaminer &binChecker)
 Process Chamber Data and fill MOs. More...
 
void processDDU (const CSCDDUEventData &data, const CSCDCCExaminer &binChecker)
 Process DDU output and fill MOs. More...
 
bool processExaminer (const CSCDCCExaminer &binChecker)
 
bool processExaminer (const CSCDCCExaminer &binChecker, const CSCDCCFormatStatusDigi &digi)
 Fill monitor elements with CSCDCCFormatStatusDigi information. More...
 
void resetEmuEventDisplays ()
 Reset Emu level EventDisplay histograms once per event. More...
 
void setEmuEventDisplayBit (MonitorObject *&mo, const unsigned int x, const unsigned int y, const unsigned int bit)
 Set a single bit in the 3D Histogram (aka EMU level event display). Checks if mo and x != null. More...
 

Private Attributes

uint32_t BXN
 
uint32_t cntALCTs
 Total Number of CFEBs per event from DMB DAV. More...
 
uint32_t cntCFEBs
 Total Number of DMBs per event from DDU Header DAV. More...
 
uint32_t cntDMBs
 
uint32_t cntTMBs
 Total Number of ALCTs per event from DMB DAV. More...
 
Configuration * config
 
bool EmuEventDisplayWasReset
 
bool fCloseL1As
 Data Format version (2005, 2013) More...
 
std::map< uint32_t, bool > fNotFirstEvent
 
edm::EDGetTokenT< FEDRawDataCollection > frdtoken
 
uint32_t L1ANumber
 
std::map< uint32_t, uint32_t > L1ANumbers
 
Summary summary
 
uint16_t theFormatVersion
 Total Number of TMBs per event from DMB DAV. More...
 

Detailed Description

Object used to process Events and compute statistics.

Definition at line 99 of file CSCDQM_EventProcessor.h.

Constructor & Destructor Documentation

◆ EventProcessor()

cscdqm::EventProcessor::EventProcessor ( Configuration *const  p_config)

Constructor.

Parameters
p_configPointer to Global Configuration.

Definition at line 27 of file CSCDQM_EventProcessor.cc.

27  {
28  config = p_config;
29  // fFirstEvent = true;
30  fCloseL1As = true;
31  }

References fCloseL1As.

◆ ~EventProcessor()

cscdqm::EventProcessor::~EventProcessor ( )
inline

Destructor.

Definition at line 116 of file CSCDQM_EventProcessor.h.

116 {}

Member Function Documentation

◆ calcEMUFractionHisto()

void cscdqm::EventProcessor::calcEMUFractionHisto ( const HistoId &  result,
const HistoId &  set,
const HistoId &  subset 
)
private

Calculate fractional histogram.

Parameters
resultHistogram to write results to
setHistogram of the set
subsetHistogram of the subset

Definition at line 86 of file CSCDQM_EventProcessor_updateFracHistos.cc.

86  {
87  MonitorObject *mo = nullptr, *mo1 = nullptr, *mo2 = nullptr;
88 
89  if (getEMUHisto(result, mo) && getEMUHisto(set, mo2) && getEMUHisto(subset, mo1)) {
90  LockType lock(mo->mutex);
91  TH1* th = mo->getTH1Lock();
92  th->Reset();
93  th->Divide(mo1->getTH1(), mo2->getTH1());
94  mo->SetMaximum(1.);
95  }
96  }

References getEMUHisto(), cscdqm::MonitorObject::getTH1Lock(), CommonMethods::lock(), cscdqm::Lock::mutex, mps_fire::result, and cscdqm::MonitorObject::SetMaximum().

Referenced by updateFractionHistos().

◆ getCSCFromMap()

const bool cscdqm::EventProcessor::getCSCFromMap ( const unsigned int &  crateId,
const unsigned int &  dmbId,
unsigned int &  cscType,
unsigned int &  cscPosition 
) const
private

Get CSC type and position from crate and dmb identifiers.

Parameters
crateIdCSC crate identifier
dmbIdCSC DMB identifier
cscTypeCSC Type identifier to return
cscPositionCSC Position identifier to return
Returns
true if parameters where found and filled, false - otherwise

Definition at line 170 of file CSCDQM_EventProcessor.cc.

173  {
174  bool result = false;
175 
176  CSCDetId cid;
177  if (config->fnGetCSCDetId(crateId, dmbId, cid)) {
178  cscPosition = cid.chamber();
179  int iring = cid.ring();
180  int istation = cid.station();
181  int iendcap = cid.endcap();
182  std::string tlabel = cscdqm::Utility::getCSCTypeLabel(iendcap, istation, iring);
183  cscType = cscdqm::Utility::getCSCTypeBin(tlabel);
184  result = true;
185  }
186 
187  /*
188  if (!result) {
189  LOG_ERROR << "Event #" << config->getNEvents() << ": Invalid CSC=" << CSCHistoDef::getPath(crateId, dmbId);
190  }
191  */
192 
193  return result;
194  }

References CSCDetId::chamber(), CSCDetId::endcap(), cscdqm::Utility::getCSCTypeBin(), cscdqm::Utility::getCSCTypeLabel(), mps_fire::result, CSCDetId::ring(), CSCDetId::station(), AlCaHLTBitMon_QueryRunRegistry::string, and compare::tlabel.

Referenced by processCSC(), and processExaminer().

◆ getCSCHisto() [1/2]

const bool cscdqm::EventProcessor::getCSCHisto ( const HistoId &  histo,
const HwId &  crateID,
const HwId &  dmbSlot,
const HwId &  adId,
MonitorObject *&  me 
)
private

Get CSC (Chamber) Level Monitoring Object with additional identifier.

Parameters
histoMO identification
crateIDChamber Crate identifier
dmbSlotChamber DMB identifier
adIdAdditional identifier, i.e. Layer number, CLCT number, etc.
meMO to return
Returns
true if MO was found, false - otherwise

Definition at line 137 of file CSCDQM_EventProcessor.cc.

138  {
139  if (config->fnGetCacheCSCHisto(histo, crateID, dmbSlot, adId, me))
140  return (me != nullptr);
141  CSCHistoDef histoD(histo, crateID, dmbSlot, adId);
142  if (config->fnGetHisto(histoD, me))
143  return (me != nullptr);
144  return false;
145  }

References timingPdfMaker::histo, and hlt_dqm_clientPB-live_cfg::me.

◆ getCSCHisto() [2/2]

const bool cscdqm::EventProcessor::getCSCHisto ( const HistoId &  histo,
const HwId &  crateID,
const HwId &  dmbSlot,
MonitorObject *&  me 
)
private

Get CSC (Chamber) Level Monitoring Object.

Parameters
histoMO identification
crateIDChamber Crate identifier
dmbSlotChamber DMB identifier
meMO to return
Returns
true if MO was found, false - otherwise

Definition at line 115 of file CSCDQM_EventProcessor.cc.

118  {
119  if (config->fnGetCacheCSCHisto(histo, crateID, dmbSlot, 0, me))
120  return (me != nullptr);
121  CSCHistoDef histoD(histo, crateID, dmbSlot);
122  if (config->fnGetHisto(histoD, me))
123  return (me != nullptr);
124  return false;
125  }

References timingPdfMaker::histo, and hlt_dqm_clientPB-live_cfg::me.

Referenced by processCSC(), processExaminer(), and updateFractionHistos().

◆ getDDUHisto()

const bool cscdqm::EventProcessor::getDDUHisto ( const HistoId &  histo,
const HwId &  dduID,
MonitorObject *&  me 
)
private

Get DDU Level Monitoring Object.

Parameters
histoMO identification
dduIDDDU identifier
meMO to return
Returns
true if MO was found, false - otherwise

Definition at line 98 of file CSCDQM_EventProcessor.cc.

98  {
99  if (config->fnGetCacheDDUHisto(histo, dduID, me))
100  return (me != nullptr);
101  DDUHistoDef histoD(histo, dduID);
102  if (config->fnGetHisto(histoD, me))
103  return (me != nullptr);
104  return false;
105  }

References timingPdfMaker::histo, and hlt_dqm_clientPB-live_cfg::me.

Referenced by processDDU().

◆ getEMUHisto()

const bool cscdqm::EventProcessor::getEMUHisto ( const HistoId &  histo,
MonitorObject *&  me 
)
private

Get EMU (Top Level) Monitoring Object.

Parameters
histoMO identification
meMO to return
Returns
true if MO was found, false - otherwise

Definition at line 66 of file CSCDQM_EventProcessor.cc.

66  {
67  if (config->fnGetCacheEMUHisto(histo, me))
68  return (me != nullptr);
69  EMUHistoDef histoD(histo);
70  if (config->fnGetHisto(histoD, me))
71  return (me != nullptr);
72  return false;
73  }

References timingPdfMaker::histo, and hlt_dqm_clientPB-live_cfg::me.

Referenced by calcEMUFractionHisto(), processCSC(), processDDU(), processExaminer(), resetEmuEventDisplays(), standbyEfficiencyHistos(), updateEfficiencyHistos(), and writeShifterHistograms().

◆ getFEDHisto()

const bool cscdqm::EventProcessor::getFEDHisto ( const HistoId &  histo,
const HwId &  fedID,
MonitorObject *&  me 
)
private

Get FED Level Monitoring Object.

Parameters
histoMO identification
fedIDFED identifier
meMO to return
Returns
true if MO was found, false - otherwise

Definition at line 82 of file CSCDQM_EventProcessor.cc.

82  {
83  if (config->fnGetCacheFEDHisto(histo, fedID, me))
84  return (me != nullptr);
85  FEDHistoDef histoD(histo, fedID);
86  if (config->fnGetHisto(histoD, me))
87  return (me != nullptr);
88  return false;
89  }

References timingPdfMaker::histo, and hlt_dqm_clientPB-live_cfg::me.

◆ getParHisto()

const bool cscdqm::EventProcessor::getParHisto ( const HistoId &  histo,
MonitorObject *&  me 
)
private

Get Parameter Monitoring Object.

Parameters
histoMO identification
meMO to return
Returns
true if MO was found, false - otherwise

Definition at line 153 of file CSCDQM_EventProcessor.cc.

153  {
154  if (config->fnGetCacheParHisto(histo, me))
155  return (me != nullptr);
156  ParHistoDef histoD(histo);
157  if (config->fnGetHisto(histoD, me))
158  return (me != nullptr);
159  return false;
160  }

References timingPdfMaker::histo, and hlt_dqm_clientPB-live_cfg::me.

Referenced by updateEfficiencyHistos().

◆ init()

void cscdqm::EventProcessor::init ( void  )

Initialize EventProcessor: reading out config information.

Definition at line 58 of file CSCDQM_EventProcessor.cc.

58 {}

Referenced by cscdqm::Dispatcher::book().

◆ maskHWElements()

unsigned int cscdqm::EventProcessor::maskHWElements ( std::vector< std::string > &  tokens)

Mask HW elements from the efficiency calculations. Can be applied on runtime!

Parameters
tokensString tokens of the HW elements
Returns
elements masked

Definition at line 202 of file CSCDQM_EventProcessor.cc.

202  {
203  unsigned int masked = summary.setMaskedHWElements(tokens);
204  LOG_INFO << masked << " HW Elements masked";
205  return masked;
206  }

References LOG_INFO, cscdqm::Summary::setMaskedHWElements(), and summary.

Referenced by cscdqm::EventProcessorMutex::maskHWElements().

◆ preProcessEvent()

void cscdqm::EventProcessor::preProcessEvent ( )
private

Common Local and Global DQM function to be called before processing Event.

Definition at line 26 of file CSCDQM_EventProcessor_processEvent.cc.

26  {
27  config->incNEvents();
28  EmuEventDisplayWasReset = false;
29  }

References EmuEventDisplayWasReset.

◆ processCSC()

void cscdqm::EventProcessor::processCSC ( const CSCEventData &  data,
const int  dduID,
const CSCDCCExaminer &  binChecker 
)
private

Process Chamber Data and fill MOs.

Parameters
dataChamber data to process
dduIDDDU identifier

DMB Found

Unpacking of DMB Header and trailer

Unpacking of Chamber Identification number

Efficiency of the chamber

Unpacking L1A number from DMB header

DMB L1A: 8bits (256)

DDU L1A: 24bits

Calculate difference between L1A numbers from DDU and DMB

LOG_DEBUG << dmbHeaderL1A << " : DMB L1A - DDU L1A = " << dmb_ddu_l1a_diff;

Unpacking BXN number from DMB header

== DMB BXN: 12bits (4096) call bxn12(), bxn() return 7bits value

== DDU BXN: 12bits (4096)

== Use 6-bit BXN

Calculation difference between BXN numbers from DDU and DMB

dmb_ddu_bxn_diff = (int)(dmbHeaderBXN-(int)(BXN&0x7F)); // For older DMB

LOG_DEBUG << dmbHeaderBXN << " : DMB BXN - DDU BXN = " << dmb_ddu_bxn_diff;

if (getCSCHisto(h::CSC_DMB_BXN_VS_DDU_BXN, crateID, dmbID, mo)) mo->Fill((int)(BXN), (int)dmbHeaderBXN);

Unpacking CFEB information from DMB header

mo->SetEntries(config->getNEvents());

if (getCSCHisto(h::CSC_DMB_CFEB_ACTIVE, crateID, dmbID, mo) mo->Fill((dmbTrailer->header_1a>>5)&0x1F); //KK

if (getCSCHisto(h::CSC_DMB_CFEB_ACTIVE_VS_DAV, crateID, dmbID, mo)) mo->Fill(dmbHeader->cfebAvailable(),(int)((dmbTrailer->header_1a>>5)&0x1F)); //KK

if (getCSCHisto(h::CSC_DMB_CFEB_ACTIVE_VS_DAV, crateID, dmbID, mo)) mo->Fill(dmbHeader->cfebAvailable(),dmbHeader->cfebActive()); //KK

DMB input (7 in total) FIFO stuff goes here

DMB input timeout (total 15 bits) goes here

Get FEBs Data Available Info

Fill Hisogram for FEB DAV Efficiency

Fill Hisogram for Different Combinations of FEB DAV Efficiency

ALCT Found

Set number of ALCT-events to third bin

KK

h[hname]->SetBinContent(3, ((float)ALCTEvent/(float)(config->getNEvents()) * 100.0));

KKend

== ALCT2007 L1A: 12bits (4096)

== ALCT2006 L1A: 4bits (16)

== Use 6-bit L1A

int alct_dmb_l1a_diff = (int)((dmbHeader->l1a()&0xF)-alctHeader->L1Acc());

if (getCSCHisto(h::CSC_DMB_L1A_VS_ALCT_L1A, crateID, dmbID, mo)) mo->Fill(alctHeader->L1Acc(),dmbHeader->l1a());

=== ALCT BXN: 12bits (4096)

=== Use 6-bit BXN

if (getCSCHisto(h::CSC_ALCT_BXN_VS_DMB_BXN, crateID, dmbID, mo)) mo->Fill((int)((alctHeader->BXNCount())), (int)(dmbHeader->bxn()));

LOG_DEBUG << "ALCT Trailer Word Count = " << dec << (int)alctTrailer->wordCount();

TODO: Add support for more than 2 ALCTs

int tbin = wireDigisItr->getBeamCrossingTag();

ALCT not found

ALCT and CLCT coinsidence

if (getCSCHisto(h::CSC_TMB_BXN_VS_ALCT_BXN, crateID, dmbID, mo)) mo->Fill((int)((alctHeader->BXNCount())),(int)(tmbHeader->BXNCount()));

CLCT Found

LOG_WARN << "TMB CRC calc: 0x" << std::hex << data.tmbData().TMBCRCcalc() << " trailer: 0x" << std::hex << data.tmbData().tmbTrailer().crc22();

Set number of CLCT-events to forth bin

Use 6-bit L1A

if (getCSCHisto(h::CSC_DMB_L1A_VS_CLCT_L1A, crateID, dmbID, mo)) mo->Fill(tmbHeader->L1ANumber(),dmbHeader->l1a());

if (getCSCHisto(h::CSC_CLCT_BXN_VS_DMB_BXN, crateID, dmbID, mo)) mo->Fill(tmbHeader->BXNCount(),dmbHeader->bxn());

LOG_DEBUG << "TMB Trailer Word Count = " << dec << (int)tmbTrailer->wordCount();

LOG_DEBUG << "CLCT BX = " << clctsDatas[lct].getBX() << " TMB BX = " << tmbHeader->BXNCount() << " 03 = " << (int)(tmbHeader->BXNCount()&0x3);

LOG_DEBUG << "diff = " << clctsDatas[lct].getBX()-(tmbHeader->BXNCount()&0x3);

int pattern_clct = (int)((clctsDatas[lct].getPattern()>>1)&0x3);

pattern_clct = Number of patterns in CLCT

Last (left) bit is bend. Positive bend = 1, negative bend = 0

pattern_clct = Number of patterns in CLCT

Last (left) bit is bend. Positive bend = 1, negative bend = 0

=VB= Fix to get right hafstrip

if (norm < 1.0) norm=1;

CLCT not found

CFEB found

bool DebugCFEB = false;

-----------—B

int NmbCell, SCA_Nmb_FC;

-----------—E

-----------—B

int TrigTimeData[N_CFEBs*16][N_Samples][N_Layers];

memset(TrigTimeData, 0, sizeof(TrigTimeData));

-----------—E

CFEB Found

----------—B

----------—E

LOG_DEBUG << "NEvents = " << config->getNEvents();

LOG_DEBUG << "Chamber ID = "<< cscTag << " Crate ID = "<< crateID << " DMB ID = " << dmbID << "nCFEB =" << nCFEB;

=VB= Optimizations for faster histogram object access

LOG_DEBUG << " nSample = " << nSample;

=VB= Optimizations for faster histogram object access

if (mo_CFEB_DMB_L1A_diff)

LOG_DEBUG << " nSample = " << nSample;

for(int nLayer = 1; nLayer <= N_Layers; ++nLayer)

-----------—B

L1_Pipe_Count = (timeSlice[nCFEB][nSample])->get_L1A_number();

LOG_DEBUG << "SCA BLOCK: Chamber=" << chamberID << " CFEB=" << nCFEB + 1

<<" TRIGTIME="<<TrigTime<<" TimeSlice="<<nSample+1<<" Layer="<<nLayer<<" SCA_BLK="<<SCA_BLK;

if(res<=1) TrigTimeData[nCFEB*16+nStrip][nSample][nLayer-1] = TrigTime;

LOG_DEBUG << "*********"<<" TRIGTIME="<<TrigTime<<" BIT COUNT="<<bit_count;

SCA Block Occupancy Histograms

if (getCSCHisto(h::CSC_CFEBXX_SCA_BLOCK_OCCUPANCY, crateID, dmbID, nCFEB + 1, mo)) mo->Fill(SCA_BLK);

Free SCA Cells

if (getCSCHisto(h::CSC_CFEBXX_FREE_SCA_CELLS, crateID, dmbID, nCFEB + 1, mo))

Number of SCA Blocks Locked by LCTs

if (getCSCHisto(h::CSC_CFEBXX_SCA_BLOCKS_LOCKED_BY_LCTS, crateID, dmbID, nCFEB + 1, mo))

Number of SCA Blocks Locked by LCTxL1

if (getCSCHisto(h::CSC_CFEBXX_SCA_BLOCKS_LOCKED_BY_LCTXL1, crateID, dmbID, nCFEB + 1, mo))

-----------—E

LOG_DEBUG << "nCFEB " << nCFEB << " nSample " << nSample << " nLayer " << nLayer << " TrigTime " << TrigTime;

LOG_DEBUG << "L1APhase " << L1APhase << " UnpackedTrigTime " << UnpackedTrigTime;

LOG_DEBUG << " nStrip="<< dec << nStrip << " ADC=" << std::hex << ADC;

LOG_DEBUG << " nStrip="<< dec << nStrip << " Pedestal=" << std::hex << Pedestal[nCFEB][nLayer-1][nStrip-1];

if (getCSCHisto(h::CSC_CFEB_OUT_OFF_RANGE_STRIPS_LYXX, crateID, dmbID, nLayer, mo))

if (getCSCHisto(h::CSC_CFEB_ACTIVE_SAMPLES_VS_STRIP_LYXX, crateID, dmbID, nLayer, mo))

if (getCSCHisto(h::CSC_CFEB_ACTIVE_SAMPLES_VS_STRIP_LYXX_PROFILE, crateID, dmbID, nLayer, mo))

if (getCSCHisto(h::CSC_CFEB_ACTIVESTRIPS_LYXX, crateID, dmbID, nLayer, mo))

-----------—B

LOG_DEBUG << "Layer="<<nLayer<<" Strip="<<nCFEB*16+nStrip<<" Time="<<nSample << " ADC-PEDEST = "<<ADC - Pedestal[nCFEB][nLayer-1][nStrip-1];

-----------—E

continue;

-----------—B

if (getCSCHisto(h::CSC_CFEB_PEDESTAL__WITHEMV__SAMPLE_01_LYXX, crateID, dmbID, nLayer, mo))

if (getCSCHisto(h::CSC_CFEB_PEDESTAL__WITHRMS__SAMPLE_01_LYXX, crateID, dmbID, nLayer, mo))

if (getCSCHisto(h::CSC_CFEB_PEDESTALRMS_SAMPLE_01_LYXX, crateID, dmbID, nLayer, mo))

-----------—E

-----------—B

Refactored for performance (VR)

StripClusterFinder *ClusterFinder = new StripClusterFinder(N_Layers, N_Samples, N_CFEBs, N_Strips);

LOG_DEBUG << "*** CATHODE PART DEBUG: Layer=" << nLayer <<" Number of Clusters=" << Clus.size() << " ***";

Number of Clusters Histograms

LOG_DEBUG << "Strip: " << Clus[u].ClusterPulseMapHeight[k].channel_+1;

Clusters Charge Histograms

Width of Clusters Histograms

Cluster Duration Histograms

delete ClusterFinder;

-----------—E

Fill Hisogram for Different Combinations of FEBs Unpacked vs DAV

Definition at line 81 of file CSCDQM_EventProcessor_processCSC.cc.

81  {
82  config->incNUnpackedCSC();
83 
84  int FEBunpacked = 0;
85  int alct_unpacked = 0;
86  int tmb_unpacked = 0;
87  int cfeb_unpacked = 0;
88 
89  int alct_keywg = -1;
90  int clct_kewdistrip = -1;
91 
92  bool L1A_out_of_sync = false;
93 
94  int nCFEBs = 5;
95 
96  MonitorObject* mo = nullptr;
97 
100  const CSCDMBHeader* dmbHeader = data.dmbHeader();
101  const CSCDMBTrailer* dmbTrailer = data.dmbTrailer();
102  if (!dmbHeader && !dmbTrailer) {
103  LOG_ERROR << "Can not unpack DMB Header or/and Trailer";
104  return;
105  }
106 
107  theFormatVersion = data.getFormatVersion();
108 
110  unsigned int crateID = 0xFF;
111  unsigned int dmbID = 0xF;
112  unsigned int chamberID = 0xFFF;
113 
114  crateID = dmbHeader->crateID();
115  dmbID = dmbHeader->dmbID();
116  chamberID = (((crateID) << 4) + dmbID) & 0xFFF;
117 
118  const std::string cscTag = CSCHistoDef::getPath(crateID, dmbID);
119 
120  unsigned long errors = binChecker.errorsForChamber(chamberID);
121  if ((errors & config->getBINCHECK_MASK()) > 0) {
122  LOG_WARN << "Format Errors " << cscTag << ": 0x" << std::hex << errors << " Skipped CSC Unpacking";
123  return;
124  }
125 
126  unsigned int cscType = 0;
127  unsigned int cscPosition = 0;
128  if (!getCSCFromMap(crateID, dmbID, cscType, cscPosition))
129  return;
130 
131  CSCDetId cid;
132  if (!config->fnGetCSCDetId(crateID, dmbID, cid)) {
133  return;
134  }
135 
136  // Check if ME11 with PostLS1 readout (7 DCFEBs)
137  if ((cscType == 8 || cscType == 9) && theFormatVersion == 2013)
138  nCFEBs = 7;
139 
140  // Check if in standby!
141  if (summary.isChamberStandby(cid)) {
142  return;
143  }
144 
145  double DMBEvents = 0.0;
146  DMBEvents = config->getChamberCounterValue(DMB_EVENTS, crateID, dmbID);
147 
148  // Get Event display plot number and next plot object
149  uint32_t evDisplNo = config->getChamberCounterValue(EVENT_DISPLAY_PLOT, crateID, dmbID);
150  evDisplNo += 1;
151  if (evDisplNo >= 5) {
152  config->setChamberCounterValue(EVENT_DISPLAY_PLOT, crateID, dmbID, 0);
153  } else {
154  config->setChamberCounterValue(EVENT_DISPLAY_PLOT, crateID, dmbID, evDisplNo);
155  }
156  MonitorObject* mo_EventDisplay = nullptr;
157  if (getCSCHisto(h::CSC_EVENT_DISPLAY_NOXX, crateID, dmbID, evDisplNo, mo_EventDisplay)) {
158  mo_EventDisplay->getTH1Lock()->Reset("");
159  }
160 
161  // Receiving EMU Event displays
162  MonitorObject *mo_Emu_EventDisplay_Anode = nullptr, *mo_Emu_EventDisplay_Cathode = nullptr,
163  *mo_Emu_EventDisplay_XY = nullptr;
164  getEMUHisto(h::EMU_EVENT_DISPLAY_ANODE, mo_Emu_EventDisplay_Anode);
165  getEMUHisto(h::EMU_EVENT_DISPLAY_CATHODE, mo_Emu_EventDisplay_Cathode);
166  getEMUHisto(h::EMU_EVENT_DISPLAY_XY, mo_Emu_EventDisplay_XY);
167 
168  // Global chamber index
169  uint32_t glChamberIndex = 0;
170 
171  if (mo_EventDisplay) {
172  mo_EventDisplay->SetBinContent(1, 1, cid.endcap());
173  mo_EventDisplay->SetBinContent(1, 2, cid.station());
174  mo_EventDisplay->SetBinContent(1, 3, cid.ring());
175  mo_EventDisplay->SetBinContent(1, 4, cscPosition);
176  mo_EventDisplay->SetBinContent(1, 5, crateID);
177  mo_EventDisplay->SetBinContent(1, 6, dmbID);
178  mo_EventDisplay->SetBinContent(1, 7, dmbHeader->l1a24());
179  if (mo_Emu_EventDisplay_Anode || mo_Emu_EventDisplay_Cathode || mo_Emu_EventDisplay_XY) {
180  glChamberIndex = summary.getDetector().GlobalChamberIndex(cid.endcap(), cid.station(), cid.ring(), cscPosition);
181  }
182  }
183 
184  config->copyChamberCounterValue(DMB_EVENTS, DMB_TRIGGERS, crateID, dmbID);
185 
186  if (cscPosition && getEMUHisto(h::EMU_CSC_UNPACKED, mo)) {
187  mo->Fill(cscPosition, cscType);
188  }
189 
191  float DMBEff = float(DMBEvents) / float(config->getNEvents());
192  if (DMBEff > 1.0) {
193  LOG_ERROR << cscTag << " has efficiency " << DMBEff << " which is greater than 1";
194  }
195 
199  int dmbHeaderL1A = dmbHeader->l1a24() % 64;
201  int dmb_ddu_l1a_diff = (int)(dmbHeaderL1A - (int)(L1ANumber % 64));
202  if (dmb_ddu_l1a_diff != 0)
203  L1A_out_of_sync = true;
204 
207  if (getCSCHisto(h::CSC_DMB_L1A_DISTRIB, crateID, dmbID, mo))
208  mo->Fill(dmbHeaderL1A);
209 
210  if (getCSCHisto(h::CSC_DMB_DDU_L1A_DIFF, crateID, dmbID, mo)) {
211  if (dmb_ddu_l1a_diff < -32) {
212  mo->Fill(dmb_ddu_l1a_diff + 64);
213  } else {
214  if (dmb_ddu_l1a_diff >= 32)
215  mo->Fill(dmb_ddu_l1a_diff - 64);
216  else
217  mo->Fill(dmb_ddu_l1a_diff);
218  }
219  mo->SetAxisRange(0.1, 1.1 * (1.0 + mo->GetBinContent(mo->GetMaximumBin())), "Y");
220  }
221 
222  if (getCSCHisto(h::CSC_DMB_L1A_VS_DDU_L1A, crateID, dmbID, mo))
223  mo->Fill((int)(L1ANumber & 0xFF), (int)dmbHeaderL1A);
224 
226  int dmbHeaderBXN = 0;
227  int dmb_ddu_bxn_diff = 0;
228 
233  dmbHeaderBXN = dmbHeader->bxn12();
237  dmb_ddu_bxn_diff = dmbHeaderBXN % 64 - BXN % 64;
239  if (getCSCHisto(h::CSC_DMB_BXN_DISTRIB, crateID, dmbID, mo))
240  mo->Fill((int)(dmbHeader->bxn12()));
241 
242  if (getCSCHisto(h::CSC_DMB_DDU_BXN_DIFF, crateID, dmbID, mo)) {
243  if (dmb_ddu_bxn_diff < -32)
244  mo->Fill(dmb_ddu_bxn_diff + 64);
245  else {
246  if (dmb_ddu_bxn_diff >= 32)
247  mo->Fill(dmb_ddu_bxn_diff - 64);
248  else
249  mo->Fill(dmb_ddu_bxn_diff);
250  }
251  mo->SetAxisRange(0.1, 1.1 * (1.0 + mo->GetBinContent(mo->GetMaximumBin())), "Y");
252  }
253 
255  if (getCSCHisto(h::CSC_DMB_BXN_VS_DDU_BXN, crateID, dmbID, mo))
256  mo->Fill(((int)(BXN)) % 256, ((int)dmbHeaderBXN) % 256);
257 
259  int cfeb_dav = 0;
260  int cfeb_dav_num = 0;
261  int cfeb_movlp = 0;
262  int dmb_cfeb_sync = 0;
263 
264  cfeb_dav = (int)dmbHeader->cfebAvailable();
265  for (int i = 0; i < nCFEBs; i++)
266  cfeb_dav_num += (cfeb_dav >> i) & 0x1;
267  cfeb_movlp = (int)dmbHeader->cfebMovlp();
268  dmb_cfeb_sync = (int)dmbHeader->dmbCfebSync();
269 
270  if (getCSCHisto(h::CSC_DMB_CFEB_DAV, crateID, dmbID, mo)) {
271  for (int i = 0; i < nCFEBs; i++) {
272  int cfeb_present = (cfeb_dav >> i) & 0x1;
273  if (cfeb_present) {
274  mo->Fill(i);
275  }
276  }
277  }
278 
279  if (getCSCHisto(h::CSC_DMB_CFEB_DAV_MULTIPLICITY, crateID, dmbID, mo))
280  mo->Fill(cfeb_dav_num);
281  if (getCSCHisto(h::CSC_DMB_CFEB_MOVLP, crateID, dmbID, mo))
282  mo->Fill(cfeb_movlp);
283  if (getCSCHisto(h::CSC_DMB_CFEB_SYNC, crateID, dmbID, mo))
284  mo->Fill(dmb_cfeb_sync);
285 
286  if (getEMUHisto(h::EMU_DMB_UNPACKED, mo)) {
287  mo->Fill(crateID, dmbID);
289  }
290 
292  if (getCSCHisto(h::CSC_DMB_CFEB_ACTIVE, crateID, dmbID, mo))
293  mo->Fill(dmbHeader->cfebActive()); //KK
294 
298  if (getCSCHisto(h::CSC_DMB_L1_PIPE, crateID, dmbID, mo))
299  mo->Fill(dmbTrailer->dmb_l1pipe());
300 
302  if (getCSCHisto(h::CSC_DMB_FIFO_STATS, crateID, dmbID, mo)) {
303  if (dmbTrailer->tmb_empty() == 1)
304  mo->Fill(1.0, 0.0); //KK
305  if (dmbTrailer->tmb_half() == 0)
306  mo->Fill(1.0, 1.0);
307  if (dmbTrailer->tmb_full() == 1)
308  mo->Fill(1.0, 2.0); //KK
309  if (dmbTrailer->alct_empty() == 1)
310  mo->Fill(0.0, 0.0);
311  if (dmbTrailer->alct_half() == 0)
312  mo->Fill(0.0, 1.0);
313  if (dmbTrailer->alct_full() == 1)
314  mo->Fill(0.0, 2.0); //KK 0->1
315  for (int i = 0; i < nCFEBs; i++) {
316  if ((int)((dmbTrailer->cfeb_empty() >> i) & 0x1) == 1)
317  mo->Fill(i + 2, 0.0);
318  if ((int)((dmbTrailer->cfeb_half() >> i) & 0x1) == 0)
319  mo->Fill(i + 2, 1);
320  if ((int)((dmbTrailer->cfeb_full() >> i) & 0x1) == 1) {
321  mo->Fill(i + 2, 2);
322  }
323  }
324  mo->SetEntries((int)DMBEvents);
325  }
326 
328  if (getCSCHisto(h::CSC_DMB_FEB_TIMEOUTS, crateID, dmbID, mo)) {
329  if ((dmbTrailer->tmb_starttimeout() == 0) && (dmbTrailer->alct_starttimeout() == 0) &&
330  (dmbTrailer->cfeb_starttimeout() == 0) && (dmbTrailer->cfeb_endtimeout() == 0)) {
331  mo->Fill(0.0);
332  } else {
333  if (dmbTrailer->alct_starttimeout())
334  mo->Fill(1);
335  if (dmbTrailer->tmb_starttimeout())
336  mo->Fill(2);
337  if (dmbTrailer->alct_endtimeout())
338  mo->Fill(8); // KK
339  if (dmbTrailer->tmb_endtimeout())
340  mo->Fill(9); // KK
341  }
342  for (int i = 0; i < nCFEBs; i++) {
343  if ((dmbTrailer->cfeb_starttimeout() >> i) & 0x1) {
344  mo->Fill(i + 3);
345  }
346  if ((dmbTrailer->cfeb_endtimeout() >> i) & 0x1) {
347  mo->Fill(i + 10); // KK 8->10
348  }
349  }
350  mo->SetEntries((int)DMBEvents);
351  }
352 
354  int alct_dav = dmbHeader->nalct();
355  int tmb_dav = dmbHeader->nclct();
356  int cfeb_dav2 = 0;
357  for (int i = 0; i < nCFEBs; i++)
358  cfeb_dav2 = cfeb_dav2 + (int)((dmbHeader->cfebAvailable() >> i) & 0x1);
359 
362  if ((alct_dav > 0) && (getCSCHisto(h::CSC_DMB_FEB_DAV_RATE, crateID, dmbID, mo))) {
363  mo->Fill(0.0);
364  float alct_dav_number = mo->GetBinContent(1);
365  if (getCSCHisto(h::CSC_DMB_FEB_DAV_EFFICIENCY, crateID, dmbID, mo)) {
366  mo->SetBinContent(1, ((float)alct_dav_number / (float)(DMBEvents)*100.0));
367  mo->SetEntries((int)DMBEvents);
368  }
369  }
370 
371  if ((tmb_dav > 0) && (getCSCHisto(h::CSC_DMB_FEB_DAV_RATE, crateID, dmbID, mo))) {
372  mo->Fill(1.0);
373  float tmb_dav_number = mo->GetBinContent(2);
374  if (getCSCHisto(h::CSC_DMB_FEB_DAV_EFFICIENCY, crateID, dmbID, mo)) {
375  mo->SetBinContent(2, ((float)tmb_dav_number / (float)(DMBEvents)*100.0));
376  mo->SetEntries((int)DMBEvents);
377  }
378  }
379 
380  if ((cfeb_dav2 > 0) && (getCSCHisto(h::CSC_DMB_FEB_DAV_RATE, crateID, dmbID, mo))) {
381  mo->Fill(2.0);
382  float cfeb_dav2_number = mo->GetBinContent(3);
383  if (getCSCHisto(h::CSC_DMB_FEB_DAV_EFFICIENCY, crateID, dmbID, mo)) {
384  mo->SetBinContent(3, ((float)cfeb_dav2_number / (float)(DMBEvents)*100.0));
385  mo->SetEntries((int)DMBEvents);
386  }
387  }
388 
389  float feb_combination_dav = -1.0;
391  if (getCSCHisto(h::CSC_DMB_FEB_COMBINATIONS_DAV_RATE, crateID, dmbID, mo)) {
392  if (alct_dav == 0 && tmb_dav == 0 && cfeb_dav2 == 0)
393  feb_combination_dav = 0.0; // Nothing
394  if (alct_dav > 0 && tmb_dav == 0 && cfeb_dav2 == 0)
395  feb_combination_dav = 1.0; // ALCT Only
396  if (alct_dav == 0 && tmb_dav > 0 && cfeb_dav2 == 0)
397  feb_combination_dav = 2.0; // TMB Only
398  if (alct_dav == 0 && tmb_dav == 0 && cfeb_dav2 > 0)
399  feb_combination_dav = 3.0; // CFEB Only
400  if (alct_dav == 0 && tmb_dav > 0 && cfeb_dav2 > 0)
401  feb_combination_dav = 4.0; // TMB+CFEB
402  if (alct_dav > 0 && tmb_dav > 0 && cfeb_dav2 == 0)
403  feb_combination_dav = 5.0; // ALCT+TMB
404  if (alct_dav > 0 && tmb_dav == 0 && cfeb_dav2 > 0)
405  feb_combination_dav = 6.0; // ALCT+CFEB
406  if (alct_dav > 0 && tmb_dav > 0 && cfeb_dav2 > 0)
407  feb_combination_dav = 7.0; // ALCT+TMB+CFEB
408  mo->Fill(feb_combination_dav);
409  float feb_combination_dav_number = mo->GetBinContent((int)(feb_combination_dav + 1.0));
410  if (getCSCHisto(h::CSC_DMB_FEB_COMBINATIONS_DAV_EFFICIENCY, crateID, dmbID, mo)) {
411  mo->SetBinContent((int)(feb_combination_dav + 1.0),
412  ((float)feb_combination_dav_number / (float)(DMBEvents)*100.0));
413  mo->SetEntries((int)DMBEvents);
414  }
415  }
416 
418  if (data.nalct()) {
419  const CSCALCTHeader* alctHeader = data.alctHeader();
420  int fwVersion = alctHeader->alctFirmwareVersion();
421  const CSCALCTTrailer* alctTrailer = data.alctTrailer();
422  const CSCAnodeData* alctData = data.alctData();
423 
424  if (alctHeader && alctTrailer) {
425  std::vector<CSCALCTDigi> alctsDatasTmp = alctHeader->ALCTDigis();
426  std::vector<CSCALCTDigi> alctsDatas;
427 
428  for (uint32_t lct = 0; lct < alctsDatasTmp.size(); lct++) {
429  if (alctsDatasTmp[lct].isValid())
430  alctsDatas.push_back(alctsDatasTmp[lct]);
431  }
432 
433  FEBunpacked = FEBunpacked + 1;
434  alct_unpacked = 1;
435 
437  if (getCSCHisto(h::CSC_CSC_RATE, crateID, dmbID, mo)) {
438  mo->Fill(2);
439  uint32_t ALCTEvent = (uint32_t)mo->GetBinContent(3);
440  config->setChamberCounterValue(ALCT_TRIGGERS, crateID, dmbID, ALCTEvent);
441  if (getCSCHisto(h::CSC_CSC_EFFICIENCY, crateID, dmbID, mo)) {
442  if (config->getNEvents() > 0) {
445  mo->SetBinContent(1, ((float)ALCTEvent / (float)(DMBEvents)*100.0));
447  mo->SetEntries((int)DMBEvents);
448  }
449  }
450  }
451 
452  if ((alct_dav > 0) && (getCSCHisto(h::CSC_DMB_FEB_UNPACKED_VS_DAV, crateID, dmbID, mo))) {
453  mo->Fill(0.0, 0.0);
454  }
455 
458  if (getCSCHisto(h::CSC_ALCT_L1A, crateID, dmbID, mo))
459  mo->Fill((int)(alctHeader->L1Acc()));
460 
462  if (getCSCHisto(h::CSC_ALCT_DMB_L1A_DIFF, crateID, dmbID, mo)) {
464  int alct_dmb_l1a_diff = (int)(alctHeader->L1Acc() % 64 - dmbHeader->l1a24() % 64);
465  if (alct_dmb_l1a_diff != 0)
466  L1A_out_of_sync = true;
467  if (alct_dmb_l1a_diff < -32)
468  mo->Fill(alct_dmb_l1a_diff + 64);
469  else {
470  if (alct_dmb_l1a_diff >= 32)
471  mo->Fill(alct_dmb_l1a_diff - 64);
472  else
473  mo->Fill(alct_dmb_l1a_diff);
474  }
475  mo->SetAxisRange(0.1, 1.1 * (1.0 + mo->GetBinContent(mo->GetMaximumBin())), "Y");
476  }
477 
479  if (getCSCHisto(h::CSC_DMB_L1A_VS_ALCT_L1A, crateID, dmbID, mo))
480  mo->Fill(alctHeader->L1Acc() % 256, dmbHeader->l1a24() % 256);
481 
484  if (getCSCHisto(h::CSC_ALCT_DMB_BXN_DIFF, crateID, dmbID, mo)) {
485  int alct_dmb_bxn_diff = (int)(alctHeader->BXNCount() - dmbHeader->bxn12());
486  if (alct_dmb_bxn_diff > 0)
487  alct_dmb_bxn_diff -= 3564;
488  alct_dmb_bxn_diff %= 32;
489  mo->Fill(alct_dmb_bxn_diff);
490  mo->SetAxisRange(0.1, 1.1 * (1.0 + mo->GetBinContent(mo->GetMaximumBin())), "Y");
491  }
492 
493  if (getCSCHisto(h::CSC_ALCT_BXN, crateID, dmbID, mo))
494  mo->Fill(alctHeader->BXNCount());
495 
497  if (getCSCHisto(h::CSC_ALCT_BXN_VS_DMB_BXN, crateID, dmbID, mo))
498  mo->Fill((int)((alctHeader->BXNCount()) % 256), (int)(dmbHeader->bxn12()) % 256);
499 
500  if (getCSCHisto(h::CSC_ALCT_NUMBER_RATE, crateID, dmbID, mo)) {
501  mo->Fill(alctsDatas.size());
502  int nALCT = (int)mo->GetBinContent((int)(alctsDatas.size() + 1));
503  if (getCSCHisto(h::CSC_ALCT_NUMBER_EFFICIENCY, crateID, dmbID, mo))
504  mo->SetBinContent((int)(alctsDatas.size() + 1), (float)(nALCT) / (float)(DMBEvents)*100.0);
505  }
506 
507  if (getCSCHisto(h::CSC_ALCT_WORD_COUNT, crateID, dmbID, mo))
508  mo->Fill((int)(alctTrailer->wordCount()));
509 
512  if (alctsDatas.size() == 2) {
513  if (getCSCHisto(h::CSC_ALCT1_VS_ALCT0_KEYWG, crateID, dmbID, mo))
514  mo->Fill(alctsDatas[0].getKeyWG(), alctsDatas[1].getKeyWG());
515  }
516 
517  MonitorObject* mo_CSC_ALCT0_BXN_mean = nullptr;
518  getEMUHisto(h::EMU_CSC_ALCT0_BXN_MEAN, mo_CSC_ALCT0_BXN_mean);
519 
520  MonitorObject* mo_CSC_ALCT0_BXN_rms = nullptr;
521  getEMUHisto(h::EMU_CSC_ALCT0_BXN_RMS, mo_CSC_ALCT0_BXN_rms);
522 
523  MonitorObject* mo_CSC_Plus_endcap_ALCT0_dTime = nullptr;
524  getEMUHisto(h::EMU_CSC_ALCT0_ENDCAP_PLUS_DTIME, mo_CSC_Plus_endcap_ALCT0_dTime);
525 
526  MonitorObject* mo_CSC_Minus_endcap_ALCT0_dTime = nullptr;
527  getEMUHisto(h::EMU_CSC_ALCT0_ENDCAP_MINUS_DTIME, mo_CSC_Minus_endcap_ALCT0_dTime);
528 
529  for (uint32_t lct = 0; lct < alctsDatas.size(); lct++) {
531  if (lct >= 2)
532  continue;
533 
534  if (getCSCHisto(h::CSC_ALCTXX_KEYWG, crateID, dmbID, lct, mo)) {
535  mo->Fill(alctsDatas[lct].getKeyWG());
536  }
537 
538  if (lct == 0)
539  alct_keywg = alctsDatas[lct].getKeyWG();
540 
541  int alct_dtime = 0;
542  if (fwVersion == 2007) {
543  alct_dtime = alctsDatas[lct].getBX();
544  } else {
545  // Older 2006 Format
546  alct_dtime = (int)(alctsDatas[lct].getBX() - (alctHeader->BXNCount() & 0x1F));
547  }
548 
549  // == Those two summary histos need to be outside of per-chamber CSC_ALCTXX_DTIME histo check.
550  // Otherwise will be empty in Offline DQM
551  if (lct == 0) {
552  if (cid.endcap() == 1) {
553  if (mo_CSC_Plus_endcap_ALCT0_dTime)
554  mo_CSC_Plus_endcap_ALCT0_dTime->Fill(alct_dtime);
555  }
556  if (cid.endcap() == 2) {
557  if (mo_CSC_Minus_endcap_ALCT0_dTime)
558  mo_CSC_Minus_endcap_ALCT0_dTime->Fill(alct_dtime);
559  }
560  }
561 
562  if (getCSCHisto(h::CSC_ALCTXX_DTIME, crateID, dmbID, lct, mo)) {
563  if (alct_dtime < -16) {
564  mo->Fill(alct_dtime + 32);
565  } else {
566  if (alct_dtime >= 16)
567  mo->Fill(alct_dtime - 32);
568  else
569  mo->Fill(alct_dtime);
570  }
571 
572  mo->SetAxisRange(0.1, 1.1 * (1.0 + mo->GetBinContent(mo->GetMaximumBin())), "Y");
573 
574  double dTime_mean = mo->getTH1()->GetMean();
575  double dTime_rms = mo->getTH1()->GetRMS();
576 
577  // == For ALCT0 Fill Summary dTime Histograms
578  if (lct == 0) {
579  /* -- Moved outside of CSC histo check
580  if (cid.endcap() == 1) {
581  if (mo_CSC_Plus_endcap_ALCT0_dTime) mo_CSC_Plus_endcap_ALCT0_dTime->Fill(alct_dtime);
582  }
583  if (cid.endcap() == 2) {
584  if (mo_CSC_Minus_endcap_ALCT0_dTime) mo_CSC_Minus_endcap_ALCT0_dTime->Fill(alct_dtime);
585  }
586  */
587  if (cscPosition && mo_CSC_ALCT0_BXN_mean) {
588  mo_CSC_ALCT0_BXN_mean->SetBinContent(cscPosition, cscType + 1, dTime_mean);
589  }
590  if (cscPosition && mo_CSC_ALCT0_BXN_rms) {
591  mo_CSC_ALCT0_BXN_rms->SetBinContent(cscPosition, cscType + 1, dTime_rms);
592  }
593  }
594  }
595 
596  if (getCSCHisto(h::CSC_ALCTXX_DTIME_VS_KEYWG, crateID, dmbID, lct, mo)) {
597  if (alct_dtime < -16) {
598  mo->Fill(alctsDatas[lct].getKeyWG(), alct_dtime + 32);
599  } else {
600  if (alct_dtime >= 16)
601  mo->Fill(alctsDatas[lct].getKeyWG(), alct_dtime - 32);
602  else
603  mo->Fill(alctsDatas[lct].getKeyWG(), alct_dtime);
604  }
605  }
606 
607  if (getCSCHisto(h::CSC_ALCTXX_DTIME_PROFILE, crateID, dmbID, lct, mo)) {
608  if (alct_dtime < -16) {
609  mo->Fill(alctsDatas[lct].getKeyWG(), alct_dtime + 32);
610  } else {
611  if (alct_dtime >= 16)
612  mo->Fill(alctsDatas[lct].getKeyWG(), alct_dtime - 32);
613  else
614  mo->Fill(alctsDatas[lct].getKeyWG(), alct_dtime);
615  }
616  }
617 
618  int alct_bxn = alctsDatas[lct].getBX();
619  if (fwVersion == 2007) {
620  alct_bxn = (alct_bxn + alctHeader->BXNCount()) & 0x1F;
621  }
622 
623  if (getCSCHisto(h::CSC_ALCTXX_BXN, crateID, dmbID, lct, mo))
624  mo->Fill(alct_bxn);
625 
626  if (getCSCHisto(h::CSC_ALCTXX_QUALITY, crateID, dmbID, lct, mo))
627  mo->Fill(alctsDatas[lct].getKeyWG(), alctsDatas[lct].getQuality());
628 
629  if (mo_EventDisplay) {
630  mo_EventDisplay->SetBinContent(2, alctsDatas[lct].getKeyWG(), alct_bxn + 1);
631  mo_EventDisplay->SetBinContent(3, alctsDatas[lct].getKeyWG(), alctsDatas[lct].getQuality());
632  }
633 
634  if (getCSCHisto(h::CSC_ALCTXX_QUALITY_DISTR, crateID, dmbID, lct, mo)) {
635  mo->Fill(alctsDatas[lct].getQuality());
636  if (lct == 0) {
637  MonitorObject* mo1 = nullptr;
638  if (cscPosition && getEMUHisto(h::EMU_CSC_ALCT0_QUALITY, mo1)) {
639  mo1->SetBinContent(cscPosition, cscType + 1, mo->getTH1()->GetMean());
640  }
641  }
642  }
643 
644  if (getCSCHisto(h::CSC_ALCTXX_QUALITY_PROFILE, crateID, dmbID, lct, mo))
645  mo->Fill(alctsDatas[lct].getKeyWG(), alctsDatas[lct].getQuality());
646 
647  if (getCSCHisto(h::CSC_ALCTXX_PATTERN, crateID, dmbID, lct, mo)) {
648  int pattern = (alctsDatas[lct].getAccelerator() << 1) + alctsDatas[lct].getCollisionB();
649  int keywg = alctsDatas[lct].getKeyWG();
650  mo->Fill(keywg, pattern);
651  }
652 
653  if (getCSCHisto(h::CSC_ALCTXX_PATTERN_DISTR, crateID, dmbID, lct, mo)) {
654  int pattern = (alctsDatas[lct].getAccelerator() << 1) + alctsDatas[lct].getCollisionB();
655  mo->Fill(pattern);
656  }
657  }
658 
659  int NumberOfLayersWithHitsInALCT = 0;
660  int NumberOfWireGroupsWithHitsInALCT = 0;
661 
662  if (alctData) {
663  MonitorObject* mo_AFEB_RawHits_TimeBins = nullptr;
664  getCSCHisto(h::CSC_CFEB_AFEB_RAWHITS_TIMEBINS, crateID, dmbID, mo_AFEB_RawHits_TimeBins);
665 
666  MonitorObject* mo_CSC_Plus_endcap_AFEB_RawHits_Time = nullptr;
667  getEMUHisto(h::EMU_CSC_AFEB_ENDCAP_PLUS_RAWHITS_TIME, mo_CSC_Plus_endcap_AFEB_RawHits_Time);
668 
669  MonitorObject* mo_CSC_Minus_endcap_AFEB_RawHits_Time = nullptr;
670  getEMUHisto(h::EMU_CSC_AFEB_ENDCAP_MINUS_RAWHITS_TIME, mo_CSC_Minus_endcap_AFEB_RawHits_Time);
671 
672  MonitorObject* mo_CSC_AFEB_RawHits_Time_mean = nullptr;
673  getEMUHisto(h::EMU_CSC_AFEB_RAWHITS_TIME_MEAN, mo_CSC_AFEB_RawHits_Time_mean);
674 
675  MonitorObject* mo_CSC_AFEB_RawHits_Time_rms = nullptr;
676  getEMUHisto(h::EMU_CSC_AFEB_RAWHITS_TIME_RMS, mo_CSC_AFEB_RawHits_Time_rms);
677 
678  for (int nLayer = 1; nLayer <= 6; nLayer++) {
679  int wg_previous = -1;
680  int tbin_previous = -1;
681  bool CheckLayerALCT = true;
682 
683  std::vector<CSCWireDigi> wireDigis = alctData->wireDigis(nLayer);
684  for (std::vector<CSCWireDigi>::iterator wireDigisItr = wireDigis.begin(); wireDigisItr != wireDigis.end();
685  ++wireDigisItr) {
686  int wg = wireDigisItr->getWireGroup();
688  std::vector<int> tbins = wireDigisItr->getTimeBinsOn();
689  int tbin = wireDigisItr->getTimeBin();
690 
691  if (mo_EventDisplay) {
692  mo_EventDisplay->SetBinContent(nLayer + 3, wg - 1, tbin + 1);
693  setEmuEventDisplayBit(mo_Emu_EventDisplay_Anode, glChamberIndex, wg - 1, nLayer - 1);
694  setEmuEventDisplayBit(mo_Emu_EventDisplay_XY, glChamberIndex, wg - 1, nLayer - 1);
695  }
696 
697  if (CheckLayerALCT) {
698  NumberOfLayersWithHitsInALCT = NumberOfLayersWithHitsInALCT + 1;
699  CheckLayerALCT = false;
700  }
701 
702  for (uint32_t n = 0; n < tbins.size(); n++) {
703  tbin = tbins[n];
704  if (wg != wg_previous || (tbin != tbin_previous + 1 && tbin != tbin_previous - 1)) {
705  if (getCSCHisto(h::CSC_ALCTTIME_LYXX, crateID, dmbID, nLayer, mo))
706  mo->Fill(wg - 1, tbin);
707 
708  if (getCSCHisto(h::CSC_ALCTTIME_LYXX_PROFILE, crateID, dmbID, nLayer, mo))
709  mo->Fill(wg - 1, tbin);
710 
711  if (mo_AFEB_RawHits_TimeBins)
712  mo_AFEB_RawHits_TimeBins->Fill(tbin);
713 
714  if (cid.endcap() == 1) {
715  if (mo_CSC_Plus_endcap_AFEB_RawHits_Time)
716  mo_CSC_Plus_endcap_AFEB_RawHits_Time->Fill(tbin);
717  }
718  if (cid.endcap() == 2) {
719  if (mo_CSC_Minus_endcap_AFEB_RawHits_Time)
720  mo_CSC_Minus_endcap_AFEB_RawHits_Time->Fill(tbin);
721  }
722 
723  if (getCSCHisto(h::CSC_ALCT_LYXX_RATE, crateID, dmbID, nLayer, mo)) {
724  mo->Fill(wg - 1);
725  int number_wg = (int)(mo->GetBinContent(wg));
726  Double_t Number_of_entries_ALCT = mo->GetEntries();
727  if (getCSCHisto(h::CSC_ALCT_LYXX_EFFICIENCY, crateID, dmbID, nLayer, mo)) {
728  mo->SetBinContent(wg, ((float)number_wg));
729  if ((Double_t)(DMBEvents) > 0.0) {
730  mo->SetNormFactor(100.0 * Number_of_entries_ALCT / (Double_t)(DMBEvents));
731  } else {
732  mo->SetNormFactor(100.0);
733  }
734  mo->SetEntries((int)DMBEvents);
735  }
736  }
737  }
738  if (wg != wg_previous) {
739  NumberOfWireGroupsWithHitsInALCT = NumberOfWireGroupsWithHitsInALCT + 1;
740  }
741 
742  wg_previous = wg;
743  tbin_previous = tbin;
744  }
745  }
746 
747  // Fill Summary Anode Raw Hits Timing Plots
748  if (mo_AFEB_RawHits_TimeBins) {
749  double rawhits_time_mean = mo_AFEB_RawHits_TimeBins->getTH1()->GetMean();
750  double rawhits_time_rms = mo_AFEB_RawHits_TimeBins->getTH1()->GetRMS();
751 
752  if (cscPosition && mo_CSC_AFEB_RawHits_Time_mean) {
753  mo_CSC_AFEB_RawHits_Time_mean->SetBinContent(cscPosition, cscType + 1, rawhits_time_mean);
754  }
755 
756  if (cscPosition && mo_CSC_AFEB_RawHits_Time_rms) {
757  mo_CSC_AFEB_RawHits_Time_rms->SetBinContent(cscPosition, cscType + 1, rawhits_time_rms);
758  }
759  }
760  }
761 
762  } else {
763  LOG_ERROR << cscTag << " Can not unpack Anode Data";
764  }
765 
766  if (getCSCHisto(h::CSC_ALCT_NUMBER_OF_LAYERS_WITH_HITS, crateID, dmbID, mo)) {
767  mo->Fill(NumberOfLayersWithHitsInALCT);
768  MonitorObject* mo1 = nullptr;
769  if (cscPosition && getEMUHisto(h::EMU_CSC_ALCT_PLANES_WITH_HITS, mo1)) {
770  mo1->SetBinContent(cscPosition, cscType + 1, mo->getTH1()->GetMean());
771  }
772  }
773 
774  if (getCSCHisto(h::CSC_ALCT_NUMBER_OF_WIREGROUPS_WITH_HITS, crateID, dmbID, mo))
775  mo->Fill(NumberOfWireGroupsWithHitsInALCT);
776 
777  } else {
778  LOG_ERROR << cscTag << " Can not unpack ALCT Header or/and Trailer";
779  }
780  } else {
783  if (getCSCHisto(h::CSC_ALCT_NUMBER_RATE, crateID, dmbID, mo)) {
784  mo->Fill(0);
785  int nALCT = (int)mo->GetBinContent(1);
786  if (getCSCHisto(h::CSC_ALCT_NUMBER_EFFICIENCY, crateID, dmbID, mo))
787  mo->SetBinContent(1, (float)(nALCT) / (float)(DMBEvents)*100.0);
788  }
789 
790  if ((alct_dav > 0) && (getCSCHisto(h::CSC_DMB_FEB_UNPACKED_VS_DAV, crateID, dmbID, mo))) {
791  mo->Fill(0.0, 1.0);
792  }
793  }
794 
796  if (data.nclct() && data.nalct()) {
797  CSCALCTHeader* alctHeader = data.alctHeader();
798 
799  if (alctHeader) {
800  std::vector<CSCALCTDigi> alctsDatasTmp = alctHeader->ALCTDigis();
801  std::vector<CSCALCTDigi> alctsDatas;
802 
803  for (uint32_t lct = 0; lct < alctsDatasTmp.size(); lct++) {
804  if (alctsDatasTmp[lct].isValid())
805  alctsDatas.push_back(alctsDatasTmp[lct]);
806  }
807 
808  CSCTMBData* tmbData = data.tmbData();
809  if (tmbData) {
810  CSCTMBHeader* tmbHeader = tmbData->tmbHeader();
811  if (tmbHeader) {
813  if (getCSCHisto(h::CSC_TMB_BXN_VS_ALCT_BXN, crateID, dmbID, mo))
814  mo->Fill(((int)(alctHeader->BXNCount())) % 256, ((int)(tmbHeader->BXNCount())) % 256);
815 
816  if (getCSCHisto(h::CSC_TMB_ALCT_BXN_DIFF, crateID, dmbID, mo)) {
817  int clct_alct_bxn_diff = (int)(alctHeader->BXNCount() - tmbHeader->BXNCount());
818  if (clct_alct_bxn_diff < -2048)
819  mo->Fill(clct_alct_bxn_diff + 4096);
820  else {
821  if (clct_alct_bxn_diff > 2048)
822  mo->Fill(clct_alct_bxn_diff - 4096);
823  else
824  mo->Fill(clct_alct_bxn_diff);
825  }
826  mo->SetAxisRange(0.1, 1.1 * (1.0 + mo->GetBinContent(mo->GetMaximumBin())), "Y");
827  }
828 
829  if (getCSCHisto(h::CSC_TMB_L1A_VS_ALCT_L1A, crateID, dmbID, mo))
830  mo->Fill((int)(alctHeader->L1Acc() % 256), (int)(tmbHeader->L1ANumber() % 256));
831 
832  if (getCSCHisto(h::CSC_TMB_ALCT_L1A_DIFF, crateID, dmbID, mo)) {
833  int clct_alct_l1a_diff = (int)(tmbHeader->L1ANumber() - alctHeader->L1Acc());
834  if (clct_alct_l1a_diff < -2048)
835  mo->Fill(clct_alct_l1a_diff + 4096);
836  else {
837  if (clct_alct_l1a_diff > 2048)
838  mo->Fill(clct_alct_l1a_diff - 4096);
839  else
840  mo->Fill(clct_alct_l1a_diff);
841  }
842  mo->SetAxisRange(0.1, 1.1 * (1.0 + mo->GetBinContent(mo->GetMaximumBin())), "Y");
843  }
844  } else {
845  LOG_ERROR << cscTag << " Can not unpack TMB Header";
846  }
847 
848  } else {
849  LOG_ERROR << cscTag << " Can not unpack TMB Data";
850  }
851  } else {
852  LOG_ERROR << cscTag << " Can not unpack ALCT Header";
853  }
854  }
855 
857  if (data.nclct()) {
860  CSCTMBData* tmbData = data.tmbData();
861  if (tmbData) {
862  CSCTMBHeader* tmbHeader = tmbData->tmbHeader();
863  CSCTMBTrailer* tmbTrailer = tmbData->tmbTrailer();
864 
865  if (tmbHeader && tmbTrailer) {
866  CSCComparatorData* comparatorData = data.comparatorData();
867 
868  std::vector<CSCCLCTDigi> clctsDatasTmp = tmbHeader->CLCTDigis(cid.rawId());
869  std::vector<CSCCLCTDigi> clctsDatas;
870 
871  for (uint32_t lct = 0; lct < clctsDatasTmp.size(); lct++) {
872  if (clctsDatasTmp[lct].isValid())
873  clctsDatas.push_back(clctsDatasTmp[lct]);
874  }
875 
876  FEBunpacked = FEBunpacked + 1;
877  tmb_unpacked = 1;
878 
879  if (getCSCHisto(h::CSC_ALCT_MATCH_TIME, crateID, dmbID, mo)) {
880  mo->Fill(tmbHeader->ALCTMatchTime());
881  double alct_match_mean = mo->getTH1()->GetMean();
882  double alct_match_rms = mo->getTH1()->GetRMS();
883  MonitorObject* mo1 = nullptr;
884 
885  if (cid.endcap() == 1) {
886  if (cscPosition && getEMUHisto(h::EMU_CSC_ENDCAP_PLUS_ALCT_CLCT_MATCH_TIME, mo1)) {
887  mo1->Fill(tmbHeader->ALCTMatchTime());
888  }
889  }
890 
891  if (cid.endcap() == 2) {
892  if (cscPosition && getEMUHisto(h::EMU_CSC_ENDCAP_MINUS_ALCT_CLCT_MATCH_TIME, mo1)) {
893  mo1->Fill(tmbHeader->ALCTMatchTime());
894  }
895  }
896 
897  if (cscPosition && getEMUHisto(h::EMU_CSC_ALCT_CLCT_MATCH_MEAN, mo1)) {
898  mo1->SetBinContent(cscPosition, cscType + 1, alct_match_mean);
899  }
900 
901  if (cscPosition && getEMUHisto(h::EMU_CSC_ALCT_CLCT_MATCH_RMS, mo1)) {
902  mo1->SetBinContent(cscPosition, cscType + 1, alct_match_rms);
903  }
904  }
905 
906  if (getCSCHisto(h::CSC_LCT_MATCH_STATUS, crateID, dmbID, mo)) {
907  if (tmbHeader->CLCTOnly())
908  mo->Fill(0.0, 0.0);
909  if (tmbHeader->ALCTOnly())
910  mo->Fill(0.0, 1.0);
911  if (tmbHeader->TMBMatch())
912  mo->Fill(0.0, 2.0);
913  }
914 
915  if (getCSCHisto(h::CSC_LCT0_MATCH_BXN_DIFFERENCE, crateID, dmbID, mo))
916  mo->Fill(tmbHeader->Bxn0Diff());
917  if (getCSCHisto(h::CSC_LCT1_MATCH_BXN_DIFFERENCE, crateID, dmbID, mo))
918  mo->Fill(tmbHeader->Bxn1Diff());
919 
920  if ((tmb_dav > 0) && (getCSCHisto(h::CSC_DMB_FEB_UNPACKED_VS_DAV, crateID, dmbID, mo))) {
921  mo->Fill(1.0, 0.0);
922  }
923 
925  if (getCSCHisto(h::CSC_CSC_RATE, crateID, dmbID, mo)) {
926  mo->Fill(3);
927  uint32_t CLCTEvent = (uint32_t)mo->GetBinContent(4);
928  config->setChamberCounterValue(CLCT_TRIGGERS, crateID, dmbID, CLCTEvent);
929  if (getCSCHisto(h::CSC_CSC_EFFICIENCY, crateID, dmbID, mo)) {
930  if (config->getNEvents() > 0) {
931  mo->SetBinContent(2, ((float)CLCTEvent / (float)(DMBEvents)*100.0));
932  mo->SetEntries(DMBEvents);
933  }
934  }
935  }
936 
937  if (getCSCHisto(h::CSC_CLCT_L1A, crateID, dmbID, mo))
938  mo->Fill(tmbHeader->L1ANumber());
939 
941  if (getCSCHisto(h::CSC_CLCT_DMB_L1A_DIFF, crateID, dmbID, mo)) {
942  int clct_dmb_l1a_diff = (int)((tmbHeader->L1ANumber() % 64) - dmbHeader->l1a24() % 64);
943  if (clct_dmb_l1a_diff != 0)
944  L1A_out_of_sync = true;
945  if (clct_dmb_l1a_diff < -32)
946  mo->Fill(clct_dmb_l1a_diff + 64);
947  else {
948  if (clct_dmb_l1a_diff >= 32)
949  mo->Fill(clct_dmb_l1a_diff - 64);
950  else
951  mo->Fill(clct_dmb_l1a_diff);
952  }
953  mo->SetAxisRange(0.1, 1.1 * (1.0 + mo->GetBinContent(mo->GetMaximumBin())), "Y");
954  }
955 
957  if (getCSCHisto(h::CSC_DMB_L1A_VS_CLCT_L1A, crateID, dmbID, mo))
958  mo->Fill(tmbHeader->L1ANumber() % 256, dmbHeader->l1a24() % 256);
959 
960  if (getCSCHisto(h::CSC_CLCT_DMB_BXN_DIFF, crateID, dmbID, mo)) {
961  int clct_dmb_bxn_diff = (int)(tmbHeader->BXNCount() % 64 - dmbHeader->bxn12() % 64);
962  if (clct_dmb_bxn_diff < -32)
963  mo->Fill(clct_dmb_bxn_diff + 64);
964  else {
965  if (clct_dmb_bxn_diff >= 32)
966  mo->Fill(clct_dmb_bxn_diff - 64);
967  else
968  mo->Fill(clct_dmb_bxn_diff);
969  }
970  mo->SetAxisRange(0.1, 1.1 * (1.0 + mo->GetBinContent(mo->GetMaximumBin())), "Y");
971  }
972 
973  if (getCSCHisto(h::CSC_CLCT_BXN, crateID, dmbID, mo))
974  mo->Fill((int)(tmbHeader->BXNCount()));
975 
977  if (getCSCHisto(h::CSC_CLCT_BXN_VS_DMB_BXN, crateID, dmbID, mo))
978  mo->Fill(tmbHeader->BXNCount() % 256, dmbHeader->bxn12() % 256);
979 
980  if (getCSCHisto(h::CSC_CLCT_NUMBER_RATE, crateID, dmbID, mo)) {
981  mo->Fill(clctsDatas.size());
982  int nCLCT = (int)mo->GetBinContent((int)(clctsDatas.size() + 1));
983  if (getCSCHisto(h::CSC_CLCT_NUMBER, crateID, dmbID, mo))
984  mo->SetBinContent((int)(clctsDatas.size() + 1), (float)(nCLCT) / (float)(DMBEvents)*100.0);
985  }
986 
987  if (clctsDatas.size() == 1) {
988  if (getCSCHisto(h::CSC_CLCT0_CLSSIFICATION, crateID, dmbID, mo)) {
989  if (clctsDatas[0].getStripType())
990  mo->Fill(0.0);
991  else
992  mo->Fill(1.0);
993  }
994  }
995 
996  if (clctsDatas.size() == 2) {
997  if (getCSCHisto(h::CSC_CLCT1_VS_CLCT0_KEY_STRIP, crateID, dmbID, mo))
998  mo->Fill(clctsDatas[0].getKeyStrip(), clctsDatas[1].getKeyStrip());
999  if (getCSCHisto(h::CSC_CLCT0_CLCT1_CLSSIFICATION, crateID, dmbID, mo)) {
1000  if (clctsDatas[0].getStripType() && clctsDatas[1].getStripType())
1001  mo->Fill(0.0);
1002  if (clctsDatas[0].getStripType() && !clctsDatas[1].getStripType())
1003  mo->Fill(1.0);
1004  if (!clctsDatas[0].getStripType() && clctsDatas[1].getStripType())
1005  mo->Fill(2.0);
1006  if (!clctsDatas[0].getStripType() && !clctsDatas[1].getStripType())
1007  mo->Fill(3.0);
1008  }
1009  }
1010 
1011  if (getCSCHisto(h::CSC_TMB_WORD_COUNT, crateID, dmbID, mo))
1012  mo->Fill((int)(tmbTrailer->wordCount()));
1015  MonitorObject* mo_CSC_Plus_endcap_CLCT0_dTime = nullptr;
1016  getEMUHisto(h::EMU_CSC_ENDCAP_PLUS_CLCT0_DTIME, mo_CSC_Plus_endcap_CLCT0_dTime);
1017 
1018  MonitorObject* mo_CSC_Minus_endcap_CLCT0_dTime = nullptr;
1019  getEMUHisto(h::EMU_CSC_ENDCAP_MINUS_CLCT0_DTIME, mo_CSC_Minus_endcap_CLCT0_dTime);
1020 
1021  MonitorObject* mo_CSC_CLCT0_BXN_mean = nullptr;
1022  getEMUHisto(h::EMU_CSC_CLCT0_BXN_MEAN, mo_CSC_CLCT0_BXN_mean);
1023 
1024  MonitorObject* mo_CSC_CLCT0_BXN_rms = nullptr;
1025  getEMUHisto(h::EMU_CSC_CLCT0_BXN_RMS, mo_CSC_CLCT0_BXN_rms);
1026 
1027  for (uint32_t lct = 0; lct < clctsDatas.size(); lct++) {
1028  if (getCSCHisto(h::CSC_CLCTXX_BXN, crateID, dmbID, lct, mo))
1029  mo->Fill(clctsDatas[lct].getFullBX() % 64);
1030 
1031  int clct_dtime = clctsDatas[lct].getFullBX() - tmbHeader->BXNCount();
1032  if (clct_dtime > 0) {
1033  clct_dtime -= 3564;
1034  }
1035 
1036  int dTime = clct_dtime;
1037 
1038  if (lct == 0) {
1039  if (cid.endcap() == 1) {
1040  if (mo_CSC_Plus_endcap_CLCT0_dTime)
1041  mo_CSC_Plus_endcap_CLCT0_dTime->Fill(dTime);
1042  }
1043  if (cid.endcap() == 2) {
1044  if (mo_CSC_Minus_endcap_CLCT0_dTime)
1045  mo_CSC_Minus_endcap_CLCT0_dTime->Fill(dTime);
1046  }
1047  }
1048 
1049  if (getCSCHisto(h::CSC_CLCTXX_DTIME, crateID, dmbID, lct, mo)) {
1050  /*
1051  int dTime = clct_dtime;
1052  if (clct_dtime < -16) {
1053  dTime = clct_dtime + 32;
1054  } else {
1055  if (clct_dtime > 16) dTime = clct_dtime - 32;
1056  }
1057  */
1058 
1059  mo->Fill(dTime);
1060  mo->SetAxisRange(0.1, 1.1 * (1.0 + mo->GetBinContent(mo->GetMaximumBin())), "Y");
1061 
1062  double dTime_mean = mo->getTH1()->GetMean();
1063  double dTime_rms = mo->getTH1()->GetRMS();
1064 
1065  // == For CLCT0 Fill Summary dTime Histograms
1066  if (lct == 0) {
1067  /* -- Moved
1068  if (cid.endcap() == 1) {
1069  if (mo_CSC_Plus_endcap_CLCT0_dTime) mo_CSC_Plus_endcap_CLCT0_dTime->Fill(dTime);
1070  }
1071  if (cid.endcap() == 2) {
1072  if (mo_CSC_Minus_endcap_CLCT0_dTime) mo_CSC_Minus_endcap_CLCT0_dTime->Fill(dTime);
1073  }
1074  */
1075  if (cscPosition && mo_CSC_CLCT0_BXN_mean) {
1076  mo_CSC_CLCT0_BXN_mean->SetBinContent(cscPosition, cscType + 1, dTime_mean);
1077  }
1078  if (cscPosition && mo_CSC_CLCT0_BXN_rms) {
1079  mo_CSC_CLCT0_BXN_rms->SetBinContent(cscPosition, cscType + 1, dTime_rms);
1080  }
1081  }
1082  }
1083 
1086  LOG_DEBUG << "LCT:" << lct << " Type:" << clctsDatas[lct].getStripType()
1087  << " Strip:" << clctsDatas[lct].getKeyStrip();
1088 
1089  if (clctsDatas[lct].getStripType()) { // HalfStrip Type
1090 
1091  if (getCSCHisto(h::CSC_CLCTXX_KEYHALFSTRIP, crateID, dmbID, lct, mo))
1092  mo->Fill(clctsDatas[lct].getKeyStrip());
1093 
1094  if (getCSCHisto(h::CSC_CLCTXX_DTIME_VS_HALF_STRIP, crateID, dmbID, lct, mo)) {
1095  mo->Fill((int)(clctsDatas[lct].getKeyStrip()), clct_dtime);
1096  /*
1097  if (clct_dtime < -16) {
1098  mo->Fill((int)(clctsDatas[lct].getKeyStrip()), clct_dtime + 32);
1099  } else {
1100  if (clct_dtime > 16) mo->Fill((int)(clctsDatas[lct].getKeyStrip()), clct_dtime - 32);
1101  else mo->Fill((int)(clctsDatas[lct].getKeyStrip()), clct_dtime);
1102  }
1103  */
1104  }
1105 
1106  if (getCSCHisto(h::CSC_CLCTXX_DTIME_PROFILE, crateID, dmbID, lct, mo)) {
1107  mo->Fill((int)(clctsDatas[lct].getKeyStrip()), clct_dtime);
1108  /*
1109  if (clct_dtime < -16) {
1110  mo->Fill((int)(clctsDatas[lct].getKeyStrip()), clct_dtime + 32);
1111  } else {
1112  if (clct_dtime > 16) mo->Fill((int)(clctsDatas[lct].getKeyStrip()), clct_dtime - 32);
1113  else mo->Fill((int)(clctsDatas[lct].getKeyStrip()), clct_dtime);
1114  }
1115  */
1116  }
1117 
1118  if (getCSCHisto(h::CSC_CLCTXX_HALF_STRIP_PATTERN, crateID, dmbID, lct, mo)) {
1119  int pattern_clct = clctsDatas[lct].getPattern();
1123  double tbin = -1;
1124 
1125  switch (pattern_clct) {
1126  case 0:
1127  tbin = 0.;
1128  break;
1129  case 1:
1130  tbin = 1.;
1131  break;
1132  case 2:
1133  tbin = 2.;
1134  break;
1135  case 3:
1136  tbin = 10.;
1137  break;
1138  case 4:
1139  tbin = 3.;
1140  break;
1141  case 5:
1142  tbin = 9.;
1143  break;
1144  case 6:
1145  tbin = 4.;
1146  break;
1147  case 7:
1148  tbin = 8.;
1149  break;
1150  case 8:
1151  tbin = 5.;
1152  break;
1153  case 9:
1154  tbin = 7.;
1155  break;
1156  case 10:
1157  tbin = 6.;
1158  break;
1159  }
1160 
1161  if (tbin >= 0)
1162  mo->Fill(clctsDatas[lct].getKeyStrip(), tbin);
1163 
1164  MonitorObject* mo1 = nullptr;
1165  if (getCSCHisto(h::CSC_CLCT_HALF_STRIP_PATTERN_DISTR, crateID, dmbID, lct, mo1))
1166  mo1->Fill(tbin);
1167  }
1168 
1169  if (getCSCHisto(h::CSC_CLCTXX_HALF_STRIP_QUALITY, crateID, dmbID, lct, mo))
1170  mo->Fill((int)(clctsDatas[lct].getKeyStrip()), (int)(clctsDatas[lct].getQuality()));
1171 
1172  if (mo_EventDisplay) {
1173  mo_EventDisplay->SetBinContent(10, clctsDatas[lct].getKeyStrip(), clct_dtime);
1174  mo_EventDisplay->SetBinContent(11, clctsDatas[lct].getKeyStrip(), clctsDatas[lct].getQuality());
1175  }
1176 
1177  if (getCSCHisto(h::CSC_CLCTXX_HALF_STRIP_QUALITY_DISTR, crateID, dmbID, lct, mo)) {
1178  mo->Fill((int)(clctsDatas[lct].getQuality()));
1179  if (lct == 0) {
1180  MonitorObject* mo1 = nullptr;
1181  if (cscPosition && getEMUHisto(h::EMU_CSC_CLCT0_QUALITY, mo1)) {
1182  mo1->SetBinContent(cscPosition, cscType + 1, mo->getTH1()->GetMean());
1183  }
1184  }
1185  }
1186 
1187  if (getCSCHisto(h::CSC_CLCTXX_HALF_STRIP_QUALITY_PROFILE, crateID, dmbID, lct, mo))
1188  mo->Fill((int)(clctsDatas[lct].getKeyStrip()), (int)(clctsDatas[lct].getQuality()));
1189 
1190  } else { // DiStrip Type
1191 
1192  LOG_INFO << "Entering block!";
1193 
1194  if (getCSCHisto(h::CSC_CLCTXX_KEYDISTRIP, crateID, dmbID, lct, mo))
1195  mo->Fill(clctsDatas[lct].getKeyStrip());
1196  else
1197  LOG_ERROR << "Not found h::CSC_CLCTXX_KEYDISTRIP = " << h::CSC_CLCTXX_KEYDISTRIP;
1198 
1199  if (lct == 0)
1200  clct_kewdistrip = clctsDatas[lct].getKeyStrip();
1201 
1202  if (getCSCHisto(h::CSC_CLCTXX_DTIME_VS_DISTRIP, crateID, dmbID, lct, mo)) {
1203  mo->Fill((int)(clctsDatas[lct].getKeyStrip()), clct_dtime);
1204  /*
1205  if(clct_dtime < -16) mo->Fill((int)(clctsDatas[lct].getKeyStrip()), clct_dtime + 32);
1206  else {
1207  if(clct_dtime > 16) mo->Fill((int)(clctsDatas[lct].getKeyStrip()), clct_dtime - 32);
1208  else mo->Fill((int)(clctsDatas[lct].getKeyStrip()), clct_dtime);
1209  }
1210  */
1211  }
1212 
1213  if (getCSCHisto(h::CSC_CLCTXX_DISTRIP_PATTERN, crateID, dmbID, lct, mo)) {
1214  int pattern_clct = (int)((clctsDatas[lct].getPattern() >> 1) & 0x3);
1217  if (pattern_clct == 1)
1218  mo->Fill(clctsDatas[lct].getKeyStrip(), 7.0);
1219  if (pattern_clct == 3)
1220  mo->Fill(clctsDatas[lct].getKeyStrip(), 6.0);
1221  if (pattern_clct == 5)
1222  mo->Fill(clctsDatas[lct].getKeyStrip(), 5.0);
1223  if (pattern_clct == 7)
1224  mo->Fill(clctsDatas[lct].getKeyStrip(), 4.0);
1225  if (pattern_clct == 6)
1226  mo->Fill(clctsDatas[lct].getKeyStrip(), 3.0);
1227  if (pattern_clct == 4)
1228  mo->Fill(clctsDatas[lct].getKeyStrip(), 2.0);
1229  if (pattern_clct == 2)
1230  mo->Fill(clctsDatas[lct].getKeyStrip(), 1.0);
1231  if (pattern_clct == 0)
1232  mo->Fill(clctsDatas[lct].getKeyStrip(), 0.0);
1233  }
1234 
1235  if (getCSCHisto(h::CSC_CLCTXX_DISTRIP_QUALITY, crateID, dmbID, lct, mo))
1236  mo->Fill((int)(clctsDatas[lct].getKeyStrip()), (int)(clctsDatas[lct].getQuality()));
1237 
1238  if (getCSCHisto(h::CSC_CLCTXX_DISTRIP_QUALITY_PROFILE, crateID, dmbID, lct, mo))
1239  mo->Fill((int)(clctsDatas[lct].getKeyStrip()), (int)(clctsDatas[lct].getQuality()));
1240  }
1241  }
1242 
1243  // int N_CFEBs = 5;
1244  int N_CFEBs = tmbHeader->NCFEBs();
1245 
1246  int NumberOfLayersWithHitsInCLCT = 0;
1247  int NumberOfHalfStripsWithHitsInCLCT = 0;
1248 
1249  if (comparatorData && comparatorData->check()) {
1250  MonitorObject* mo_CFEB_Comparators_TimeSamples = nullptr;
1251  getCSCHisto(h::CSC_CFEB_COMPARATORS_TIMESAMPLES, crateID, dmbID, mo_CFEB_Comparators_TimeSamples);
1252 
1253  MonitorObject* mo_CSC_Plus_endcap_CFEB_Comparators_Time = nullptr;
1254  getEMUHisto(h::EMU_CSC_ENDCAP_PLUS_CFEB_COMPARATORS_TIME, mo_CSC_Plus_endcap_CFEB_Comparators_Time);
1255 
1256  MonitorObject* mo_CSC_Minus_endcap_CFEB_Comparators_Time = nullptr;
1257  getEMUHisto(h::EMU_CSC_ENDCAP_MINUS_CFEB_COMPARATORS_TIME, mo_CSC_Minus_endcap_CFEB_Comparators_Time);
1258 
1259  MonitorObject* mo_CSC_CFEB_Comparators_Time_mean = nullptr;
1260  getEMUHisto(h::EMU_CSC_CFEB_COMPARATORS_TIME_MEAN, mo_CSC_CFEB_Comparators_Time_mean);
1261 
1262  MonitorObject* mo_CSC_CFEB_Comparators_Time_rms = nullptr;
1263  getEMUHisto(h::EMU_CSC_CFEB_COMPARATORS_TIME_RMS, mo_CSC_CFEB_Comparators_Time_rms);
1264 
1265  for (int nCFEB = 0; nCFEB < N_CFEBs; ++nCFEB) {
1266  for (int nLayer = 1; nLayer <= 6; nLayer++) {
1267  int hstrip_previous = -1;
1268  int tbin_clct_previous = -1;
1269  bool CheckLayerCLCT = true;
1270 
1271  std::vector<CSCComparatorDigi> compOutData = comparatorData->comparatorDigis(nLayer, nCFEB);
1272 
1273  for (std::vector<CSCComparatorDigi>::iterator compOutDataItr = compOutData.begin();
1274  compOutDataItr != compOutData.end();
1275  ++compOutDataItr) {
1277  int hstrip = 2 * (compOutDataItr->getStrip() - 1) + compOutDataItr->getComparator();
1278  std::vector<int> tbins_clct = compOutDataItr->getTimeBinsOn();
1279  int tbin_clct = (int)compOutDataItr->getTimeBin();
1280 
1281  if (mo_EventDisplay) {
1282  mo_EventDisplay->SetBinContent(nLayer + 11, hstrip, tbin_clct + 1);
1283  setEmuEventDisplayBit(mo_Emu_EventDisplay_Anode, glChamberIndex, 160 + hstrip, nLayer - 1);
1284  setEmuEventDisplayBit(mo_Emu_EventDisplay_XY, glChamberIndex, 160 + hstrip, nLayer - 1);
1285  }
1286 
1287  if (CheckLayerCLCT) {
1288  NumberOfLayersWithHitsInCLCT = NumberOfLayersWithHitsInCLCT + 1;
1289  CheckLayerCLCT = false;
1290  }
1291 
1292  for (uint32_t n = 0; n < tbins_clct.size(); n++) {
1293  tbin_clct = tbins_clct[n];
1294  if (hstrip != hstrip_previous ||
1295  (tbin_clct != tbin_clct_previous + 1 && tbin_clct != tbin_clct_previous - 1)) {
1296  if (getCSCHisto(h::CSC_CLCTTIME_LYXX, crateID, dmbID, nLayer, mo))
1297  mo->Fill(hstrip, tbin_clct);
1298 
1299  if (mo_CFEB_Comparators_TimeSamples)
1300  mo_CFEB_Comparators_TimeSamples->Fill(tbin_clct);
1301 
1302  if (cid.endcap() == 1) {
1303  if (mo_CSC_Plus_endcap_CFEB_Comparators_Time)
1304  mo_CSC_Plus_endcap_CFEB_Comparators_Time->Fill(tbin_clct);
1305  }
1306 
1307  if (cid.endcap() == 2) {
1308  if (mo_CSC_Minus_endcap_CFEB_Comparators_Time)
1309  mo_CSC_Minus_endcap_CFEB_Comparators_Time->Fill(tbin_clct);
1310  }
1311 
1312  if (getCSCHisto(h::CSC_CLCTTIME_LYXX_PROFILE, crateID, dmbID, nLayer, mo))
1313  mo->Fill(hstrip, tbin_clct);
1314 
1315  if (getCSCHisto(h::CSC_CLCT_LYXX_RATE, crateID, dmbID, nLayer, mo)) {
1316  mo->Fill(hstrip);
1317 
1318  double number_hstrip = mo->GetBinContent(hstrip + 1);
1319  double Number_of_entries_CLCT = mo->GetEntries();
1320 
1321  if (getCSCHisto(h::CSC_CLCT_LYXX_EFFICIENCY, crateID, dmbID, nLayer, mo)) {
1322  mo->SetBinContent(hstrip + 1, number_hstrip);
1323  if (DMBEvents > 0) {
1324  double norm = (100.0 * Number_of_entries_CLCT) / ((double)(DMBEvents));
1326  mo->SetNormFactor(norm);
1327  } else {
1328  mo->SetNormFactor(100.0);
1329  }
1330  mo->SetEntries(DMBEvents);
1331  }
1332  }
1333  }
1334 
1335  if (hstrip != hstrip_previous) {
1336  NumberOfHalfStripsWithHitsInCLCT = NumberOfHalfStripsWithHitsInCLCT + 1;
1337  }
1338  hstrip_previous = hstrip;
1339  tbin_clct_previous = tbin_clct;
1340  }
1341  }
1342  }
1343  }
1344 
1345  if (mo_CFEB_Comparators_TimeSamples) {
1346  double comps_time_mean = mo_CFEB_Comparators_TimeSamples->getTH1()->GetMean();
1347  double comps_time_rms = mo_CFEB_Comparators_TimeSamples->getTH1()->GetRMS();
1348 
1349  if (cscPosition && mo_CSC_CFEB_Comparators_Time_mean) {
1350  mo_CSC_CFEB_Comparators_Time_mean->SetBinContent(cscPosition, cscType + 1, comps_time_mean);
1351  }
1352  if (cscPosition && mo_CSC_CFEB_Comparators_Time_rms) {
1353  mo_CSC_CFEB_Comparators_Time_rms->SetBinContent(cscPosition, cscType + 1, comps_time_rms);
1354  }
1355  }
1356 
1357  } else {
1358  LOG_ERROR << cscTag << " Can not unpack CLCT Data";
1359  }
1360 
1361  if (getCSCHisto(h::CSC_CLCT_NUMBER_OF_LAYERS_WITH_HITS, crateID, dmbID, mo)) {
1362  mo->Fill(NumberOfLayersWithHitsInCLCT);
1363  MonitorObject* mo1 = nullptr;
1364  if (cscPosition && getEMUHisto(h::EMU_CSC_CLCT_PLANES_WITH_HITS, mo1)) {
1365  mo1->SetBinContent(cscPosition, cscType + 1, mo->getTH1()->GetMean());
1366  }
1367  }
1368 
1369  if (getCSCHisto(h::CSC_CLCT_NUMBER_OF_HALFSTRIPS_WITH_HITS, crateID, dmbID, mo))
1370  mo->Fill(NumberOfHalfStripsWithHitsInCLCT);
1371  } else {
1372  LOG_ERROR << cscTag << " Can not unpack TMB Header or/and Trailer";
1373  }
1374  } else {
1375  LOG_ERROR << cscTag << " Can not unpack TMB Data";
1376  }
1377 
1378  } else {
1381  if (getCSCHisto(h::CSC_CLCT_NUMBER_RATE, crateID, dmbID, mo)) {
1382  mo->Fill(0);
1383  int nCLCT = (int)mo->GetBinContent(1);
1384  if (getCSCHisto(h::CSC_CLCT_NUMBER, crateID, dmbID, mo))
1385  mo->SetBinContent(1, (float)(nCLCT) / (float)(DMBEvents)*100.0);
1386  }
1387  if ((tmb_dav > 0) && (getCSCHisto(h::CSC_DMB_FEB_UNPACKED_VS_DAV, crateID, dmbID, mo))) {
1388  mo->Fill(1.0, 1.0);
1389  }
1390  }
1391 
1393  int NumberOfUnpackedCFEBs = 0;
1394  const int N_CFEBs = nCFEBs, N_Samples = 16, N_Layers = 6, N_Strips = 16, nStrips = nCFEBs * N_Strips;
1395  int ADC = 0, OutOffRange, Threshold = 30;
1397  // CSCCFEBData * cfebData[N_CFEBs];
1398  // CSCCFEBTimeSlice * timeSlice[N_CFEBs][16];
1399  // CSCCFEBDataWord * timeSample[N_CFEBs][16][6][16];
1400  int Pedestal[N_CFEBs][6][16];
1401  memset(Pedestal, 0, sizeof(Pedestal));
1402 #ifdef __clang__
1403  std::vector<std::array<std::array<std::pair<int, int>, 6>, 16>> CellPeak(N_CFEBs);
1404  std::fill(CellPeak.begin(), CellPeak.end(), std::array<std::array<std::pair<int, int>, 6>, 16>{});
1405 #else
1406  std::pair<int, int> CellPeak[N_CFEBs][6][16];
1407  memset(CellPeak, 0, sizeof(CellPeak));
1408 #endif
1409  // float PedestalError[N_CFEBs][6][16];
1410  // CSCCFEBSCAControllerWord scaControllerWord[5][16][6];
1411  bool CheckCFEB = true;
1413  float Clus_Sum_Charge;
1414  int TrigTime, L1APhase, UnpackedTrigTime, LCTPhase, SCA_BLK, NmbTimeSamples;
1416  int FreeCells, LCT_Pipe_Empty, LCT_Pipe_Full, LCT_Pipe_Count, L1_Pipe_Empty, L1_Pipe_Full, Buffer_Count;
1419  bool CheckThresholdStripInTheLayer[6][nStrips];
1420  for (int i = 0; i < 6; i++) {
1421  for (int j = 0; j < nStrips; j++)
1422  CheckThresholdStripInTheLayer[i][j] = true;
1423  }
1424 
1425  bool CheckOutOffRangeStripInTheLayer[6][nStrips];
1426  for (int i = 0; i < 6; i++) {
1427  for (int j = 0; j < nStrips; j++)
1428  CheckOutOffRangeStripInTheLayer[i][j] = true;
1429  }
1430 
1432  float cscdata[N_CFEBs * 16][N_Samples][N_Layers];
1434  int SCABlockData[N_CFEBs * 16][N_Samples][N_Layers];
1435  memset(cscdata, 0, sizeof(cscdata));
1437  memset(SCABlockData, 0, sizeof(SCABlockData));
1440  char hbuf[255];
1441  memset(hbuf, 0, sizeof(hbuf));
1442 
1443  MonitorObject* mo_CFEB_SCA_CellPeak_Time = nullptr;
1444  getCSCHisto(h::CSC_CFEB_SCA_CELLPEAK_TIME, crateID, dmbID, mo_CFEB_SCA_CellPeak_Time);
1445 
1446  MonitorObject* mo_CSC_Plus_endcap_CFEB_SCA_CellPeak_Time = nullptr;
1447  getEMUHisto(h::EMU_CSC_PLUS_ENDCAP_CFEB_SCA_CELLPEAK_TIME, mo_CSC_Plus_endcap_CFEB_SCA_CellPeak_Time);
1448 
1449  MonitorObject* mo_CSC_Minus_endcap_CFEB_SCA_CellPeak_Time = nullptr;
1450  getEMUHisto(h::EMU_CSC_MINUS_ENDCAP_CFEB_SCA_CELLPEAK_TIME, mo_CSC_Minus_endcap_CFEB_SCA_CellPeak_Time);
1451 
1452  MonitorObject* mo_CSC_CFEB_SCA_CellPeak_Time_mean = nullptr;
1453  getEMUHisto(h::EMU_CSC_CFEB_SCA_CELLPEAK_TIME_MEAN, mo_CSC_CFEB_SCA_CellPeak_Time_mean);
1454 
1455  MonitorObject* mo_CSC_CFEB_SCA_CellPeak_Time_rms = nullptr;
1456  getEMUHisto(h::EMU_CSC_CFEB_SCA_CELLPEAK_TIME_RMS, mo_CSC_CFEB_SCA_CellPeak_Time_rms);
1457 
1458  for (int nCFEB = 0; nCFEB < N_CFEBs; ++nCFEB) {
1459  // cfebData[nCFEB] = data.cfebData(nCFEB);
1460  if (data.cfebData(nCFEB) != nullptr) {
1461  if (!data.cfebData(nCFEB)->check())
1462  continue;
1463 
1465  FEBunpacked = FEBunpacked + 1; // Increment number of unpacked FED
1466  NumberOfUnpackedCFEBs = NumberOfUnpackedCFEBs + 1; // Increment number of unpaked CFEB
1467  cfeb_unpacked = 1;
1468  if (CheckCFEB == true) {
1469  if (getCSCHisto(h::CSC_CSC_RATE, crateID, dmbID, mo)) {
1470  mo->Fill(4);
1471  uint32_t CFEBEvent = (uint32_t)mo->GetBinContent(5);
1472  config->setChamberCounterValue(CFEB_TRIGGERS, crateID, dmbID, CFEBEvent);
1473  if (getCSCHisto(h::CSC_CSC_EFFICIENCY, crateID, dmbID, mo)) {
1474  if (config->getNEvents() > 0) {
1475  mo->SetBinContent(3, ((float)CFEBEvent / (float)(DMBEvents)*100.0));
1476  mo->SetEntries((int)DMBEvents);
1477  }
1478  }
1479  }
1480 
1481  if ((cfeb_dav2 > 0) && (getCSCHisto(h::CSC_DMB_FEB_UNPACKED_VS_DAV, crateID, dmbID, mo))) {
1482  mo->Fill(2.0, 0.0);
1483  }
1484  CheckCFEB = false;
1485  }
1487  NmbTimeSamples = (data.cfebData(nCFEB))->nTimeSamples();
1493  MonitorObject* mo_CFEB_SCA_Block_Occupancy = nullptr;
1494  getCSCHisto(h::CSC_CFEBXX_SCA_BLOCK_OCCUPANCY, crateID, dmbID, nCFEB + 1, mo_CFEB_SCA_Block_Occupancy);
1495  MonitorObject* mo_CFEB_Free_SCA_Cells = nullptr;
1496  getCSCHisto(h::CSC_CFEBXX_FREE_SCA_CELLS, crateID, dmbID, nCFEB + 1, mo_CFEB_Free_SCA_Cells);
1497  MonitorObject* mo_CFEB_SCA_Blocks_Locked_by_LCTs = nullptr;
1498  getCSCHisto(
1499  h::CSC_CFEBXX_SCA_BLOCKS_LOCKED_BY_LCTS, crateID, dmbID, nCFEB + 1, mo_CFEB_SCA_Blocks_Locked_by_LCTs);
1500  MonitorObject* mo_CFEB_SCA_Blocks_Locked_by_LCTxL1 = nullptr;
1501  getCSCHisto(
1502  h::CSC_CFEBXX_SCA_BLOCKS_LOCKED_BY_LCTXL1, crateID, dmbID, nCFEB + 1, mo_CFEB_SCA_Blocks_Locked_by_LCTxL1);
1503  MonitorObject* mo_CFEB_DMB_L1A_diff = nullptr;
1504  getCSCHisto(h::CSC_CFEBXX_DMB_L1A_DIFF, crateID, dmbID, nCFEB + 1, mo_CFEB_DMB_L1A_diff);
1505 
1508  for (int nLayer = 1; nLayer <= N_Layers; ++nLayer) {
1510  MonitorObject* mo_CFEB_Out_Off_Range_Strips = nullptr;
1511  getCSCHisto(h::CSC_CFEB_OUT_OFF_RANGE_STRIPS_LYXX, crateID, dmbID, nLayer, mo_CFEB_Out_Off_Range_Strips);
1512  MonitorObject* mo_CFEB_Active_Samples_vs_Strip = nullptr;
1513  getCSCHisto(
1514  h::CSC_CFEB_ACTIVE_SAMPLES_VS_STRIP_LYXX, crateID, dmbID, nLayer, mo_CFEB_Active_Samples_vs_Strip);
1515  MonitorObject* mo_CFEB_Active_Samples_vs_Strip_Profile = nullptr;
1516  getCSCHisto(h::CSC_CFEB_ACTIVE_SAMPLES_VS_STRIP_LYXX_PROFILE,
1517  crateID,
1518  dmbID,
1519  nLayer,
1520  mo_CFEB_Active_Samples_vs_Strip_Profile);
1521  MonitorObject* mo_CFEB_ActiveStrips = nullptr;
1522  getCSCHisto(h::CSC_CFEB_ACTIVESTRIPS_LYXX, crateID, dmbID, nLayer, mo_CFEB_ActiveStrips);
1523  MonitorObject* mo_CFEB_SCA_Cell_Peak = nullptr;
1524  getCSCHisto(h::CSC_CFEB_SCA_CELL_PEAK_LY_XX, crateID, dmbID, nLayer, mo_CFEB_SCA_Cell_Peak);
1525 
1526  MonitorObject* mo_CFEB_Pedestal_withEMV_Sample = nullptr;
1527  getCSCHisto(
1528  h::CSC_CFEB_PEDESTAL_WITHEMV_SAMPLE_01_LYXX, crateID, dmbID, nLayer, mo_CFEB_Pedestal_withEMV_Sample);
1529  MonitorObject* mo_CFEB_Pedestal_withRMS_Sample = nullptr;
1530  getCSCHisto(
1531  h::CSC_CFEB_PEDESTAL_WITHRMS_SAMPLE_01_LYXX, crateID, dmbID, nLayer, mo_CFEB_Pedestal_withRMS_Sample);
1532  MonitorObject* mo_CFEB_PedestalRMS_Sample = nullptr;
1533  getCSCHisto(h::CSC_CFEB_PEDESTALRMS_SAMPLE_01_LYXX, crateID, dmbID, nLayer, mo_CFEB_PedestalRMS_Sample);
1534 
1535  for (int nSample = 0; nSample < NmbTimeSamples; ++nSample) {
1536  // timeSlice[nCFEB][nSample] = (CSCCFEBTimeSlice * )((cfebData[nCFEB])->timeSlice(nSample));
1537  if (timeSlice(data, nCFEB, nSample) == nullptr) {
1538  LOG_WARN << "CFEB" << nCFEB << " nSample: " << nSample << " - B-Word";
1539  continue;
1540  }
1541 
1542  if (mo_CFEB_DMB_L1A_diff && !fCloseL1As) {
1544  int cfeb_dmb_l1a_diff =
1545  (int)((timeSlice(data, nCFEB, nSample)->get_L1A_number()) - dmbHeader->l1a24() % 64);
1546  if (cfeb_dmb_l1a_diff != 0) {
1547  L1A_out_of_sync = true;
1548  }
1549  if (cfeb_dmb_l1a_diff < -32)
1550  mo->Fill(cfeb_dmb_l1a_diff + 64);
1551  else {
1552  if (cfeb_dmb_l1a_diff >= 32)
1553  mo->Fill(cfeb_dmb_l1a_diff - 64);
1554  else
1555  mo_CFEB_DMB_L1A_diff->Fill(cfeb_dmb_l1a_diff);
1556  }
1557  mo_CFEB_DMB_L1A_diff->SetAxisRange(
1558  0.1, 1.1 * (1.0 + mo_CFEB_DMB_L1A_diff->GetBinContent(mo_CFEB_DMB_L1A_diff->GetMaximumBin())), "Y");
1559  }
1560 
1563  // scaControllerWord[nCFEB][nSample][nLayer-1] = timeSlice(cfebData, nCFEB, nSample)->scaControllerWord(nLayer);
1564 
1565  // TrigTime = (int)(timeSlice(data, nCFEB, nSample)->scaControllerWord(nLayer).trig_time);
1567  FreeCells = timeSlice(data, nCFEB, nSample)->get_n_free_sca_blocks();
1568  LCT_Pipe_Empty = timeSlice(data, nCFEB, nSample)->get_lctpipe_empty();
1569  LCT_Pipe_Full = timeSlice(data, nCFEB, nSample)->get_lctpipe_full();
1570  LCT_Pipe_Count = timeSlice(data, nCFEB, nSample)->get_lctpipe_count();
1571  L1_Pipe_Empty = timeSlice(data, nCFEB, nSample)->get_l1pipe_empty();
1572  L1_Pipe_Full = timeSlice(data, nCFEB, nSample)->get_l1pipe_full();
1574  Buffer_Count = timeSlice(data, nCFEB, nSample)->get_buffer_count();
1575 
1576  SCA_BLK = (int)(timeSlice(data, nCFEB, nSample)->scaControllerWord(nLayer).sca_blk);
1580  for (int nStrip = 0; nStrip < N_Strips; ++nStrip) {
1581  SCABlockData[nCFEB * 16 + nStrip][nSample][nLayer - 1] = SCA_BLK;
1583  }
1588  if (mo_CFEB_SCA_Block_Occupancy)
1589  mo_CFEB_SCA_Block_Occupancy->Fill(SCA_BLK);
1590 
1593  if (mo_CFEB_Free_SCA_Cells) {
1594  if (timeSlice(data, nCFEB, nSample)->scaControllerWord(nLayer).sca_full == 1)
1595  mo_CFEB_Free_SCA_Cells->Fill(-1);
1596  mo_CFEB_Free_SCA_Cells->Fill(FreeCells);
1597  }
1598 
1601  if (mo_CFEB_SCA_Blocks_Locked_by_LCTs) {
1602  if (LCT_Pipe_Empty == 1)
1603  mo_CFEB_SCA_Blocks_Locked_by_LCTs->Fill(-0.5);
1604  if (LCT_Pipe_Full == 1)
1605  mo_CFEB_SCA_Blocks_Locked_by_LCTs->Fill(16.5);
1606  mo_CFEB_SCA_Blocks_Locked_by_LCTs->Fill(LCT_Pipe_Count);
1607  }
1608 
1611  if (mo_CFEB_SCA_Blocks_Locked_by_LCTxL1) {
1612  if (L1_Pipe_Empty == 1)
1613  mo_CFEB_SCA_Blocks_Locked_by_LCTxL1->Fill(-0.5);
1614  if (L1_Pipe_Full == 1)
1615  mo_CFEB_SCA_Blocks_Locked_by_LCTxL1->Fill(31.5);
1616  mo_CFEB_SCA_Blocks_Locked_by_LCTxL1->Fill(Buffer_Count);
1617  }
1618 
1621  if (nSample == 0 && nLayer == 1) {
1622  TrigTime = (int)(timeSlice(data, nCFEB, nSample)->scaControllerWord(nLayer).trig_time);
1623  int k = 1;
1624  while (((TrigTime >> (k - 1)) & 0x1) != 1 && k <= 8) {
1625  k = k + 1;
1626  }
1627  L1APhase = (int)((timeSlice(data, nCFEB, nSample)->scaControllerWord(nLayer).l1a_phase) & 0x1);
1628  UnpackedTrigTime = ((k << 1) & 0xE) + L1APhase;
1629 
1630  if (getCSCHisto(h::CSC_CFEBXX_L1A_SYNC_TIME, crateID, dmbID, nCFEB + 1, mo))
1631  mo->Fill((int)UnpackedTrigTime);
1632  LCTPhase = (int)((timeSlice(data, nCFEB, nSample)->scaControllerWord(nLayer).lct_phase) & 0x1);
1633 
1634  if (getCSCHisto(h::CSC_CFEBXX_LCT_PHASE_VS_L1A_PHASE, crateID, dmbID, nCFEB + 1, mo))
1635  mo->Fill(LCTPhase, L1APhase);
1636 
1639  if (getCSCHisto(h::CSC_CFEBXX_L1A_SYNC_TIME_VS_DMB, crateID, dmbID, nCFEB + 1, mo))
1640  mo->Fill((int)(dmbHeader->dmbCfebSync()), (int)UnpackedTrigTime);
1641 
1642  if (getCSCHisto(h::CSC_CFEBXX_L1A_SYNC_TIME_DMB_DIFF, crateID, dmbID, nCFEB + 1, mo)) {
1643  int cfeb_dmb_L1A_sync_time = (int)(dmbHeader->dmbCfebSync()) - (int)UnpackedTrigTime;
1644  if (cfeb_dmb_L1A_sync_time < -8)
1645  mo->Fill(cfeb_dmb_L1A_sync_time + 16);
1646  else {
1647  if (cfeb_dmb_L1A_sync_time >= 8)
1648  mo->Fill(cfeb_dmb_L1A_sync_time - 16);
1649  else
1650  mo->Fill(cfeb_dmb_L1A_sync_time);
1651  }
1652  mo->SetAxisRange(0.1, 1.1 * (1.0 + mo->GetBinContent(mo->GetMaximumBin())), "Y");
1653  }
1654  }
1655 
1656  for (int nStrip = 1; nStrip <= N_Strips; ++nStrip) {
1657  // timeSample[nCFEB][nSample][nLayer - 1][nStrip - 1]=(data.cfebData(nCFEB)->timeSlice(nSample))->timeSample(nLayer,nStrip,data.cfebData(nCFEB)->isDCFEB());
1658  ADC = (int)((timeSample(data, nCFEB, nSample, nLayer, nStrip)->adcCounts) & 0xFFF);
1660  OutOffRange = (int)((timeSample(data, nCFEB, nSample, nLayer, nStrip)->adcOverflow) & 0x1);
1661 
1662  if (nSample == 0) { // nSample == 0
1663  CellPeak[nCFEB][nLayer - 1][nStrip - 1] = std::make_pair(nSample, ADC);
1664  Pedestal[nCFEB][nLayer - 1][nStrip - 1] = ADC;
1666  }
1667 
1668  if (OutOffRange == 1 && CheckOutOffRangeStripInTheLayer[nLayer - 1][nCFEB * 16 + nStrip - 1] == true) {
1670  if (mo_CFEB_Out_Off_Range_Strips)
1671  mo_CFEB_Out_Off_Range_Strips->Fill((int)(nCFEB * 16 + nStrip - 1));
1672  CheckOutOffRangeStripInTheLayer[nLayer - 1][nCFEB * 16 + nStrip - 1] = false;
1673  }
1674  if (ADC - Pedestal[nCFEB][nLayer - 1][nStrip - 1] > Threshold && OutOffRange != 1) {
1676  if (mo_CFEB_Active_Samples_vs_Strip)
1677  mo_CFEB_Active_Samples_vs_Strip->Fill((int)(nCFEB * 16 + nStrip - 1), nSample);
1678 
1680  if (mo_CFEB_Active_Samples_vs_Strip_Profile)
1681  mo_CFEB_Active_Samples_vs_Strip_Profile->Fill((int)(nCFEB * 16 + nStrip - 1), nSample);
1682 
1683  if (CheckThresholdStripInTheLayer[nLayer - 1][nCFEB * 16 + nStrip - 1] == true) {
1685  if (mo_CFEB_ActiveStrips)
1686  mo_CFEB_ActiveStrips->Fill((int)(nCFEB * 16 + nStrip));
1687  CheckThresholdStripInTheLayer[nLayer - 1][nCFEB * 16 + nStrip - 1] = false;
1688  }
1690  if (ADC - Pedestal[nCFEB][nLayer - 1][nStrip - 1] > Threshold) {
1692  cscdata[nCFEB * 16 + nStrip - 1][nSample][nLayer - 1] = ADC - Pedestal[nCFEB][nLayer - 1][nStrip - 1];
1693  }
1695  if (ADC > CellPeak[nCFEB][nLayer - 1][nStrip - 1].second) {
1696  CellPeak[nCFEB][nLayer - 1][nStrip - 1].first = nSample;
1697  CellPeak[nCFEB][nLayer - 1][nStrip - 1].second = ADC;
1698  }
1699  }
1702  if (nSample == 1) {
1703  int channel_threshold = 40;
1704  if (std::abs(ADC - Pedestal[nCFEB][nLayer - 1][nStrip - 1]) < channel_threshold) {
1706  if (mo_CFEB_Pedestal_withEMV_Sample)
1707  mo_CFEB_Pedestal_withEMV_Sample->Fill((int)(nCFEB * 16 + nStrip - 1),
1708  Pedestal[nCFEB][nLayer - 1][nStrip - 1]);
1709 
1711  if (mo_CFEB_Pedestal_withRMS_Sample) {
1712  mo_CFEB_Pedestal_withRMS_Sample->Fill((int)(nCFEB * 16 + nStrip - 1),
1713  Pedestal[nCFEB][nLayer - 1][nStrip - 1]);
1714  // PedestalError[nCFEB][nLayer - 1][nStrip - 1] = mo_CFEB_Pedestal_withRMS_Sample->GetBinError(nCFEB * 16 + nStrip);
1715 
1717  if (mo_CFEB_PedestalRMS_Sample) {
1718  mo_CFEB_PedestalRMS_Sample->SetBinContent(
1719  nCFEB * 16 + nStrip - 1, mo_CFEB_Pedestal_withRMS_Sample->GetBinError(nCFEB * 16 + nStrip));
1720  mo_CFEB_PedestalRMS_Sample->SetBinError(nCFEB * 16 + nStrip - 1, 0.00000000001);
1721  }
1722  }
1723  }
1724  Pedestal[nCFEB][nLayer - 1][nStrip - 1] += ADC;
1725  Pedestal[nCFEB][nLayer - 1][nStrip - 1] /= 2;
1726  }
1728  }
1729  }
1730 
1731  for (int nStrip = 1; nStrip <= N_Strips; ++nStrip) {
1732  if (mo_CFEB_SCA_Cell_Peak && CellPeak[nCFEB][nLayer - 1][nStrip - 1].first) {
1733  mo_CFEB_SCA_Cell_Peak->Fill((int)(nCFEB * 16 + nStrip - 1),
1734  CellPeak[nCFEB][nLayer - 1][nStrip - 1].first);
1735  if (mo_CFEB_SCA_CellPeak_Time) {
1736  mo_CFEB_SCA_CellPeak_Time->Fill(CellPeak[nCFEB][nLayer - 1][nStrip - 1].first);
1737  }
1738 
1739  if (mo_EventDisplay) {
1740  int peak_sample = CellPeak[nCFEB][nLayer - 1][nStrip - 1].first;
1741  int peak_adc = CellPeak[nCFEB][nLayer - 1][nStrip - 1].second;
1742  int pedestal = Pedestal[nCFEB][nLayer - 1][nStrip - 1];
1743  int peak_sca_charge = peak_adc - pedestal;
1744 
1745  if (peak_adc - pedestal > Threshold) {
1746  if (peak_sample >= 1) {
1747  peak_sca_charge +=
1748  ((timeSample(data, nCFEB, peak_sample - 1, nLayer, nStrip)->adcCounts) & 0xFFF) - pedestal;
1749  }
1750  if (peak_sample < NmbTimeSamples - 1) {
1751  peak_sca_charge +=
1752  ((timeSample(data, nCFEB, peak_sample + 1, nLayer, nStrip)->adcCounts) & 0xFFF) - pedestal;
1753  }
1754  mo_EventDisplay->SetBinContent(nLayer + 17, nCFEB * 16 + nStrip - 1, peak_sca_charge);
1755  setEmuEventDisplayBit(
1756  mo_Emu_EventDisplay_Cathode, glChamberIndex, nCFEB * 16 + nStrip - 1, nLayer - 1);
1757  }
1758  }
1759 
1760  if (cid.endcap() == 1) {
1761  if (mo_CSC_Plus_endcap_CFEB_SCA_CellPeak_Time)
1762  mo_CSC_Plus_endcap_CFEB_SCA_CellPeak_Time->Fill(CellPeak[nCFEB][nLayer - 1][nStrip - 1].first);
1763  }
1764  if (cid.endcap() == 2) {
1765  if (mo_CSC_Minus_endcap_CFEB_SCA_CellPeak_Time)
1766  mo_CSC_Minus_endcap_CFEB_SCA_CellPeak_Time->Fill(CellPeak[nCFEB][nLayer - 1][nStrip - 1].first);
1767  }
1768  }
1769  }
1770  }
1771  }
1772  }
1773 
1774  // Fill Summary CFEB Raw Hits Timing Plots
1775  if (mo_CFEB_SCA_CellPeak_Time) {
1776  double cellpeak_time_mean = mo_CFEB_SCA_CellPeak_Time->getTH1()->GetMean();
1777  double cellpeak_time_rms = mo_CFEB_SCA_CellPeak_Time->getTH1()->GetRMS();
1778  if (cscPosition && mo_CSC_CFEB_SCA_CellPeak_Time_mean) {
1779  mo_CSC_CFEB_SCA_CellPeak_Time_mean->SetBinContent(cscPosition, cscType + 1, cellpeak_time_mean);
1780  }
1781  if (cscPosition && mo_CSC_CFEB_SCA_CellPeak_Time_rms) {
1782  mo_CSC_CFEB_SCA_CellPeak_Time_rms->SetBinContent(cscPosition, cscType + 1, cellpeak_time_rms);
1783  }
1784  }
1785 
1788  const int a = N_CFEBs * N_Strips;
1789  const int b = a * N_Samples;
1790  float Cathodes[b * N_Layers];
1791  for (int i = 0; i < N_Layers; ++i) {
1792  const int b1 = i * b;
1793  for (int j = 0; j < a; ++j) {
1794  const int b2 = b1 + j;
1795  for (int k = 0; k < N_Samples; ++k) {
1796  Cathodes[b2 + a * k] = cscdata[j][k][i];
1797  }
1798  }
1799  }
1800 
1801  std::vector<StripCluster> Clus;
1802  Clus.clear();
1803  StripClusterFinder ClusterFinder(N_Layers, N_Samples, N_CFEBs, N_Strips);
1804 
1805  for (int nLayer = 1; nLayer <= N_Layers; ++nLayer) {
1808  ClusterFinder.DoAction(nLayer - 1, Cathodes);
1809  Clus = ClusterFinder.getClusters();
1810 
1813  if (getCSCHisto(h::CSC_CFEB_NUMBER_OF_CLUSTERS_LY_XX, crateID, dmbID, nLayer, mo)) {
1814  // Allways true because Clus.size() = unsigned
1815  // if (Clus.size() >= 0)
1816  mo->Fill(Clus.size());
1817  }
1818 
1819  for (uint32_t u = 0; u < Clus.size(); u++) {
1820  Clus_Sum_Charge = 0.0;
1821 
1822  for (uint32_t k = 0; k < Clus[u].ClusterPulseMapHeight.size(); k++) {
1825  for (int n = Clus[u].LFTBNDTime; n < Clus[u].IRTBNDTime; n++) {
1826  Clus_Sum_Charge = Clus_Sum_Charge + Clus[u].ClusterPulseMapHeight[k].height_[n];
1827  }
1828  }
1829 
1831  if (getCSCHisto(h::CSC_CFEB_CLUSTERS_CHARGE_LY_XX, crateID, dmbID, nLayer, mo)) {
1832  mo->Fill(Clus_Sum_Charge);
1833  }
1834 
1836  if (getCSCHisto(h::CSC_CFEB_WIDTH_OF_CLUSTERS_LY_XX, crateID, dmbID, nLayer, mo)) {
1837  mo->Fill(Clus[u].IRTBNDStrip - Clus[u].LFTBNDStrip + 1);
1838  }
1839 
1841  if (getCSCHisto(h::CSC_CFEB_CLUSTER_DURATION_LY_XX, crateID, dmbID, nLayer, mo)) {
1842  mo->Fill(Clus[u].IRTBNDTime - Clus[u].LFTBNDTime + 1);
1843  }
1844  }
1845 
1846  Clus.clear();
1847 
1849  }
1850 
1854  if (getCSCHisto(h::CSC_DMB_FEB_COMBINATIONS_UNPACKED_VS_DAV, crateID, dmbID, mo)) {
1855  float feb_combination_unpacked = -1.0;
1856  if (alct_unpacked == 0 && tmb_unpacked == 0 && cfeb_unpacked == 0)
1857  feb_combination_unpacked = 0.0;
1858  if (alct_unpacked > 0 && tmb_unpacked == 0 && cfeb_unpacked == 0)
1859  feb_combination_unpacked = 1.0;
1860  if (alct_unpacked == 0 && tmb_unpacked > 0 && cfeb_unpacked == 0)
1861  feb_combination_unpacked = 2.0;
1862  if (alct_unpacked == 0 && tmb_unpacked == 0 && cfeb_unpacked > 0)
1863  feb_combination_unpacked = 3.0;
1864  if (alct_unpacked > 0 && tmb_unpacked > 0 && cfeb_unpacked == 0)
1865  feb_combination_unpacked = 4.0;
1866  if (alct_unpacked > 0 && tmb_unpacked == 0 && cfeb_unpacked > 0)
1867  feb_combination_unpacked = 5.0;
1868  if (alct_unpacked == 0 && tmb_unpacked > 0 && cfeb_unpacked > 0)
1869  feb_combination_unpacked = 6.0;
1870  if (alct_unpacked > 0 && tmb_unpacked > 0 && cfeb_unpacked > 0)
1871  feb_combination_unpacked = 7.0;
1872  mo->Fill(feb_combination_dav, feb_combination_unpacked);
1873  }
1874 
1875  if ((clct_kewdistrip > -1 && alct_keywg > -1) &&
1876  (getCSCHisto(h::CSC_CLCT0_KEYDISTRIP_VS_ALCT0_KEYWIREGROUP, crateID, dmbID, mo))) {
1877  mo->Fill(alct_keywg, clct_kewdistrip);
1878  }
1879 
1880  if (L1A_out_of_sync && cscPosition && getEMUHisto(h::EMU_CSC_L1A_OUT_OF_SYNC, mo)) {
1881  mo->Fill(cscPosition, cscType);
1882  }
1883 
1884  if (L1A_out_of_sync && getEMUHisto(h::EMU_DMB_L1A_OUT_OF_SYNC, mo)) {
1885  mo->Fill(crateID, dmbID);
1886  }
1887  }

References a, funct::abs(), CSCCFEBDataWord::adcCounts, CSCCFEBDataWord::adcOverflow, CSCDMBTrailer::alct_empty(), CSCDMBTrailer::alct_endtimeout(), CSCDMBTrailer::alct_full(), CSCDMBTrailer::alct_half(), CSCDMBTrailer::alct_starttimeout(), cscdqm::ALCT_TRIGGERS, CSCALCTHeader::ALCTDigis(), CSCALCTHeader::alctFirmwareVersion(), CSCTMBHeader::ALCTMatchTime(), CSCTMBHeader::ALCTOnly(), b, b1, b2, BXN, CSCTMBHeader::Bxn0Diff(), CSCDMBHeader::bxn12(), CSCTMBHeader::Bxn1Diff(), CSCTMBHeader::BXNCount(), CSCALCTHeader::BXNCount(), CSCDMBTrailer::cfeb_empty(), CSCDMBTrailer::cfeb_endtimeout(), CSCDMBTrailer::cfeb_full(), CSCDMBTrailer::cfeb_half(), CSCDMBTrailer::cfeb_starttimeout(), cscdqm::CFEB_TRIGGERS, CSCDMBHeader::cfebActive(), CSCDMBHeader::cfebAvailable(), CSCDMBHeader::cfebMovlp(), cscd2r::chamberID(), CSCComparatorData::check(), cscdqm::CLCT_TRIGGERS, CSCTMBHeader::CLCTDigis(), CSCTMBHeader::CLCTOnly(), CSCComparatorData::comparatorDigis(), CSCDMBHeader::crateID(), data, cscdqm::DMB_EVENTS, CSCDMBTrailer::dmb_l1pipe(), cscdqm::DMB_TRIGGERS, CSCDMBHeader::dmbCfebSync(), CSCDMBHeader::dmbID(), cscdqm::StripClusterFinder::DoAction(), CSCDetId::endcap(), CSCDCCExaminer::errorsForChamber(), cscdqm::EVENT_DISPLAY_PLOT, fCloseL1As, cscdqm::MonitorObject::Fill(), ntuplemaker::fill, first, dqmMemoryStats::float, amcDumpToRaw_cfi::fwVersion, CSCCFEBTimeSlice::get_buffer_count(), CSCCFEBTimeSlice::get_l1pipe_empty(), CSCCFEBTimeSlice::get_l1pipe_full(), CSCCFEBTimeSlice::get_lctpipe_count(), CSCCFEBTimeSlice::get_lctpipe_empty(), CSCCFEBTimeSlice::get_lctpipe_full(), CSCCFEBTimeSlice::get_n_free_sca_blocks(), cscdqm::MonitorObject::GetBinContent(), cscdqm::MonitorObject::GetBinError(), cscdqm::StripClusterFinder::getClusters(), getCSCFromMap(), getCSCHisto(), cscdqm::Summary::getDetector(), getEMUHisto(), cscdqm::MonitorObject::GetEntries(), cscdqm::MonitorObject::GetMaximumBin(), cscdqm::CSCHistoDef::getPath(), cscdqm::MonitorObject::getTH1(), cscdqm::MonitorObject::getTH1Lock(), cscdqm::Detector::GlobalChamberIndex(), mps_fire::i, createfilelist::int, cscdqm::Summary::isChamberStandby(), sistrip::SpyUtilities::isValid(), dqmiolumiharvest::j, dqmdumpme::k, CSCDMBHeader::l1a24(), CSCCFEBSCAControllerWord::l1a_phase, CSCALCTHeader::L1Acc(), CSCTMBHeader::L1ANumber(), L1ANumber, LOG_ERROR, LOG_INFO, LOG_WARN, dqmiodumpmetadata::n, CSCDMBHeader::nalct(), CSCTMBHeader::NCFEBs(), CSCDMBHeader::nclct(), me0TriggerPseudoDigis_cff::nStrips, topSingleLeptonDQM_PU_cfi::pattern, CalibrationSummaryClient_cfi::Pedestal, EcalCondDBWriter_cfi::pedestal, DetId::rawId(), CSCDetId::ring(), CSCCFEBSCAControllerWord::sca_blk, CSCCFEBTimeSlice::scaControllerWord(), edm::second(), cscdqm::MonitorObject::SetAxisRange(), cscdqm::MonitorObject::SetBinContent(), cscdqm::MonitorObject::SetBinError(), setEmuEventDisplayBit(), cscdqm::MonitorObject::SetEntries(), cscdqm::MonitorObject::SetNormFactor(), CSCDetId::station(), AlCaHLTBitMon_QueryRunRegistry::string, summary, theFormatVersion, HLT_FULL_cff::Threshold, cscdqm::timeSample(), cscdqm::timeSlice(), CSCDMBTrailer::tmb_empty(), CSCDMBTrailer::tmb_endtimeout(), CSCDMBTrailer::tmb_full(), CSCDMBTrailer::tmb_half(), CSCDMBTrailer::tmb_starttimeout(), CSCTMBData::tmbHeader(), CSCTMBHeader::TMBMatch(), CSCTMBData::tmbTrailer(), CSCCFEBSCAControllerWord::trig_time, CSCAnodeData::wireDigis(), CSCTMBTrailer::wordCount(), CSCALCTTrailer::wordCount(), and testProducerWithPsetDescEmpty_cfi::x1.

Referenced by processDDU().

◆ processDDU()

void cscdqm::EventProcessor::processDDU ( const CSCDDUEventData &  dduData,
const CSCDCCExaminer &  binChecker 
)
private

Process DDU output and fill MOs.

Parameters
dduDataDDU object to process

LOG4CPLUS_WARN(logger_,eTag << "Skipped because of DDU Trailer check failed.");

New CSC readout without DCCs. CMS CSC DDU ID range 830-869

Only 8bits are significant; format of DDU id is Dxx

DDU word counter

LOG4CPLUS_DEBUG(logger_,dduTag << " Trailer Word (64 bits) Count = " << std::dec << trl_word_count);

if (fCloseL1As) LOG4CPLUS_DEBUG(logger_,eTag << " Close L1As bit is set");

DDU Header bunch crossing number (BXN)

LOG4CPLUS_WARN(logger_,dduTag << " DDU Header BXN Number = " << std::dec << BXN);

L1A number from DDU Header

LOG4CPLUS_DEBUG(logger_,dduTag << " Header L1A Number = " << std::dec << L1ANumber);

Handle 24-bit L1A roll-over maximum value case

== Occupancy and number of DMB (CSC) with Data available (DAV) in header of particular DDU

== Number of active DMB (CSC) in header of particular DDU

LOG4CPLUS_DEBUG(logger_,dduTag << " Header DMB DAV = 0x" << std::hex << dmb_dav_header);

LOG4CPLUS_DEBUG(logger_,dduTag << " Header Number of Active DMB = " << std::dec << dmb_active_header);

Check binary Error status at DDU Trailer

LOG4CPLUS_DEBUG(logger_,dduTag << " Trailer Error Status = 0x" << std::hex << trl_errorstat);

Check DDU Output Path status in DDU Header uint32_t ddu_output_path_status = dduHeader.output_path_status(); if (getEMUHisto(h::EMU_ALL_DDUS_OUTPUT_PATH_STATUS, mo)) { if (ddu_output_path_status) { mo->Fill(dduID, 1); // Any Error for (int i = 0; i < 16; i++) { if ((ddu_output_path_status >> i) & 0x1) { mo->Fill(dduID, i + 2); // Fill Summary Histo } } } else { mo->Fill(dduID, 0); // No Errors } }

uint32_t nCSCs = 0;

/** Unpack all found CSC

First event per DDU

Definition at line 27 of file CSCDQM_EventProcessor_processDDU.cc.

27  {
28  CSCDDUHeader dduHeader = dduData.header();
29  CSCDDUTrailer dduTrailer = dduData.trailer();
30  if (!dduTrailer.check()) {
32  return;
33  }
34 
35  int dduID = dduHeader.source_id();
36 
37  if ((dduID >= FEDNumbering::MINCSCDDUFEDID) &&
38  (dduID <= FEDNumbering::MAXCSCDDUFEDID))
39  {
40  // dduID -= (FEDNumbering::MINCSCDDUFEDID - 1); /// TODO: Can require DDU-RUI remapping for actual system
41  dduID = cscdqm::Utility::getRUIfromDDUId(dduHeader.source_id());
42  if (dduID < 0) {
43  LOG_WARN << "DDU source ID (" << dduHeader.source_id() << ") is out of valid range. Remapping to DDU ID 1.";
44  dduID = 1;
45  }
46  } else {
48  dduID = dduID & 0xFF;
49  }
50 
51  MonitorObject* mo = nullptr;
52 
53  if (getEMUHisto(h::EMU_ALL_DDUS_IN_READOUT, mo)) {
54  mo->Fill(dduID);
55  }
56 
57  std::string dduTag = DDUHistoDef::getPath(dduID);
58 
59  uint32_t dduEvtSize = dduData.sizeInWords() * 2;
60 
61  // if (dduEvtSize > 48)
62  {
64  int trl_word_count = 0;
65  trl_word_count = dduTrailer.wordcount();
66 
67  if (getDDUHisto(h::DDU_BUFFER_SIZE, dduID, mo))
68  mo->Fill(dduEvtSize);
69 
70  if (getDDUHisto(h::DDU_WORD_COUNT, dduID, mo))
71  mo->Fill(trl_word_count);
72 
75  if (trl_word_count > 0) {
76  if (getEMUHisto(h::EMU_ALL_DDUS_EVENT_SIZE, mo)) {
77  mo->Fill(dduID, log10((double)trl_word_count));
78  }
79  }
80 
81  if (getEMUHisto(h::EMU_ALL_DDUS_AVERAGE_EVENT_SIZE, mo)) {
82  mo->Fill(dduID, trl_word_count);
83  }
84  }
85 
86  fCloseL1As = dduTrailer.reserved() & 0x1; // Get status if Close L1As bit
90  BXN = dduHeader.bxnum();
92  if (getEMUHisto(h::EMU_DDU_BXN, mo))
93  mo->Fill(BXN);
94  if (getDDUHisto(h::DDU_BXN, dduID, mo))
95  mo->Fill(BXN);
96 
98  int L1ANumber_previous_event = L1ANumbers[dduID];
99  L1ANumbers[dduID] = (int)(dduHeader.lvl1num());
100  L1ANumber = L1ANumbers[dduID];
102  int L1A_inc = L1ANumber - L1ANumber_previous_event;
103 
105  if (L1A_inc < 0)
106  L1A_inc = 0xFFFFFF + L1A_inc;
107 
108  // if (!fFirstEvent) {
109  if (fNotFirstEvent[dduID]) {
110  if (getDDUHisto(h::DDU_L1A_INCREMENT, dduID, mo))
111  mo->Fill(L1A_inc);
112  if (getEMUHisto(h::EMU_ALL_DDUS_L1A_INCREMENT, mo)) {
113  if (L1A_inc > 100000) {
114  L1A_inc = 19;
115  } else if (L1A_inc > 30000) {
116  L1A_inc = 18;
117  } else if (L1A_inc > 10000) {
118  L1A_inc = 17;
119  } else if (L1A_inc > 3000) {
120  L1A_inc = 16;
121  } else if (L1A_inc > 1000) {
122  L1A_inc = 15;
123  } else if (L1A_inc > 300) {
124  L1A_inc = 14;
125  } else if (L1A_inc > 100) {
126  L1A_inc = 13;
127  } else if (L1A_inc > 30) {
128  L1A_inc = 12;
129  } else if (L1A_inc > 10) {
130  L1A_inc = 11;
131  }
132  mo->Fill(dduID, L1A_inc);
133  }
134  }
135 
137  int dmb_dav_header = 0;
138  int dmb_dav_header_cnt = 0;
139 
140  int ddu_connected_inputs = 0;
141  int ddu_connected_inputs_cnt = 0;
142 
143  int csc_error_state = 0;
144  int csc_warning_state = 0;
145 
147  int dmb_active_header = 0;
148 
149  dmb_dav_header = dduHeader.dmb_dav();
150  dmb_active_header = (int)(dduHeader.ncsc() & 0xF);
151  csc_error_state = dduTrailer.dmb_full() & 0x7FFF; // Only 15 inputs for DDU
152  csc_warning_state = dduTrailer.dmb_warn() & 0x7FFF; // Only 15 inputs for DDU
153  ddu_connected_inputs = dduHeader.live_cscs();
154 
158  double freq = 0;
159  for (int i = 0; i < 15; ++i) {
160  if ((dmb_dav_header >> i) & 0x1) {
161  dmb_dav_header_cnt++;
162  if (getDDUHisto(h::DDU_DMB_DAV_HEADER_OCCUPANCY_RATE, dduID, mo)) {
163  mo->Fill(i + 1);
164  freq = (100.0 * mo->GetBinContent(i + 1)) / config->getNEvents();
165  if (getDDUHisto(h::DDU_DMB_DAV_HEADER_OCCUPANCY, dduID, mo))
166  mo->SetBinContent(i + 1, freq);
167  }
168  if (getEMUHisto(h::EMU_ALL_DDUS_INPUTS_WITH_DATA, mo)) {
169  mo->Fill(dduID, i);
170  }
171  }
172 
173  if ((ddu_connected_inputs >> i) & 0x1) {
174  ddu_connected_inputs_cnt++;
175  if (getDDUHisto(h::DDU_DMB_CONNECTED_INPUTS_RATE, dduID, mo)) {
176  mo->Fill(i + 1);
177  freq = (100.0 * mo->GetBinContent(i + 1)) / config->getNEvents();
178  if (getDDUHisto(h::DDU_DMB_CONNECTED_INPUTS, dduID, mo))
179  mo->SetBinContent(i + 1, freq);
180  }
181  if (getEMUHisto(h::EMU_ALL_DDUS_LIVE_INPUTS, mo)) {
182  mo->Fill(dduID, i);
183  }
184  }
185 
186  if ((csc_error_state >> i) & 0x1) {
187  if (getDDUHisto(h::DDU_CSC_ERRORS_RATE, dduID, mo)) {
188  mo->Fill(i + 1);
189  freq = (100.0 * mo->GetBinContent(i + 1)) / config->getNEvents();
190  if (getDDUHisto(h::DDU_CSC_ERRORS, dduID, mo))
191  mo->SetBinContent(i + 1, freq);
192  }
193  if (getEMUHisto(h::EMU_ALL_DDUS_INPUTS_ERRORS, mo)) {
194  mo->Fill(dduID, i + 2);
195  }
196  }
197 
198  if ((csc_warning_state >> i) & 0x1) {
199  if (getDDUHisto(h::DDU_CSC_WARNINGS_RATE, dduID, mo)) {
200  mo->Fill(i + 1);
201  freq = (100.0 * mo->GetBinContent(i + 1)) / config->getNEvents();
202  if (getDDUHisto(h::DDU_CSC_WARNINGS, dduID, mo))
203  mo->SetBinContent(i + 1, freq);
204  }
205  if (getEMUHisto(h::EMU_ALL_DDUS_INPUTS_WARNINGS, mo)) {
206  mo->Fill(dduID, i + 2);
207  }
208  }
209  }
210 
211  if (getEMUHisto(h::EMU_ALL_DDUS_AVERAGE_LIVE_INPUTS, mo)) {
212  mo->Fill(dduID, ddu_connected_inputs_cnt);
213  }
214 
215  // if (dduEvtSize > 48)
216  {
217  if (getEMUHisto(h::EMU_ALL_DDUS_AVERAGE_INPUTS_WITH_DATA, mo)) {
218  mo->Fill(dduID, dmb_dav_header_cnt);
219  }
220  }
221 
222  if (getEMUHisto(h::EMU_ALL_DDUS_INPUTS_ERRORS, mo)) {
223  if (csc_error_state > 0) {
224  mo->Fill(dduID, 1); // Any Input
225  } else {
226  mo->Fill(dduID, 0); // No errors
227  }
228  }
229 
230  if (getEMUHisto(h::EMU_ALL_DDUS_INPUTS_WARNINGS, mo)) {
231  if (csc_warning_state > 0) {
232  mo->Fill(dduID, 1); // Any Input
233  } else {
234  mo->Fill(dduID, 0); // No errors
235  }
236  }
237 
238  if (getDDUHisto(h::DDU_DMB_DAV_HEADER_OCCUPANCY, dduID, mo))
239  mo->SetEntries(config->getNEvents());
240  if (getDDUHisto(h::DDU_DMB_CONNECTED_INPUTS, dduID, mo))
241  mo->SetEntries(config->getNEvents());
242  if (getDDUHisto(h::DDU_CSC_ERRORS, dduID, mo))
243  mo->SetEntries(config->getNEvents());
244  if (getDDUHisto(h::DDU_CSC_WARNINGS, dduID, mo))
245  mo->SetEntries(config->getNEvents());
246  if (getDDUHisto(h::DDU_DMB_ACTIVE_HEADER_COUNT, dduID, mo))
247  mo->Fill(dmb_active_header);
248  if (getDDUHisto(h::DDU_DMB_DAV_HEADER_COUNT_VS_DMB_ACTIVE_HEADER_COUNT, dduID, mo))
249  mo->Fill(dmb_active_header, dmb_dav_header_cnt);
250 
252  uint32_t trl_errorstat = dduTrailer.errorstat();
253  if (dmb_dav_header_cnt == 0)
254  trl_errorstat &= ~0x20000000; // Ignore No Good DMB CRC bit of no DMB is present
256  for (int i = 0; i < 32; i++) {
257  if ((trl_errorstat >> i) & 0x1) {
258  if (getDDUHisto(h::DDU_TRAILER_ERRORSTAT_RATE, dduID, mo)) {
259  mo->Fill(i);
260  double freq = (100.0 * mo->GetBinContent(i + 1)) / config->getNEvents();
261  if (getDDUHisto(h::DDU_TRAILER_ERRORSTAT_FREQUENCY, dduID, mo))
262  mo->SetBinContent(i + 1, freq);
263  }
264  if (getDDUHisto(h::DDU_TRAILER_ERRORSTAT_TABLE, dduID, mo))
265  mo->Fill(0., i);
266  }
267  }
268  if (getEMUHisto(h::EMU_ALL_DDUS_TRAILER_ERRORS, mo)) {
269  if (trl_errorstat) {
270  mo->Fill(dduID, 1); // Any Error
271  for (int i = 0; i < 32; i++) {
272  if ((trl_errorstat >> i) & 0x1) {
273  mo->Fill(dduID, i + 2);
274  }
275  }
276  } else {
277  mo->Fill(dduID, 0); // No Errors
278  }
279  }
280 
281  if (getDDUHisto(h::DDU_TRAILER_ERRORSTAT_TABLE, dduID, mo))
282  mo->SetEntries(config->getNEvents());
283  if (getDDUHisto(h::DDU_TRAILER_ERRORSTAT_FREQUENCY, dduID, mo))
284  mo->SetEntries(config->getNEvents());
285 
287  uint32_t ddu_output_path_status = dduHeader.output_path_status();
288  if (getEMUHisto(h::EMU_ALL_DDUS_OUTPUT_PATH_STATUS, mo)) {
289  if (ddu_output_path_status) {
290  mo->Fill(dduID, 1); // Any Error
291  for (int i = 0; i < 16; i++) {
292  if ((ddu_output_path_status >> i) & 0x1) {
293  mo->Fill(dduID, i + 2); // Fill Summary Histo
294  }
295  }
296  } else {
297  mo->Fill(dduID, 0); // No Errors
298  }
299  }
300 
301  uint32_t nCSCs = 0;
302 
304  if (config->getPROCESS_CSC()) {
305  std::vector<CSCEventData> chamberDatas;
306  chamberDatas.clear();
307  chamberDatas = dduData.cscData();
308 
309  nCSCs = chamberDatas.size();
310 
311  for (uint32_t i = 0; i < nCSCs; i++) {
312  processCSC(chamberDatas[i], dduID, binChecker);
313  }
314  }
315 
316  if (getDDUHisto(h::DDU_DMB_UNPACKED_VS_DAV, dduID, mo))
317  mo->Fill(dmb_active_header, nCSCs);
318 
319  // fFirstEvent = false;
320 
322  fNotFirstEvent[dduID] = true;
323  }

References BXN, CSCDDUHeader::bxnum(), CSCDDUTrailer::check(), CSCDDUEventData::cscData(), CSCDDUHeader::dmb_dav(), CSCDDUTrailer::dmb_full(), CSCDDUTrailer::dmb_warn(), CSCDDUTrailer::errorstat(), fCloseL1As, cscdqm::MonitorObject::Fill(), fNotFirstEvent, cscdqm::MonitorObject::GetBinContent(), getDDUHisto(), getEMUHisto(), cscdqm::DDUHistoDef::getPath(), cscdqm::Utility::getRUIfromDDUId(), CSCDDUEventData::header(), mps_fire::i, createfilelist::int, L1ANumber, L1ANumbers, CSCDDUHeader::live_cscs(), LOG_WARN, CSCDDUHeader::lvl1num(), FEDNumbering::MAXCSCDDUFEDID, FEDNumbering::MINCSCDDUFEDID, CSCDDUHeader::ncsc(), CSCDDUHeader::output_path_status(), processCSC(), CSCDDUTrailer::reserved(), cscdqm::MonitorObject::SetBinContent(), cscdqm::MonitorObject::SetEntries(), CSCDDUEventData::sizeInWords(), CSCDDUHeader::source_id(), AlCaHLTBitMon_QueryRunRegistry::string, CSCDDUEventData::trailer(), CSCDDUTrailer::wordcount(), and testProducerWithPsetDescEmpty_cfi::x1.

◆ processExaminer() [1/2]

bool cscdqm::EventProcessor::processExaminer ( const CSCDCCExaminer &  binChecker)
private

◆ processExaminer() [2/2]

bool cscdqm::EventProcessor::processExaminer ( const CSCDCCExaminer &  binChecker,
const CSCDCCFormatStatusDigi &  digi 
)
private

Fill monitor elements with CSCDCCFormatStatusDigi information.

Returns
true if this buffer (event) was accepted by Examiner else otherwise

New CSC readout without DCCs. CMS CSC DDU ID range 830-869

Check and fill CSC Payload information

Update counters

Get FEBs Data Available Info

Increment total number of CFEBs, ALCTs, TMBs

Fill Histogram for FEB DAV Efficiency

Fill Histogram for Different Combinations of FEB DAV Efficiency

Check and fill CSC Data Flow Problems

Check and fill CSC Format Errors

Definition at line 27 of file CSCDQM_EventProcessor_processExaminer.cc.

27  {
28  bool eventAccepted = true;
29  MonitorObject* mo = nullptr;
30 
31  uint32_t binErrorStatus = digi.getDDUSummaryErrors();
32 
33  if (getEMUHisto(h::EMU_ALL_DDUS_FORMAT_ERRORS, mo)) {
34  const std::set<DDUIdType> DDUs = digi.getListOfDDUs();
35  for (std::set<DDUIdType>::const_iterator ddu_itr = DDUs.begin(); ddu_itr != DDUs.end(); ++ddu_itr) {
36  ExaminerStatusType errs = digi.getDDUErrors(*ddu_itr);
37  int dduID = (*ddu_itr) & 0xFF;
38  if (((*ddu_itr) >= FEDNumbering::MINCSCDDUFEDID) &&
39  ((*ddu_itr) <=
40  FEDNumbering::MAXCSCDDUFEDID))
41  {
42  // dduID = (*ddu_itr) - FEDNumbering::MINCSCDDUFEDID + 1; /// TODO: Can require DDU-RUI remapping for actual system
43  dduID = cscdqm::Utility::getRUIfromDDUId((*ddu_itr));
44  if (dduID < 0) {
45  LOG_WARN << "DDU source ID (" << (*ddu_itr) << ") is out of valid range. Remapping to DDU ID 1.";
46  dduID = 1;
47  }
48  }
49  if (errs != 0) {
50  for (int i = 0; i < 29; i++) {
51  if ((errs >> i) & 0x1) {
52  mo->Fill(dduID, i + 1);
53  }
54  }
55  } else {
56  mo->Fill(dduID, 0);
57  }
58  }
59  }
60 
61  // =VB= We want to use DCC level check mask as in CSCDCCUnpacker and not DDU mask
62  // Otherwise whole DCC event could be skipped because of a single chamber error
63  unsigned long dccBinCheckMask = 0x06080016;
64  // if ((binErrorStatus & config->getDDU_BINCHECK_MASK()) > 0) {
65  if ((binErrorStatus & dccBinCheckMask) > 0) {
66  eventAccepted = false;
67  }
68 
69  if (binErrorStatus != 0) {
70  config->incNEventsBad();
71  }
72 
75  {
76  uint32_t i = 0;
77  CSCIdType chamberID = 0;
78  while (digi.nextCSCWithPayload(i, chamberID)) {
79  int crateID = (chamberID >> 4) & 0xFF;
80  int dmbSlot = chamberID & 0xF;
81 
82  if (crateID == 255) {
83  continue;
84  }
85  if ((crateID > 60) || (dmbSlot > 10) || (crateID <= 0) || (dmbSlot <= 0)) {
86  continue;
87  }
88 
89  // Check if in standby!
90  {
91  CSCDetId cid;
92  if (!config->fnGetCSCDetId(crateID, dmbSlot, cid)) {
93  continue;
94  }
95  }
96 
98  config->incChamberCounter(DMB_EVENTS, crateID, dmbSlot);
99  long DMBEvents = config->getChamberCounterValue(DMB_EVENTS, crateID, dmbSlot);
100  config->copyChamberCounterValue(DMB_EVENTS, DMB_TRIGGERS, crateID, dmbSlot);
101  cntDMBs++;
102 
103  if (getEMUHisto(h::EMU_DMB_REPORTING, mo)) {
104  mo->Fill(crateID, dmbSlot);
105  }
106 
107  unsigned int cscType = 0;
108  unsigned int cscPosition = 0;
109  if (!getCSCFromMap(crateID, dmbSlot, cscType, cscPosition))
110  continue;
111 
112  if (cscPosition && getEMUHisto(h::EMU_CSC_REPORTING, mo)) {
113  mo->Fill(cscPosition, cscType);
114  }
115 
117  long payload = digi.getCSCPayload(chamberID);
118  int cfeb_dav = (payload >> 7) & 0x7F;
119  int cfeb_active = payload & 0x1F;
120  cfeb_active |= ((payload >> 14) & 0x03) << 5;
121  int alct_dav = (payload >> 5) & 0x1;
122  int tmb_dav = (payload >> 6) & 0x1;
123  int cfeb_dav_num = 0;
124 
125  if (alct_dav == 0) {
126  if (cscPosition && getEMUHisto(h::EMU_CSC_WO_ALCT, mo)) {
127  mo->Fill(cscPosition, cscType);
128  }
129  if (getEMUHisto(h::EMU_DMB_WO_ALCT, mo)) {
130  mo->Fill(crateID, dmbSlot);
131  }
132  }
133 
134  if (tmb_dav == 0) {
135  if (cscPosition && getEMUHisto(h::EMU_CSC_WO_CLCT, mo)) {
136  mo->Fill(cscPosition, cscType);
137  }
138  if (getEMUHisto(h::EMU_DMB_WO_CLCT, mo)) {
139  mo->Fill(crateID, dmbSlot);
140  }
141  }
142 
143  if (cfeb_dav == 0) {
144  if (cscPosition && getEMUHisto(h::EMU_CSC_WO_CFEB, mo)) {
145  mo->Fill(cscPosition, cscType);
146  }
147  if (getEMUHisto(h::EMU_DMB_WO_CFEB, mo)) {
148  mo->Fill(crateID, dmbSlot);
149  }
150  }
151 
153  for (int i = 0; i < 7; i++) {
154  if ((cfeb_dav >> i) & 0x1)
155  cntCFEBs++;
156  }
157 
158  if (alct_dav > 0) {
159  cntALCTs++;
160  }
161 
162  if (tmb_dav > 0) {
163  cntTMBs++;
164  }
165 
166  MonitorObject *mof = nullptr, *mo1 = nullptr, *mo2 = nullptr;
167  if (getCSCHisto(h::CSC_ACTUAL_DMB_CFEB_DAV_RATE, crateID, dmbSlot, mo) &&
168  getCSCHisto(h::CSC_ACTUAL_DMB_CFEB_DAV_FREQUENCY, crateID, dmbSlot, mof)) {
169  if (getCSCHisto(h::CSC_DMB_CFEB_DAV_UNPACKING_INEFFICIENCY, crateID, dmbSlot, mo1) &&
170  getCSCHisto(h::CSC_DMB_CFEB_DAV, crateID, dmbSlot, mo2)) {
171  for (int i = 1; i <= 7; i++) {
172  double actual_dav_num = mo->GetBinContent(i);
173  double unpacked_dav_num = mo2->GetBinContent(i);
174  if (actual_dav_num) {
175  mo1->SetBinContent(i, 1, 100. * (1 - unpacked_dav_num / actual_dav_num));
176  }
177  mo1->SetEntries((int)DMBEvents);
178  }
179  }
180  for (int i = 0; i < 7; i++) {
181  int cfeb_present = (cfeb_dav >> i) & 0x1;
182  cfeb_dav_num += cfeb_present;
183  if (cfeb_present) {
184  mo->Fill(i);
185  }
186  float cfeb_entries = mo->GetBinContent(i + 1);
187  mof->SetBinContent(i + 1, ((float)cfeb_entries / (float)(DMBEvents)*100.0));
188  }
189  mof->SetEntries((int)DMBEvents);
190  }
191 
192  if (getCSCHisto(h::CSC_ACTUAL_DMB_CFEB_DAV_MULTIPLICITY_RATE, crateID, dmbSlot, mo) &&
193  getCSCHisto(h::CSC_ACTUAL_DMB_CFEB_DAV_MULTIPLICITY_FREQUENCY, crateID, dmbSlot, mof)) {
194  for (unsigned short i = 1; i < 7; i++) {
195  float cfeb_entries = mo->GetBinContent(i);
196  mof->SetBinContent(i, ((float)cfeb_entries / (float)(DMBEvents)*100.0));
197  }
198  mof->SetEntries((int)DMBEvents);
199 
200  if (getCSCHisto(h::CSC_DMB_CFEB_DAV_MULTIPLICITY_UNPACKING_INEFFICIENCY, crateID, dmbSlot, mo1) &&
201  getCSCHisto(h::CSC_DMB_CFEB_DAV_MULTIPLICITY, crateID, dmbSlot, mo2)) {
202  for (unsigned short i = 1; i < 9; i++) {
203  float actual_dav_num = mo->GetBinContent(i);
204  float unpacked_dav_num = mo2->GetBinContent(i);
205  if (actual_dav_num) {
206  mo1->SetBinContent(i, 1, 100. * (1 - unpacked_dav_num / actual_dav_num));
207  }
208  mo1->SetEntries((int)DMBEvents);
209  }
210  }
211  mo->Fill(cfeb_dav_num);
212  }
213 
214  if (getCSCHisto(h::CSC_DMB_CFEB_ACTIVE_VS_DAV, crateID, dmbSlot, mo))
215  mo->Fill(cfeb_dav, cfeb_active);
216 
218  if (getCSCHisto(h::CSC_ACTUAL_DMB_FEB_DAV_RATE, crateID, dmbSlot, mo)) {
219  if (getCSCHisto(h::CSC_ACTUAL_DMB_FEB_DAV_FREQUENCY, crateID, dmbSlot, mo1)) {
220  for (int i = 1; i < 4; i++) {
221  float dav_num = mo->GetBinContent(i);
222  mo1->SetBinContent(i, ((float)dav_num / (float)(DMBEvents)*100.0));
223  }
224  mo1->SetEntries((int)DMBEvents);
225 
226  if (getCSCHisto(h::CSC_DMB_FEB_DAV_UNPACKING_INEFFICIENCY, crateID, dmbSlot, mof) &&
227  getCSCHisto(h::CSC_DMB_FEB_DAV_RATE, crateID, dmbSlot, mo2)) {
228  for (int i = 1; i < 4; i++) {
229  float actual_dav_num = mo->GetBinContent(i);
230  float unpacked_dav_num = mo2->GetBinContent(i);
231  if (actual_dav_num) {
232  mof->SetBinContent(i, 1, 100. * (1 - unpacked_dav_num / actual_dav_num));
233  }
234  mof->SetEntries((int)DMBEvents);
235  mof->SetMaximum(100.0);
236  }
237  }
238  }
239 
240  if (alct_dav > 0) {
241  mo->Fill(0.0);
242  }
243  if (tmb_dav > 0) {
244  mo->Fill(1.0);
245  }
246  if (cfeb_dav > 0) {
247  mo->Fill(2.0);
248  }
249  }
250 
251  float feb_combination_dav = -1.0;
253  if (getCSCHisto(h::CSC_ACTUAL_DMB_FEB_COMBINATIONS_DAV_RATE, crateID, dmbSlot, mo)) {
254  if (alct_dav == 0 && tmb_dav == 0 && cfeb_dav == 0)
255  feb_combination_dav = 0.0; // Nothing
256  if (alct_dav > 0 && tmb_dav == 0 && cfeb_dav == 0)
257  feb_combination_dav = 1.0; // ALCT Only
258  if (alct_dav == 0 && tmb_dav > 0 && cfeb_dav == 0)
259  feb_combination_dav = 2.0; // TMB Only
260  if (alct_dav == 0 && tmb_dav == 0 && cfeb_dav > 0)
261  feb_combination_dav = 3.0; // CFEB Only
262  if (alct_dav == 0 && tmb_dav > 0 && cfeb_dav > 0)
263  feb_combination_dav = 4.0; // TMB+CFEB
264  if (alct_dav > 0 && tmb_dav > 0 && cfeb_dav == 0)
265  feb_combination_dav = 5.0; // ALCT+TMB
266  if (alct_dav > 0 && tmb_dav == 0 && cfeb_dav > 0)
267  feb_combination_dav = 6.0; // ALCT+CFEB
268  if (alct_dav > 0 && tmb_dav > 0 && cfeb_dav > 0)
269  feb_combination_dav = 7.0; // ALCT+TMB+CFEB
270  // mo->Fill(feb_combination_dav);
271 
272  if (getCSCHisto(h::CSC_ACTUAL_DMB_FEB_COMBINATIONS_DAV_FREQUENCY, crateID, dmbSlot, mo1)) {
273  for (int i = 1; i < 9; i++) {
274  float feb_combination_dav_number = mo->GetBinContent(i);
275  mo1->SetBinContent(i, ((float)feb_combination_dav_number / (float)(DMBEvents)*100.0));
276  }
277  mo1->SetEntries(DMBEvents);
278 
279  if (getCSCHisto(h::CSC_DMB_FEB_COMBINATIONS_DAV_UNPACKING_INEFFICIENCY, crateID, dmbSlot, mof) &&
280  getCSCHisto(h::CSC_DMB_FEB_COMBINATIONS_DAV_RATE, crateID, dmbSlot, mo2)) {
281  for (int i = 1; i < 9; i++) {
282  float actual_dav_num = mo->GetBinContent(i);
283  float unpacked_dav_num = mo2->GetBinContent(i);
284  if (actual_dav_num) {
285  mof->SetBinContent(i, 1, 100. * (1 - unpacked_dav_num / actual_dav_num));
286  }
287  mof->SetEntries((int)DMBEvents);
288  mof->SetMaximum(100.0);
289  }
290  }
291  }
292  mo->Fill(feb_combination_dav);
293  }
294  }
295  }
296 
299  {
300  uint32_t i = 0;
301  CSCIdType chamberID = 0;
302  while (digi.nextCSCWithStatus(i, chamberID)) {
303  unsigned int crateID = (chamberID >> 4) & 0xFF;
304  unsigned int dmbSlot = chamberID & 0xF;
305  ExaminerStatusType chStatus = digi.getCSCStatus(chamberID);
306 
307  if (crateID == 255) {
308  continue;
309  }
310  if ((crateID > 60) || (dmbSlot > 10) || (crateID <= 0) || (dmbSlot <= 0)) {
311  continue;
312  }
313 
314  // Check if in standby!
315  {
316  CSCDetId cid;
317  if (!config->fnGetCSCDetId(crateID, dmbSlot, cid)) {
318  continue;
319  }
320  }
321 
322  unsigned int cscType = 0;
323  unsigned int cscPosition = 0;
324  if (!getCSCFromMap(crateID, dmbSlot, cscType, cscPosition))
325  continue;
326 
327  if (getCSCHisto(h::CSC_BINCHECK_DATAFLOW_PROBLEMS_TABLE, crateID, dmbSlot, mo)) {
328  for (int bit = 0; bit < binChecker.nSTATUSES; bit++) {
329  if (chStatus & (1 << bit)) {
330  mo->Fill(0., bit);
331  }
332  }
333  mo->SetEntries(config->getChamberCounterValue(DMB_EVENTS, crateID, dmbSlot));
334  }
335 
336  int anyInputFull = chStatus & 0x3F;
337  if (anyInputFull) {
338  if (cscPosition && getEMUHisto(h::EMU_CSC_DMB_INPUT_FIFO_FULL, mo)) {
339  mo->Fill(cscPosition, cscType);
340  }
341  if (getEMUHisto(h::EMU_DMB_INPUT_FIFO_FULL, mo)) {
342  mo->Fill(crateID, dmbSlot);
343  }
344  }
345 
346  int anyInputTO = (chStatus >> 7) & 0x3FFF;
347  if (anyInputTO) {
348  if (cscPosition && getEMUHisto(h::EMU_CSC_DMB_INPUT_TIMEOUT, mo)) {
349  mo->Fill(cscPosition, cscType);
350  }
351  if (getEMUHisto(h::EMU_DMB_INPUT_TIMEOUT, mo)) {
352  mo->Fill(crateID, dmbSlot);
353  }
354  }
355 
356  if (digi.getCSCStatus(chamberID) & (1 << 22)) {
357  if (getEMUHisto(h::EMU_DMB_FORMAT_WARNINGS, mo)) {
358  mo->Fill(crateID, dmbSlot);
359  }
360 
361  if (cscPosition && getEMUHisto(h::EMU_CSC_FORMAT_WARNINGS, mo)) {
362  mo->Fill(cscPosition, cscType);
363  }
364  }
365  }
366  }
367 
370  {
371  uint32_t i = 0;
372  CSCIdType chamberID = 0;
373  while (digi.nextCSCWithError(i, chamberID)) {
374  const unsigned int crateID = (chamberID >> 4) & 0xFF;
375  const unsigned int dmbSlot = chamberID & 0xF;
376  const ExaminerStatusType chErr = digi.getCSCErrors(chamberID);
377 
378  if ((crateID == 255) || (chErr & 0x80)) {
379  continue; // = Skip chamber detection if DMB header is missing (Error code 6)
380  }
381  if ((crateID > 60) || (dmbSlot > 10) || (crateID <= 0) || (dmbSlot <= 0)) {
382  continue;
383  }
384 
385  // Check if in standby!
386  {
387  CSCDetId cid;
388  if (!config->fnGetCSCDetId(crateID, dmbSlot, cid)) {
389  continue;
390  }
391  }
392 
393  if ((chErr & config->getBINCHECK_MASK()) != 0) {
394  config->incChamberCounter(BAD_EVENTS, crateID, dmbSlot);
395  }
396 
397  bool isCSCError = false;
398  bool fillBC = getCSCHisto(h::CSC_BINCHECK_ERRORSTAT_TABLE, crateID, dmbSlot, mo);
399 
400  for (int bit = 5; bit < 24; bit++) {
401  if (chErr & (1 << bit)) {
402  isCSCError = true;
403  if (fillBC) {
404  mo->Fill(0., bit - 5);
405  } else {
406  break;
407  }
408  }
409 
410  if (fillBC) {
411  mo->SetEntries(config->getChamberCounterValue(DMB_EVENTS, crateID, dmbSlot));
412  }
413  }
414 
415  if (isCSCError) {
416  if (getEMUHisto(h::EMU_DMB_FORMAT_ERRORS, mo)) {
417  mo->Fill(crateID, dmbSlot);
418  }
419 
420  if (eventAccepted && getEMUHisto(h::EMU_DMB_UNPACKED_WITH_ERRORS, mo)) {
421  mo->Fill(crateID, dmbSlot);
422  }
423 
424  unsigned int cscType = 0;
425  unsigned int cscPosition = 0;
426  if (!getCSCFromMap(crateID, dmbSlot, cscType, cscPosition))
427  continue;
428 
429  if (cscPosition && getEMUHisto(h::EMU_CSC_FORMAT_ERRORS, mo)) {
430  mo->Fill(cscPosition, cscType);
431  }
432 
433  if (eventAccepted && cscPosition && getEMUHisto(h::EMU_CSC_UNPACKED_WITH_ERRORS, mo)) {
434  mo->Fill(cscPosition, cscType);
435  }
436  }
437  }
438  }
439 
440  return eventAccepted;
441  }

References cscdqm::BAD_EVENTS, cscd2r::chamberID(), cntALCTs, cntCFEBs, cntDMBs, cntTMBs, cscdqm::DMB_EVENTS, cscdqm::DMB_TRIGGERS, cscdqm::MonitorObject::Fill(), cscdqm::MonitorObject::GetBinContent(), CSCDCCFormatStatusDigi::getCSCErrors(), getCSCFromMap(), getCSCHisto(), CSCDCCFormatStatusDigi::getCSCPayload(), CSCDCCFormatStatusDigi::getCSCStatus(), CSCDCCFormatStatusDigi::getDDUErrors(), CSCDCCFormatStatusDigi::getDDUSummaryErrors(), getEMUHisto(), CSCDCCFormatStatusDigi::getListOfDDUs(), cscdqm::Utility::getRUIfromDDUId(), mps_fire::i, LOG_WARN, FEDNumbering::MAXCSCDDUFEDID, FEDNumbering::MINCSCDDUFEDID, CSCDCCFormatStatusDigi::nextCSCWithError(), CSCDCCFormatStatusDigi::nextCSCWithPayload(), CSCDCCFormatStatusDigi::nextCSCWithStatus(), CSCDCCExaminer::nSTATUSES, jets_cff::payload, cscdqm::MonitorObject::SetBinContent(), cscdqm::MonitorObject::SetEntries(), cscdqm::MonitorObject::SetMaximum(), and testProducerWithPsetDescEmpty_cfi::x1.

◆ resetEmuEventDisplays()

void cscdqm::EventProcessor::resetEmuEventDisplays ( )
private

Reset Emu level EventDisplay histograms once per event.

Definition at line 56 of file CSCDQM_EventProcessor_processCSC.cc.

56  {
57  if (!EmuEventDisplayWasReset) {
58  // Reseting EMU level Event displays
59  MonitorObject* mo = nullptr;
60  if (getEMUHisto(h::EMU_EVENT_DISPLAY_ANODE, mo)) {
61  mo->getTH1Lock()->Reset("");
62  }
63 
64  if (getEMUHisto(h::EMU_EVENT_DISPLAY_CATHODE, mo)) {
65  mo->getTH1Lock()->Reset("");
66  }
67 
68  if (getEMUHisto(h::EMU_EVENT_DISPLAY_XY, mo)) {
69  mo->getTH1Lock()->Reset("");
70  }
71 
72  EmuEventDisplayWasReset = true;
73  }
74  }

References EmuEventDisplayWasReset, getEMUHisto(), and cscdqm::MonitorObject::getTH1Lock().

Referenced by setEmuEventDisplayBit().

◆ setEmuEventDisplayBit()

void cscdqm::EventProcessor::setEmuEventDisplayBit ( MonitorObject *&  mo,
const unsigned int  x,
const unsigned int  y,
const unsigned int  bit 
)
private

Set a single bit in the 3D Histogram (aka EMU level event display). Checks if mo and x != null.

Parameters
eventNumbernumber of event
moHistogram
xX bin number
yY bin number
bitbit number to set

Definition at line 41 of file CSCDQM_EventProcessor_processCSC.cc.

44  {
45  if (mo && x) {
46  resetEmuEventDisplays();
47  int bitset = (int)mo->GetBinContent(x, y);
48  bitset |= 1 << bit;
49  mo->SetBinContent(x, y, bitset);
50  }
51  }

References cscdqm::MonitorObject::GetBinContent(), createfilelist::int, resetEmuEventDisplays(), and cscdqm::MonitorObject::SetBinContent().

Referenced by processCSC().

◆ standbyEfficiencyHistos()

void cscdqm::EventProcessor::standbyEfficiencyHistos ( HWStandbyType &  standby)

apply standby flags/parameters

Parameters
standbystandby flags

Definition at line 349 of file CSCDQM_EventProcessor_updateEffHistos.cc.

349  {
350  Address adr;
351  bzero(&adr, sizeof(Address));
352  adr.mask.side = true;
353  adr.mask.station = adr.mask.ring = adr.mask.chamber = adr.mask.layer = adr.mask.cfeb = adr.mask.hv = false;
354 
355  adr.side = 1;
356  summary.SetValue(adr, STANDBY, (standby.MeP ? 1 : 0));
357  if (!standby.MeP) {
358  summary.SetValue(adr, WAS_ON);
359  }
360 
361  adr.side = 2;
362  summary.SetValue(adr, STANDBY, (standby.MeM ? 1 : 0));
363  if (!standby.MeM) {
364  summary.SetValue(adr, WAS_ON);
365  }
366 
367  MonitorObject* me = nullptr;
368  if (getEMUHisto(h::EMU_CSC_STANDBY, me)) {
369  LockType lock(me->mutex);
370  TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
371 
372  // All standby
373  summary.WriteChamberState(tmp, 0x1000, 5);
374 
375  // Temporary in standby (was ON)
376  summary.WriteChamberState(tmp, 0x3000, 1, false);
377  }
378  }

References cscdqm::AddressMask::cfeb, cscdqm::AddressMask::chamber, getEMUHisto(), cscdqm::AddressMask::hv, cscdqm::AddressMask::layer, CommonMethods::lock(), cscdqm::Address::mask, hlt_dqm_clientPB-live_cfg::me, cscdqm::HWStandbyType::MeM, cscdqm::HWStandbyType::MeP, cscdqm::AddressMask::ring, cscdqm::Summary::SetValue(), cscdqm::AddressMask::side, cscdqm::Address::side, cscdqm::STANDBY, cscdqm::AddressMask::station, summary, createJobs::tmp, cscdqm::WAS_ON, and cscdqm::Summary::WriteChamberState().

Referenced by cscdqm::EventProcessorMutex::processStandby().

◆ updateEfficiencyHistos()

void cscdqm::EventProcessor::updateEfficiencyHistos ( )

Update Efficiency MOs.

Get CSC Reporting reference histogram

If reference for CSC_Reporting is defined - use it Else - do it flat way

Write summary information

Looping via addresses (scope: side->station->ring) and filling in HW efficiencies

Definition at line 26 of file CSCDQM_EventProcessor_updateEffHistos.cc.

26  {
27  MonitorObject *me = nullptr, *me1 = nullptr;
28 
29  if (config->getNEvents() > 0) {
30  if (getEMUHisto(h::EMU_CSC_REPORTING, me)) {
31  const TH2* rep = dynamic_cast<const TH2*>(me->getTH1());
32 
34  const TObject* tobj = me->getRefRootObject();
35 
39  if (tobj) {
40  const TH2* ref = dynamic_cast<const TH2*>(tobj);
41  summary.ReadReportingChambersRef(rep,
42  ref,
43  config->getEFF_COLD_THRESHOLD(),
44  config->getEFF_COLD_SIGFAIL(),
45  config->getEFF_HOT_THRESHOLD(),
46  config->getEFF_HOT_SIGFAIL());
47  } else {
48  summary.ReadReportingChambers(rep, 1.0);
49  }
50 
51  if (getEMUHisto(h::EMU_CSC_FORMAT_ERRORS, me1)) {
52  const TH2* err = dynamic_cast<const TH2*>(me1->getTH1());
53  summary.ReadErrorChambers(rep, err, FORMAT_ERR, config->getEFF_ERR_THRESHOLD(), config->getEFF_ERR_SIGFAIL());
54  }
55 
56  if (getEMUHisto(h::EMU_CSC_L1A_OUT_OF_SYNC, me1)) {
57  const TH2* err = dynamic_cast<const TH2*>(me1->getTH1());
58  summary.ReadErrorChambers(rep, err, L1SYNC_ERR, config->getEFF_ERR_THRESHOLD(), config->getEFF_ERR_SIGFAIL());
59  }
60 
61  if (getEMUHisto(h::EMU_CSC_DMB_INPUT_FIFO_FULL, me1)) {
62  const TH2* err = dynamic_cast<const TH2*>(me1->getTH1());
63  summary.ReadErrorChambers(
64  rep, err, FIFOFULL_ERR, config->getEFF_ERR_THRESHOLD(), config->getEFF_ERR_SIGFAIL());
65  }
66 
67  if (getEMUHisto(h::EMU_CSC_DMB_INPUT_TIMEOUT, me1)) {
68  const TH2* err = dynamic_cast<const TH2*>(me1->getTH1());
69  summary.ReadErrorChambers(
70  rep, err, INPUTTO_ERR, config->getEFF_ERR_THRESHOLD(), config->getEFF_ERR_SIGFAIL());
71  }
72 
73  if (getEMUHisto(h::EMU_CSC_WO_ALCT, me1)) {
74  const TH2* err = dynamic_cast<const TH2*>(me1->getTH1());
75  summary.ReadErrorChambers(
76  rep, err, NODATA_ALCT, config->getEFF_NODATA_THRESHOLD(), config->getEFF_NODATA_SIGFAIL());
77  }
78 
79  if (getEMUHisto(h::EMU_CSC_WO_CLCT, me1)) {
80  const TH2* err = dynamic_cast<const TH2*>(me1->getTH1());
81  summary.ReadErrorChambers(
82  rep, err, NODATA_CLCT, config->getEFF_NODATA_THRESHOLD(), config->getEFF_NODATA_SIGFAIL());
83  }
84 
85  if (getEMUHisto(h::EMU_CSC_WO_CFEB, me1)) {
86  const TH2* err = dynamic_cast<const TH2*>(me1->getTH1());
87  summary.ReadErrorChambers(
88  rep, err, NODATA_CFEB, config->getEFF_NODATA_THRESHOLD(), config->getEFF_NODATA_SIGFAIL());
89  }
90 
91  if (getEMUHisto(h::EMU_CSC_FORMAT_WARNINGS, me1)) {
92  const TH2* err = dynamic_cast<const TH2*>(me1->getTH1());
93  summary.ReadErrorChambers(
94  rep, err, CFEB_BWORDS, config->getEFF_NODATA_THRESHOLD(), config->getEFF_NODATA_SIGFAIL());
95  }
96  }
97 
98  writeShifterHistograms();
99 
104  if (getEMUHisto(h::EMU_PHYSICS_ME1, me)) {
105  LockType lock(me->mutex);
106  TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
107  summary.Write(tmp, 1);
108  }
109 
110  if (getEMUHisto(h::EMU_PHYSICS_ME2, me)) {
111  LockType lock(me->mutex);
112  TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
113  summary.Write(tmp, 2);
114  }
115 
116  if (getEMUHisto(h::EMU_PHYSICS_ME3, me)) {
117  LockType lock(me->mutex);
118  TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
119  summary.Write(tmp, 3);
120  }
121 
122  if (getEMUHisto(h::EMU_PHYSICS_ME4, me)) {
123  LockType lock(me->mutex);
124  TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
125  summary.Write(tmp, 4);
126  }
127 
128  if (getEMUHisto(h::EMU_PHYSICS_EMU, me)) {
129  LockType lock(me->mutex);
130  TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
131  summary.WriteMap(tmp);
132  }
133  }
134 
139  if (config->getPROCESS_EFF_PARAMETERS()) {
140  { // Compute DQM information parameters
141 
142  Address adr;
143  bzero(&adr, sizeof(Address));
144  adr.mask.side = adr.mask.station = adr.mask.ring = true;
145  adr.mask.chamber = adr.mask.layer = adr.mask.cfeb = adr.mask.hv = false;
146 
147  double e_detector = 0.0, e_side = 0.0, e_station = 0.0, e_ring = 0.0;
148  uint32_t e_detector_ch = 0, e_side_ch = 0, e_station_ch = 0;
149 
150  const HistoId parameters[] = {h::PAR_CSC_SIDEPLUS_STATION01_RING01, h::PAR_CSC_SIDEPLUS_STATION01_RING02,
151  h::PAR_CSC_SIDEPLUS_STATION01_RING03, h::PAR_CSC_SIDEPLUS_STATION01,
152  h::PAR_CSC_SIDEPLUS_STATION02_RING01, h::PAR_CSC_SIDEPLUS_STATION02_RING02,
153  h::PAR_CSC_SIDEPLUS_STATION02, h::PAR_CSC_SIDEPLUS_STATION03_RING01,
154  h::PAR_CSC_SIDEPLUS_STATION03_RING02, h::PAR_CSC_SIDEPLUS_STATION03,
155  h::PAR_CSC_SIDEPLUS_STATION04_RING01, h::PAR_CSC_SIDEPLUS_STATION04_RING02,
156  h::PAR_CSC_SIDEPLUS_STATION04, h::PAR_CSC_SIDEPLUS,
157  h::PAR_CSC_SIDEMINUS_STATION01_RING01, h::PAR_CSC_SIDEMINUS_STATION01_RING02,
158  h::PAR_CSC_SIDEMINUS_STATION01_RING03, h::PAR_CSC_SIDEMINUS_STATION01,
159  h::PAR_CSC_SIDEMINUS_STATION02_RING01, h::PAR_CSC_SIDEMINUS_STATION02_RING02,
160  h::PAR_CSC_SIDEMINUS_STATION02, h::PAR_CSC_SIDEMINUS_STATION03_RING01,
161  h::PAR_CSC_SIDEMINUS_STATION03_RING02, h::PAR_CSC_SIDEMINUS_STATION03,
162  h::PAR_CSC_SIDEMINUS_STATION04_RING01, h::PAR_CSC_SIDEMINUS_STATION04_RING02,
163  h::PAR_CSC_SIDEMINUS_STATION04, h::PAR_CSC_SIDEMINUS};
164 
165  bool calc = (config->getNEvents() > 0);
166 
167  if (!calc) {
168  e_detector = e_side = e_station = e_ring = -1.0;
169  }
170 
171  unsigned int parameter = 0;
172  for (adr.side = 1; adr.side <= N_SIDES; adr.side++) {
173  if (calc) {
174  e_side = 0.0;
175  e_side_ch = 0;
176  }
177 
178  adr.mask.station = true;
179  for (adr.station = 1; adr.station <= N_STATIONS; adr.station++) {
180  if (calc) {
181  e_station = 0.0;
182  e_station_ch = 0;
183  }
184 
185  adr.mask.ring = true;
186  for (adr.ring = 1; adr.ring <= summary.getDetector().NumberOfRings(adr.station); adr.ring++) {
187  if (calc) {
188  e_ring = summary.GetEfficiencyHW(adr);
189  uint32_t ch = summary.getDetector().NumberOfChambers(adr.station, adr.ring);
190  e_station += (e_ring * ch);
191  e_station_ch += ch;
192  }
193 
194  if (summary.getDetector().NumberOfRings(adr.station) > 1) {
195  if (getParHisto(parameters[parameter++], me))
196  me->Fill(e_ring);
197  }
198  }
199 
200  adr.mask.ring = false;
201  if (calc) {
202  e_side += e_station;
203  e_side_ch += e_station_ch;
204  e_station = e_station / e_station_ch;
205  }
206 
207  if (getParHisto(parameters[parameter++], me))
208  me->Fill(e_station);
209  }
210 
211  adr.mask.station = false;
212  if (calc) {
213  e_detector += e_side;
214  e_detector_ch += e_side_ch;
215  e_side = e_side / e_side_ch;
216  }
217 
218  if (getParHisto(parameters[parameter++], me))
219  me->Fill(e_side);
220  }
221 
222  if (calc) {
223  e_detector = e_detector / e_detector_ch;
224  }
225 
226  if (getParHisto(h::PAR_REPORT_SUMMARY, me))
227  me->Fill(e_detector);
228  }
229  }
230  }

References cscdqm::AddressMask::cfeb, cscdqm::CFEB_BWORDS, cscdqm::AddressMask::chamber, submitPVResolutionJobs::err, cscdqm::FIFOFULL_ERR, cscdqm::FORMAT_ERR, cscdqm::Summary::getDetector(), cscdqm::Summary::GetEfficiencyHW(), getEMUHisto(), getParHisto(), cscdqm::AddressMask::hv, cscdqm::INPUTTO_ERR, cscdqm::L1SYNC_ERR, cscdqm::AddressMask::layer, CommonMethods::lock(), cscdqm::Address::mask, hlt_dqm_clientPB-live_cfg::me, hlt_dqm_clientPB-live_cfg::me1, N_SIDES, N_STATIONS, cscdqm::NODATA_ALCT, cscdqm::NODATA_CFEB, cscdqm::NODATA_CLCT, cscdqm::Detector::NumberOfChambers(), cscdqm::Detector::NumberOfRings(), pfMETsysShiftCorrections_cfi::parameter, cscdqm::Summary::ReadErrorChambers(), cscdqm::Summary::ReadReportingChambers(), cscdqm::Summary::ReadReportingChambersRef(), cuy::rep, cscdqm::AddressMask::ring, cscdqm::Address::ring, cscdqm::AddressMask::side, cscdqm::Address::side, cscdqm::AddressMask::station, cscdqm::Address::station, summary, createJobs::tmp, cscdqm::Summary::Write(), cscdqm::Summary::WriteMap(), and writeShifterHistograms().

Referenced by cscdqm::EventProcessorMutex::updateFractionAndEfficiencyHistos().

◆ updateFractionHistos()

void cscdqm::EventProcessor::updateFractionHistos ( )

Update Fractional MOs.

Definition at line 26 of file CSCDQM_EventProcessor_updateFracHistos.cc.

26  {
27  calcEMUFractionHisto(h::EMU_DMB_FORMAT_ERRORS_FRACT, h::EMU_DMB_REPORTING, h::EMU_DMB_FORMAT_ERRORS);
28  calcEMUFractionHisto(h::EMU_CSC_FORMAT_ERRORS_FRACT, h::EMU_CSC_REPORTING, h::EMU_CSC_FORMAT_ERRORS);
29  calcEMUFractionHisto(h::EMU_DMB_FORMAT_WARNINGS_FRACT, h::EMU_DMB_REPORTING, h::EMU_DMB_FORMAT_WARNINGS);
30  calcEMUFractionHisto(h::EMU_CSC_FORMAT_WARNINGS_FRACT, h::EMU_CSC_REPORTING, h::EMU_CSC_FORMAT_WARNINGS);
31  calcEMUFractionHisto(h::EMU_DMB_UNPACKED_FRACT, h::EMU_DMB_REPORTING, h::EMU_DMB_UNPACKED);
32  calcEMUFractionHisto(h::EMU_CSC_UNPACKED_FRACT, h::EMU_CSC_REPORTING, h::EMU_CSC_UNPACKED);
33  calcEMUFractionHisto(h::EMU_DMB_WO_ALCT_FRACT, h::EMU_DMB_REPORTING, h::EMU_DMB_WO_ALCT);
34  calcEMUFractionHisto(h::EMU_CSC_WO_ALCT_FRACT, h::EMU_CSC_REPORTING, h::EMU_CSC_WO_ALCT);
35  calcEMUFractionHisto(h::EMU_DMB_WO_CLCT_FRACT, h::EMU_DMB_REPORTING, h::EMU_DMB_WO_CLCT);
36  calcEMUFractionHisto(h::EMU_CSC_WO_CLCT_FRACT, h::EMU_CSC_REPORTING, h::EMU_CSC_WO_CLCT);
37  calcEMUFractionHisto(h::EMU_DMB_WO_CFEB_FRACT, h::EMU_DMB_REPORTING, h::EMU_DMB_WO_CFEB);
38  calcEMUFractionHisto(h::EMU_CSC_WO_CFEB_FRACT, h::EMU_CSC_REPORTING, h::EMU_CSC_WO_CFEB);
39  calcEMUFractionHisto(h::EMU_CSC_DMB_INPUT_FIFO_FULL_FRACT, h::EMU_CSC_REPORTING, h::EMU_CSC_DMB_INPUT_FIFO_FULL);
40  calcEMUFractionHisto(h::EMU_DMB_INPUT_FIFO_FULL_FRACT, h::EMU_DMB_REPORTING, h::EMU_DMB_INPUT_FIFO_FULL);
41  calcEMUFractionHisto(h::EMU_CSC_DMB_INPUT_TIMEOUT_FRACT, h::EMU_CSC_REPORTING, h::EMU_CSC_DMB_INPUT_TIMEOUT);
42  calcEMUFractionHisto(h::EMU_DMB_INPUT_TIMEOUT_FRACT, h::EMU_DMB_REPORTING, h::EMU_DMB_INPUT_TIMEOUT);
43  calcEMUFractionHisto(h::EMU_CSC_L1A_OUT_OF_SYNC_FRACT, h::EMU_CSC_REPORTING, h::EMU_CSC_L1A_OUT_OF_SYNC);
44  calcEMUFractionHisto(h::EMU_DMB_L1A_OUT_OF_SYNC_FRACT, h::EMU_DMB_REPORTING, h::EMU_DMB_L1A_OUT_OF_SYNC);
45  calcEMUFractionHisto(h::EMU_FED_DDU_L1A_MISMATCH_FRACT, h::EMU_FED_ENTRIES, h::EMU_FED_DDU_L1A_MISMATCH);
46  calcEMUFractionHisto(
47  h::EMU_FED_DDU_L1A_MISMATCH_WITH_CSC_DATA_FRACT, h::EMU_FED_ENTRIES, h::EMU_FED_DDU_L1A_MISMATCH_WITH_CSC_DATA);
48 
49  unsigned int iter = 0, crateId = 0, dmbId = 0;
50  MonitorObject *mo = nullptr, *mof = nullptr;
51  while (config->fnNextBookedCSC(iter, crateId, dmbId)) {
52  uint32_t dmbEvents = config->getChamberCounterValue(DMB_EVENTS, crateId, dmbId);
53 
54  if (getCSCHisto(h::CSC_BINCHECK_DATAFLOW_PROBLEMS_TABLE, crateId, dmbId, mo) &&
55  getCSCHisto(h::CSC_BINCHECK_DATAFLOW_PROBLEMS_FREQUENCY, crateId, dmbId, mof)) {
56  LockType lock(mof->mutex);
57  TH1* th = mof->getTH1Lock();
58  th->Reset();
59  th->Add(mo->getTH1());
60  th->Scale(1. / dmbEvents);
61  mof->SetMaximum(1.);
62  mof->SetEntries(dmbEvents);
63  mo->SetEntries(dmbEvents);
64  }
65 
66  if (getCSCHisto(h::CSC_BINCHECK_ERRORSTAT_TABLE, crateId, dmbId, mo) &&
67  getCSCHisto(h::CSC_BINCHECK_ERRORS_FREQUENCY, crateId, dmbId, mof)) {
68  LockType lock(mof->mutex);
69  TH1* th = mof->getTH1Lock();
70  th->Reset();
71  th->Add(mo->getTH1());
72  th->Scale(1. / dmbEvents);
73  mof->SetMaximum(1.);
74  mof->SetEntries(dmbEvents);
75  mo->SetEntries(dmbEvents);
76  }
77  }
78  }

References calcEMUFractionHisto(), cscdqm::DMB_EVENTS, getCSCHisto(), cscdqm::MonitorObject::getTH1(), CommonMethods::lock(), and cscdqm::MonitorObject::SetEntries().

Referenced by cscdqm::EventProcessorMutex::updateFractionAndEfficiencyHistos().

◆ writeShifterHistograms()

void cscdqm::EventProcessor::writeShifterHistograms ( )

Definition at line 232 of file CSCDQM_EventProcessor_updateEffHistos.cc.

232  {
233  MonitorObject* me = nullptr;
234 
235  //const int COLOR_WHITE = 0;
236  const int COLOR_GREEN = 1;
237  const int COLOR_RED = 2;
238  const int COLOR_BLUE = 3;
239  const int COLOR_GREY = 4;
240  const int COLOR_STANDBY = 5;
241 
242  if (getEMUHisto(h::EMU_CSC_STATS_SUMMARY, me)) {
243  LockType lock(me->mutex);
244  TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
245  if (!config->getIN_FULL_STANDBY()) {
246  summary.WriteChamberState(tmp, 0x1, COLOR_GREEN, true, false);
247  summary.WriteChamberState(tmp, HWSTATUSERRORBITS, COLOR_RED, false, true);
248  }
249  summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
250  summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false);
251  }
252 
253  if (getEMUHisto(h::EMU_CSC_STATS_OCCUPANCY, me)) {
254  LockType lock(me->mutex);
255  TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
256  if (!config->getIN_FULL_STANDBY()) {
257  summary.WriteChamberState(tmp, 0x4, COLOR_RED, true, false);
258  summary.WriteChamberState(tmp, 0x8, COLOR_BLUE, false, false);
259  }
260  summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
261  summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false, false);
262  }
263 
264  if (getEMUHisto(h::EMU_CSC_STATS_FORMAT_ERR, me)) {
265  LockType lock(me->mutex);
266  TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
267  if (!config->getIN_FULL_STANDBY()) {
268  summary.WriteChamberState(tmp, 0x10, COLOR_RED, true, false);
269  }
270  summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
271  summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false, false);
272  }
273 
274  if (getEMUHisto(h::EMU_CSC_STATS_L1SYNC_ERR, me)) {
275  LockType lock(me->mutex);
276  TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
277  if (!config->getIN_FULL_STANDBY()) {
278  summary.WriteChamberState(tmp, 0x20, COLOR_RED, true, false);
279  }
280  summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
281  summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false, false);
282  }
283 
284  if (getEMUHisto(h::EMU_CSC_STATS_FIFOFULL_ERR, me)) {
285  LockType lock(me->mutex);
286  TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
287  if (!config->getIN_FULL_STANDBY()) {
288  summary.WriteChamberState(tmp, 0x40, COLOR_RED, true, false);
289  }
290  summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
291  summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false, false);
292  }
293 
294  if (getEMUHisto(h::EMU_CSC_STATS_INPUTTO_ERR, me)) {
295  LockType lock(me->mutex);
296  TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
297  if (!config->getIN_FULL_STANDBY()) {
298  summary.WriteChamberState(tmp, 0x80, COLOR_RED, true, false);
299  }
300  summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
301  summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false, false);
302  }
303 
304  if (getEMUHisto(h::EMU_CSC_STATS_WO_ALCT, me)) {
305  LockType lock(me->mutex);
306  TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
307  if (!config->getIN_FULL_STANDBY()) {
308  summary.WriteChamberState(tmp, 0x100, COLOR_RED, true, false);
309  }
310  summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
311  summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false, false);
312  }
313 
314  if (getEMUHisto(h::EMU_CSC_STATS_WO_CLCT, me)) {
315  LockType lock(me->mutex);
316  TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
317  if (!config->getIN_FULL_STANDBY()) {
318  summary.WriteChamberState(tmp, 0x200, COLOR_RED, true, false);
319  }
320  summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
321  summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false, false);
322  }
323 
324  if (getEMUHisto(h::EMU_CSC_STATS_WO_CFEB, me)) {
325  LockType lock(me->mutex);
326  TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
327  if (!config->getIN_FULL_STANDBY()) {
328  summary.WriteChamberState(tmp, 0x400, COLOR_RED, true, false);
329  }
330  summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
331  summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false, false);
332  }
333 
334  if (getEMUHisto(h::EMU_CSC_STATS_CFEB_BWORDS, me)) {
335  LockType lock(me->mutex);
336  TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
337  if (!config->getIN_FULL_STANDBY()) {
338  summary.WriteChamberState(tmp, 0x800, COLOR_RED, true, false);
339  }
340  summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
341  summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false, false);
342  }
343  }

References dqmd_manager::COLOR_BLUE, dqmd_manager::COLOR_GREEN, dqmd_manager::COLOR_RED, getEMUHisto(), HWSTATUSERRORBITS, CommonMethods::lock(), hlt_dqm_clientPB-live_cfg::me, summary, createJobs::tmp, cscdqm::Summary::WriteChamberState(), testProducerWithPsetDescEmpty_cfi::x1, and testProducerWithPsetDescEmpty_cfi::x2.

Referenced by cscdqm::EventProcessorMutex::processStandby(), and updateEfficiencyHistos().

Member Data Documentation

◆ BXN

uint32_t cscdqm::EventProcessor::BXN
private

Definition at line 160 of file CSCDQM_EventProcessor.h.

Referenced by processCSC(), and processDDU().

◆ cntALCTs

uint32_t cscdqm::EventProcessor::cntALCTs
private

Total Number of CFEBs per event from DMB DAV.

Definition at line 163 of file CSCDQM_EventProcessor.h.

Referenced by processExaminer().

◆ cntCFEBs

uint32_t cscdqm::EventProcessor::cntCFEBs
private

Total Number of DMBs per event from DDU Header DAV.

Definition at line 162 of file CSCDQM_EventProcessor.h.

Referenced by processExaminer().

◆ cntDMBs

uint32_t cscdqm::EventProcessor::cntDMBs
private

Definition at line 161 of file CSCDQM_EventProcessor.h.

Referenced by processExaminer().

◆ cntTMBs

uint32_t cscdqm::EventProcessor::cntTMBs
private

Total Number of ALCTs per event from DMB DAV.

Definition at line 164 of file CSCDQM_EventProcessor.h.

Referenced by processExaminer().

◆ config

Configuration* cscdqm::EventProcessor::config
private

Pointer to Global Configuration

Definition at line 152 of file CSCDQM_EventProcessor.h.

Referenced by confdb.HLTProcess::addEras(), confdb.HLTProcess::addGlobalOptions(), confdb.HLTProcess::build_source(), confdb.HLTProcess::buildOptions(), confdb.HLTProcess::customize(), confdb.HLTProcess::dump(), confdb.HLTProcess::fixPrescales(), pkg.AbstractPkg::generate(), pkg.AbstractPkg::get_kwds(), confdb.HLTProcess::getPathList(), confdb.HLTProcess::getRawConfigurationFromDB(), confdb.HLTProcess::getSetupConfigurationFromDB(), confdb.HLTProcess::instrumentDQM(), confdb.HLTProcess::instrumentErrorEventType(), confdb.HLTProcess::instrumentOpenMode(), confdb.HLTProcess::instrumentTiming(), confdb.HLTProcess::loadCffCommand(), confdb.HLTProcess::loadSetupCff(), confdb.HLTProcess::overrideGlobalTag(), confdb.HLTProcess::overrideL1MenuXml(), confdb.HLTProcess::overrideOutput(), confdb.HLTProcess::overrideProcessName(), pkg.AbstractPkg::parse_etags(), confdb.HLTProcess::runL1Emulator(), and confdb.HLTProcess::specificCustomize().

◆ EmuEventDisplayWasReset

bool cscdqm::EventProcessor::EmuEventDisplayWasReset
private

Definition at line 170 of file CSCDQM_EventProcessor.h.

Referenced by preProcessEvent(), and resetEmuEventDisplays().

◆ fCloseL1As

bool cscdqm::EventProcessor::fCloseL1As
private

Data Format version (2005, 2013)

Definition at line 169 of file CSCDQM_EventProcessor.h.

Referenced by EventProcessor(), processCSC(), and processDDU().

◆ fNotFirstEvent

std::map<uint32_t, bool> cscdqm::EventProcessor::fNotFirstEvent
private

Definition at line 158 of file CSCDQM_EventProcessor.h.

Referenced by processDDU().

◆ frdtoken

edm::EDGetTokenT<FEDRawDataCollection> cscdqm::EventProcessor::frdtoken
private

Definition at line 173 of file CSCDQM_EventProcessor.h.

◆ L1ANumber

uint32_t cscdqm::EventProcessor::L1ANumber
private

Definition at line 159 of file CSCDQM_EventProcessor.h.

Referenced by processCSC(), and processDDU().

◆ L1ANumbers

std::map<uint32_t, uint32_t> cscdqm::EventProcessor::L1ANumbers
private

Definition at line 157 of file CSCDQM_EventProcessor.h.

Referenced by processDDU().

◆ summary

Summary cscdqm::EventProcessor::summary
private

Detector efficiency manipulation object

Definition at line 155 of file CSCDQM_EventProcessor.h.

Referenced by maskHWElements(), processCSC(), standbyEfficiencyHistos(), updateEfficiencyHistos(), and writeShifterHistograms().

◆ theFormatVersion

uint16_t cscdqm::EventProcessor::theFormatVersion
private

Total Number of TMBs per event from DMB DAV.

Definition at line 166 of file CSCDQM_EventProcessor.h.

Referenced by processCSC().

cscdqm::Summary::ReadReportingChambers
void ReadReportingChambers(const TH2 *&h2, const double threshold=1.0)
Read Reporting Chamber histogram and fill in detector map.
Definition: CSCDQM_Summary.cc:61
cscdqm::Summary::WriteChamberState
void WriteChamberState(TH2 *&h2, const int mask, const int value=1, const bool reset=true, const bool op_any=false) const
Write State information to chamber histogram.
Definition: CSCDQM_Summary.cc:339
cscdqm::EventProcessor::getEMUHisto
const bool getEMUHisto(const HistoId &histo, MonitorObject *&me)
Get EMU (Top Level) Monitoring Object.
Definition: CSCDQM_EventProcessor.cc:66
amcDumpToRaw_cfi.fwVersion
fwVersion
Definition: amcDumpToRaw_cfi.py:11
DDAxes::y
BeamSpotPI::parameters
parameters
Definition: BeamSpotPayloadInspectorHelper.h:30
cscdqm::EventProcessor::resetEmuEventDisplays
void resetEmuEventDisplays()
Reset Emu level EventDisplay histograms once per event.
Definition: CSCDQM_EventProcessor_processCSC.cc:56
HLT_FULL_cff.Threshold
Threshold
Definition: HLT_FULL_cff.py:11592
cscdqm::NODATA_CLCT
No ALCT data.
Definition: CSCDQM_Summary.h:59
cscdqm::EventProcessor::fCloseL1As
bool fCloseL1As
Data Format version (2005, 2013)
Definition: CSCDQM_EventProcessor.h:169
mps_fire.i
i
Definition: mps_fire.py:428
CSCDMBTrailer::cfeb_endtimeout
unsigned cfeb_endtimeout() const
Definition: CSCDMBTrailer.h:33
cscdqm::FORMAT_ERR
HW element is cold comparing with reference histogram.
Definition: CSCDQM_Summary.h:53
dqmMemoryStats.float
float
Definition: dqmMemoryStats.py:127
pfMETsysShiftCorrections_cfi.parameter
parameter
Definition: pfMETsysShiftCorrections_cfi.py:118
cscdqm::HistoId
unsigned int HistoId
Definition: CSCDQM_HistoDef.h:35
cscdqm::Detector::NumberOfChambers
const unsigned int NumberOfChambers(const unsigned int station, const unsigned int ring) const
Returns the number of chambers for the given station and ring.
Definition: CSCDQM_Detector.cc:215
dqmiodumpmetadata.n
n
Definition: dqmiodumpmetadata.py:28
CSCDDUEventData::cscData
const std::vector< CSCEventData > & cscData() const
accessor to data
Definition: CSCDDUEventData.h:33
CSCDMBTrailer::alct_starttimeout
unsigned alct_starttimeout() const
Definition: CSCDMBTrailer.h:35
CSCDDUHeader::bxnum
int bxnum() const
Definition: CSCDDUHeader.h:23
cscdqm::FIFOFULL_ERR
L1A out of sync errors.
Definition: CSCDQM_Summary.h:55
CSCDMBTrailer
Definition: CSCDMBTrailer.h:16
cscdqm::BAD_EVENTS
Definition: CSCDQM_Configuration.h:204
cscdqm::EventProcessor::processCSC
void processCSC(const CSCEventData &data, const int dduID, const CSCDCCExaminer &binChecker)
Process Chamber Data and fill MOs.
Definition: CSCDQM_EventProcessor_processCSC.cc:81
CSCTMBTrailer::wordCount
int wordCount() const
Definition: CSCTMBTrailer.cc:60
cscdqm::EventProcessor::writeShifterHistograms
void writeShifterHistograms()
Definition: CSCDQM_EventProcessor_updateEffHistos.cc:232
CSCDDUHeader
Definition: CSCDDUHeader.h:11
CSCDCCFormatStatusDigi::getCSCErrors
ExaminerStatusType getCSCErrors(const CSCIdType CSCId) const
Definition: CSCDCCFormatStatusDigi.h:343
CSCCFEBTimeSlice::get_l1pipe_empty
unsigned get_l1pipe_empty() const
Definition: CSCCFEBTimeSlice.h:100
CSCDMBTrailer::alct_empty
unsigned alct_empty() const
Definition: CSCDMBTrailer.h:42
CSCDCCFormatStatusDigi::nextCSCWithStatus
bool nextCSCWithStatus(uint32_t &iterator, CSCIdType &CSCId) const
CSC with status iteration procedure.
Definition: CSCDCCFormatStatusDigi.h:311
CSCDDUHeader::lvl1num
int lvl1num() const
Definition: CSCDDUHeader.h:24
CSCDMBHeader::cfebActive
unsigned cfebActive() const
Definition: CSCDMBHeader.h:34
testProducerWithPsetDescEmpty_cfi.x2
x2
Definition: testProducerWithPsetDescEmpty_cfi.py:28
CSCDetId::ring
int ring() const
Definition: CSCDetId.h:68
cscdqm::EVENT_DISPLAY_PLOT
Definition: CSCDQM_Configuration.h:209
CSCCFEBSCAControllerWord::sca_blk
unsigned short sca_blk
Definition: CSCCFEBTimeSlice.h:45
CSCDMBTrailer::alct_endtimeout
unsigned alct_endtimeout() const
Definition: CSCDMBTrailer.h:31
CSCDMBHeader::cfebAvailable
bool cfebAvailable(unsigned icfeb)
Definition: CSCDMBHeader.h:21
CSCALCTHeader::L1Acc
unsigned short int L1Acc() const
Definition: CSCALCTHeader.h:97
FEDNumbering::MAXCSCDDUFEDID
Definition: FEDNumbering.h:90
CSCDDUTrailer
Definition: CSCDDUTrailer.h:12
cscdqm::DMB_TRIGGERS
Definition: CSCDQM_Configuration.h:205
timingPdfMaker.histo
histo
Definition: timingPdfMaker.py:278
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:222
cscdqm::CFEB_BWORDS
No CFEB data.
Definition: CSCDQM_Summary.h:61
CSCDMBHeader::dmbCfebSync
unsigned dmbCfebSync() const
Definition: CSCDMBHeader.h:45
CSCDMBHeader::l1a24
unsigned l1a24() const
Definition: CSCDMBHeader.h:40
CSCTMBHeader::CLCTDigis
std::vector< CSCCLCTDigi > CLCTDigis(uint32_t idlayer)
returns CLCT digis
Definition: CSCTMBHeader.h:69
LOG_INFO
#define LOG_INFO
Definition: CSCDQM_Logger.h:42
dqmd_manager.COLOR_BLUE
COLOR_BLUE
Definition: dqmd_manager.py:9
cscdqm::EventProcessor::cntALCTs
uint32_t cntALCTs
Total Number of CFEBs per event from DMB DAV.
Definition: CSCDQM_EventProcessor.h:163
DDAxes::x
CSCALCTTrailer
Definition: CSCALCTTrailer.h:53
cscdqm::Summary::Write
void Write(TH2 *&h2, const unsigned int station) const
Write detector map to H1 histogram (linear data) for the selected adr.station.
Definition: CSCDQM_Summary.cc:229
CSCTMBData::tmbHeader
CSCTMBHeader * tmbHeader()
Definition: CSCTMBData.h:39
cscdqm::Utility::getRUIfromDDUId
static int getRUIfromDDUId(unsigned ddu_id)
Get RUI Number from DDU source ID for post LS1 configuration.
Definition: CSCDQM_Utility.cc:397
CSCDCCFormatStatusDigi::getDDUSummaryErrors
ExaminerStatusType getDDUSummaryErrors() const
Definition: CSCDCCFormatStatusDigi.h:333
cscdqm::CSCHistoDef::getPath
const std::string getPath() const override
Get path part of the histogram (used only for DDUs and CSCs)
Definition: CSCDQM_HistoDef.h:388
b2
static constexpr float b2
Definition: L1EGammaCrystalsEmulatorProducer.cc:83
cscdqm::CFEB_TRIGGERS
Definition: CSCDQM_Configuration.h:208
createJobs.tmp
tmp
align.sh
Definition: createJobs.py:716
CSCTMBData::tmbTrailer
CSCTMBTrailer * tmbTrailer()
Definition: CSCTMBData.h:50
cscdqm::EventProcessor::getCSCFromMap
const bool getCSCFromMap(const unsigned int &crateId, const unsigned int &dmbId, unsigned int &cscType, unsigned int &cscPosition) const
Get CSC type and position from crate and dmb identifiers.
Definition: CSCDQM_EventProcessor.cc:170
CSCDDUTrailer::check
bool check() const
Definition: CSCDDUTrailer.h:25
cscdqm::EventProcessor::getDDUHisto
const bool getDDUHisto(const HistoId &histo, const HwId &dduID, MonitorObject *&me)
Get DDU Level Monitoring Object.
Definition: CSCDQM_EventProcessor.cc:98
CSCCFEBTimeSlice::get_lctpipe_empty
unsigned get_lctpipe_empty() const
Definition: CSCCFEBTimeSlice.h:99
CSCCFEBTimeSlice::get_lctpipe_count
unsigned get_lctpipe_count() const
Definition: CSCCFEBTimeSlice.h:96
CSCTMBHeader::Bxn1Diff
uint16_t Bxn1Diff() const
Definition: CSCTMBHeader.h:46
config
Definition: config.py:1
CSCALCTHeader
Definition: CSCALCTHeader.h:21
b1
static constexpr float b1
Definition: L1EGammaCrystalsEmulatorProducer.cc:83
cscdqm::Detector::GlobalChamberIndex
unsigned int GlobalChamberIndex(unsigned int side, unsigned int station, unsigned int ring, unsigned int chamber) const
Return global chamber index on his geometric location.
Definition: CSCDQM_Detector.cc:147
cscdqm::DDUHistoDef::getPath
const std::string getPath() const override
Get path part of the histogram (used only for DDUs and CSCs)
Definition: CSCDQM_HistoDef.h:330
CSCAnodeData::wireDigis
std::vector< CSCWireDigi > wireDigis(int layer) const
input layer is from 1 to 6
Definition: CSCAnodeData.h:21
N_SIDES
#define N_SIDES
Definition: CSCDQM_Detector.h:42
testProducerWithPsetDescEmpty_cfi.x1
x1
Definition: testProducerWithPsetDescEmpty_cfi.py:33
CSCDDUEventData::header
CSCDDUHeader header() const
Definition: CSCDDUEventData.h:35
CSCALCTHeader::BXNCount
unsigned short int BXNCount() const
Definition: CSCALCTHeader.h:61
CSCDMBTrailer::tmb_empty
unsigned tmb_empty() const
Definition: CSCDMBTrailer.h:43
CSCCFEBTimeSlice::get_lctpipe_full
unsigned get_lctpipe_full() const
Definition: CSCCFEBTimeSlice.h:97
errors
Definition: errors.py:1
CSCDCCFormatStatusDigi::getDDUErrors
ExaminerStatusType getDDUErrors(const DDUIdType DDUId) const
Definition: CSCDCCFormatStatusDigi.h:335
CSCDMBTrailer::tmb_starttimeout
unsigned tmb_starttimeout() const
Definition: CSCDMBTrailer.h:36
CSCDMBTrailer::alct_half
unsigned alct_half() const
Definition: CSCDMBTrailer.h:46
CSCDDUTrailer::errorstat
unsigned errorstat() const
Definition: CSCDDUTrailer.h:36
cscdqm::Detector::NumberOfRings
const unsigned int NumberOfRings(const unsigned int station) const
Returns the number of rings for the given station.
Definition: CSCDQM_Detector.cc:197
CSCDMBTrailer::tmb_endtimeout
unsigned tmb_endtimeout() const
Definition: CSCDMBTrailer.h:32
CSCComparatorData::check
bool check() const
Definition: CSCComparatorData.cc:303
ADC
Definition: ZdcTBAnalysis.h:46
dqmd_manager.COLOR_GREEN
COLOR_GREEN
Definition: dqmd_manager.py:10
compare.tlabel
tlabel
Definition: compare.py:27
CSCDDUTrailer::reserved
unsigned reserved() const
Definition: CSCDDUTrailer.h:43
CSCDDUEventData::trailer
CSCDDUTrailer trailer() const
Definition: CSCDDUEventData.h:36
ADC
struct ADC ADC
CSCCFEBTimeSlice::get_l1pipe_full
unsigned get_l1pipe_full() const
Definition: CSCCFEBTimeSlice.h:98
jets_cff.payload
payload
Definition: jets_cff.py:32
cscdqm::DMB_EVENTS
Definition: CSCDQM_Configuration.h:203
dqmdumpme.k
k
Definition: dqmdumpme.py:60
cscdqm::Utility::getCSCTypeLabel
static std::string getCSCTypeLabel(int endcap, int station, int ring)
Get CSC label from CSC parameters.
Definition: CSCDQM_Utility.cc:80
sistrip::SpyUtilities::isValid
const bool isValid(const Frame &aFrame, const FrameQuality &aQuality, const uint16_t aExpectedPos)
Definition: SiStripSpyUtilities.cc:124
b
double b
Definition: hdecay.h:118
CSCIdType
int32_t CSCIdType
Definition: CSCDCCFormatStatusDigi.h:36
first
auto first
Definition: CAHitNtupletGeneratorKernelsImpl.h:125
CSCCFEBTimeSlice::get_buffer_count
unsigned get_buffer_count() const
Definition: CSCCFEBTimeSlice.h:102
CSCDMBTrailer::cfeb_starttimeout
unsigned cfeb_starttimeout() const
Definition: CSCDMBTrailer.h:37
CSCDMBHeader::bxn12
unsigned bxn12() const
Definition: CSCDMBHeader.h:38
cscdqm::EventProcessor::summary
Summary summary
Definition: CSCDQM_EventProcessor.h:155
dqmd_manager.COLOR_RED
COLOR_RED
Definition: dqmd_manager.py:12
CSCTMBHeader::NCFEBs
uint16_t NCFEBs() const
Definition: CSCTMBHeader.h:59
cscdqm::Summary::SetValue
void SetValue(const HWStatusBit bit, const int value=1)
SetValue for the whole of detector.
Definition: CSCDQM_Summary.cc:393
ntuplemaker.fill
fill
Definition: ntuplemaker.py:304
cscdqm::EventProcessor::setEmuEventDisplayBit
void setEmuEventDisplayBit(MonitorObject *&mo, const unsigned int x, const unsigned int y, const unsigned int bit)
Set a single bit in the 3D Histogram (aka EMU level event display). Checks if mo and x !...
Definition: CSCDQM_EventProcessor_processCSC.cc:41
a
double a
Definition: hdecay.h:119
cscdqm::EventProcessor::calcEMUFractionHisto
void calcEMUFractionHisto(const HistoId &result, const HistoId &set, const HistoId &subset)
Calculate fractional histogram.
Definition: CSCDQM_EventProcessor_updateFracHistos.cc:86
CSCDMBHeader::crateID
unsigned crateID() const
Definition: CSCDMBHeader.h:35
CSCCFEBDataWord::adcCounts
unsigned short adcCounts
Definition: CSCCFEBTimeSlice.h:21
CommonMethods.lock
def lock()
Definition: CommonMethods.py:81
CSCDDUHeader::ncsc
int ncsc() const
Definition: CSCDDUHeader.h:26
CSCDMBTrailer::tmb_full
unsigned tmb_full() const
Definition: CSCDMBTrailer.h:51
CSCDMBTrailer::alct_full
unsigned alct_full() const
Definition: CSCDMBTrailer.h:50
CSCCFEBSCAControllerWord::trig_time
unsigned short trig_time
Definition: CSCCFEBTimeSlice.h:44
CSCDMBTrailer::tmb_half
unsigned tmb_half() const
Definition: CSCDMBTrailer.h:47
cscdqm::Utility::getCSCTypeBin
static int getCSCTypeBin(const std::string &cstr)
Get CSC y-axis position from chamber string.
Definition: CSCDQM_Utility.cc:33
CSCTMBHeader::TMBMatch
uint16_t TMBMatch() const
Definition: CSCTMBHeader.h:43
CSCDetId
Definition: CSCDetId.h:26
CSCDMBTrailer::cfeb_empty
unsigned cfeb_empty() const
Definition: CSCDMBTrailer.h:44
CSCDMBHeader::nalct
unsigned nalct() const
Definition: CSCDMBHeader.h:42
cscdqm::EventProcessor::getCSCHisto
const bool getCSCHisto(const HistoId &histo, const HwId &crateID, const HwId &dmbSlot, MonitorObject *&me)
Get CSC (Chamber) Level Monitoring Object.
Definition: CSCDQM_EventProcessor.cc:115
CalibrationSummaryClient_cfi.Pedestal
Pedestal
Definition: CalibrationSummaryClient_cfi.py:28
cscdqm::EventProcessor::theFormatVersion
uint16_t theFormatVersion
Total Number of TMBs per event from DMB DAV.
Definition: CSCDQM_EventProcessor.h:166
CSCTMBTrailer
Definition: CSCTMBTrailer.h:28
CSCTMBHeader::CLCTOnly
uint16_t CLCTOnly() const
Definition: CSCTMBHeader.h:41
createfilelist.int
int
Definition: createfilelist.py:10
cscdqm::ALCT_TRIGGERS
Definition: CSCDQM_Configuration.h:206
FEDNumbering::MINCSCDDUFEDID
Definition: FEDNumbering.h:89
cscdqm::EventProcessor::BXN
uint32_t BXN
Definition: CSCDQM_EventProcessor.h:160
cuy.rep
rep
Definition: cuy.py:1189
topSingleLeptonDQM_PU_cfi.pattern
pattern
Definition: topSingleLeptonDQM_PU_cfi.py:39
cscdqm::CLCT_TRIGGERS
Definition: CSCDQM_Configuration.h:207
CSCDCCFormatStatusDigi::getCSCPayload
ExaminerStatusType getCSCPayload(const CSCIdType CSCId) const
Definition: CSCDCCFormatStatusDigi.h:355
CSCDetId::chamber
int chamber() const
Definition: CSCDetId.h:62
CSCDDUTrailer::dmb_full
unsigned dmb_full() const
Definition: CSCDDUTrailer.h:42
CSCTMBData
Definition: CSCTMBData.h:24
EcalCondDBWriter_cfi.pedestal
pedestal
Definition: EcalCondDBWriter_cfi.py:49
cscdqm::EventProcessor::EmuEventDisplayWasReset
bool EmuEventDisplayWasReset
Definition: CSCDQM_EventProcessor.h:170
cscdqm::EventProcessor::cntTMBs
uint32_t cntTMBs
Total Number of ALCTs per event from DMB DAV.
Definition: CSCDQM_EventProcessor.h:164
cscdqm::STANDBY
Data with CFEB BWORDS.
Definition: CSCDQM_Summary.h:63
cscdqm::NODATA_CFEB
No CLCT data.
Definition: CSCDQM_Summary.h:60
hlt_dqm_clientPB-live_cfg.me1
me1
Definition: hlt_dqm_clientPB-live_cfg.py:73
CSCALCTHeader::ALCTDigis
std::vector< CSCALCTDigi > ALCTDigis() const
Definition: CSCALCTHeader.cc:152
cscdqm::Summary::setMaskedHWElements
const unsigned int setMaskedHWElements(std::vector< std::string > &tokens)
Read HW element masks (strings), create Address and apply to detector map.
Definition: CSCDQM_Summary.cc:800
submitPVResolutionJobs.err
err
Definition: submitPVResolutionJobs.py:85
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
cscdqm::NODATA_ALCT
DMB Input timeout error.
Definition: CSCDQM_Summary.h:58
cscdqm::Summary::ReadErrorChambers
void ReadErrorChambers(const TH2 *&evs, const TH2 *&err, const HWStatusBit bit, const double eps_max=0.1, const double Sfail=5.0)
Read Error data for Chambers.
Definition: CSCDQM_Summary.cc:197
CSCComparatorData::comparatorDigis
std::vector< CSCComparatorDigi > comparatorDigis(int layer)
layers count from one
Definition: CSCComparatorData.cc:182
CSCDDUHeader::live_cscs
int live_cscs() const
Definition: CSCDDUHeader.h:29
me0TriggerPseudoDigis_cff.nStrips
nStrips
1.2 is to make the matching window safely the two nearest strips 0.35 is the size of an ME0 chamber i...
Definition: me0TriggerPseudoDigis_cff.py:26
cscdqm::Summary::WriteMap
void WriteMap(TH2 *&h2)
Write PhysicsReady Map to H2 histogram.
Definition: CSCDQM_Summary.cc:279
CSCTMBHeader
Definition: CSCTMBHeader.h:27
CSCALCTTrailer::wordCount
int wordCount() const
Definition: CSCALCTTrailer.h:135
CSCDCCExaminer::nSTATUSES
const uint16_t nSTATUSES
Definition: CSCDCCExaminer.h:17
CSCTMBHeader::Bxn0Diff
uint16_t Bxn0Diff() const
Definition: CSCTMBHeader.h:45
CSCDDUTrailer::dmb_warn
unsigned dmb_warn() const
Definition: CSCDDUTrailer.h:41
CSCDMBHeader
Definition: CSCDMBHeader.h:15
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
CSCDMBHeader::cfebMovlp
unsigned cfebMovlp() const
Definition: CSCDMBHeader.h:44
cscdqm::Summary::isChamberStandby
bool isChamberStandby(unsigned int side, unsigned int station, unsigned int ring, unsigned int chamber) const
Check if chamber is in standby?
Definition: CSCDQM_Summary.cc:707
cscdqm::Summary::GetEfficiencyHW
const double GetEfficiencyHW() const
Get efficiency of the whole detector.
Definition: CSCDQM_Summary.cc:512
cscdqm::EventProcessor::L1ANumber
uint32_t L1ANumber
Definition: CSCDQM_EventProcessor.h:159
CSCDetId::endcap
int endcap() const
Definition: CSCDetId.h:85
cscdqm::EventProcessor::getParHisto
const bool getParHisto(const HistoId &histo, MonitorObject *&me)
Get Parameter Monitoring Object.
Definition: CSCDQM_EventProcessor.cc:153
cscdqm::L1SYNC_ERR
Format errors.
Definition: CSCDQM_Summary.h:54
CSCCFEBSCAControllerWord::l1a_phase
unsigned short l1a_phase
Definition: CSCCFEBTimeSlice.h:46
CSCAnodeData
Definition: CSCAnodeData.h:9
cscdqm::Summary::ReadReportingChambersRef
void ReadReportingChambersRef(const TH2 *&h2, const TH2 *&refh2, const double cold_coef=0.1, const double cold_Sfail=5.0, const double hot_coef=2.0, const double hot_Sfail=5.0)
Read Reporting Chamber histogram and fill in detector map based on reference histogram.
Definition: CSCDQM_Summary.cc:95
CSCDMBTrailer::cfeb_full
unsigned cfeb_full() const
Definition: CSCDMBTrailer.h:52
cscdqm::timeSample
CSCCFEBDataWord const *const timeSample(T const &data, int nCFEB, int nSample, int nLayer, int nStrip)
Definition: CSCDQM_EventProcessor_processCSC.cc:24
N_STATIONS
#define N_STATIONS
Definition: CSCDQM_Detector.h:43
cscdqm::WAS_ON
HW element in standby mode.
Definition: CSCDQM_Summary.h:64
CSCTMBHeader::BXNCount
uint16_t BXNCount() const
Definition: CSCTMBHeader.h:39
data
char data[epos_bytes_allocation]
Definition: EPOS_Wrapper.h:79
CSCDDUHeader::output_path_status
int output_path_status() const
Definition: CSCDDUHeader.h:30
CSCDMBTrailer::cfeb_half
unsigned cfeb_half() const
Definition: CSCDMBTrailer.h:48
CSCCFEBDataWord::adcOverflow
unsigned short adcOverflow
Definition: CSCCFEBTimeSlice.h:22
CSCDMBHeader::dmbID
unsigned dmbID() const
Definition: CSCDMBHeader.h:36
CSCDMBHeader::nclct
unsigned nclct() const
Definition: CSCDMBHeader.h:43
CSCDDUEventData::sizeInWords
int sizeInWords() const
Definition: CSCDDUEventData.h:54
CSCTMBHeader::ALCTOnly
uint16_t ALCTOnly() const
Definition: CSCTMBHeader.h:42
CSCDDUHeader::dmb_dav
int dmb_dav() const
Definition: CSCDDUHeader.h:27
cscdqm::timeSlice
CSCCFEBTimeSlice const *const timeSlice(T const &data, int nCFEB, int nSample)
Definition: CSCDQM_EventProcessor_processCSC.cc:29
mps_fire.result
result
Definition: mps_fire.py:311
HWSTATUSERRORBITS
#define HWSTATUSERRORBITS
Definition: CSCDQM_Summary.h:33
CSCTMBHeader::ALCTMatchTime
uint16_t ALCTMatchTime() const
Definition: CSCTMBHeader.h:40
CSCDCCExaminer::errorsForChamber
ExaminerStatusType errorsForChamber(CSCIdType chamber) const
Definition: CSCDCCExaminer.h:253
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
cscdqm::EventProcessor::cntCFEBs
uint32_t cntCFEBs
Total Number of DMBs per event from DDU Header DAV.
Definition: CSCDQM_EventProcessor.h:162
CSCCFEBTimeSlice::get_n_free_sca_blocks
unsigned get_n_free_sca_blocks() const
Definition: CSCCFEBTimeSlice.h:95
CSCDetId::station
int station() const
Definition: CSCDetId.h:79
CSCDDUTrailer::wordcount
unsigned wordcount() const
Definition: CSCDDUTrailer.h:37
LOG_WARN
#define LOG_WARN
Definition: CSCDQM_Logger.h:41
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
hlt_dqm_clientPB-live_cfg.me
me
Definition: hlt_dqm_clientPB-live_cfg.py:61
CSCCFEBTimeSlice::scaControllerWord
CSCCFEBSCAControllerWord scaControllerWord(int layer) const
unpacked from the controller words for each channel in the layer
Definition: CSCCFEBTimeSlice.cc:46
cscd2r::chamberID
CSCDetId chamberID(const CSCDetId &cscDetId)
takes layer ID, converts to chamber ID, switching ME1A to ME11
Definition: CSCDigiToRaw.cc:30
ExaminerStatusType
uint32_t ExaminerStatusType
Definition: CSCDCCFormatStatusDigi.h:40
CSCTMBHeader::L1ANumber
uint16_t L1ANumber() const
Definition: CSCTMBHeader.h:48
CSCDCCFormatStatusDigi::nextCSCWithError
bool nextCSCWithError(uint32_t &iterator, CSCIdType &CSCId) const
CSC with error iteration procedure. Usage: unsigned int i = 0; CSCIdType cscId; while (c....
Definition: CSCDCCFormatStatusDigi.h:302
CSCDMBTrailer::dmb_l1pipe
unsigned dmb_l1pipe() const
Definition: CSCDMBTrailer.h:40
cscdqm::EventProcessor::cntDMBs
uint32_t cntDMBs
Definition: CSCDQM_EventProcessor.h:161
CSCDCCFormatStatusDigi::nextCSCWithPayload
bool nextCSCWithPayload(uint32_t &iterator, CSCIdType &CSCId) const
CSC with payload iteration procedure.
Definition: CSCDCCFormatStatusDigi.h:320
CSCDDUHeader::source_id
int source_id() const
Definition: CSCDDUHeader.h:22
CSCDCCFormatStatusDigi::getListOfDDUs
std::set< DDUIdType > getListOfDDUs() const
Definition: CSCDCCFormatStatusDigi.h:283
LOG_ERROR
#define LOG_ERROR
Definition: CSCDQM_Logger.h:40
cscdqm::Summary::getDetector
const Detector getDetector() const
Definition: CSCDQM_Summary.h:85
cscdqm::INPUTTO_ERR
DMB FIFO full error.
Definition: CSCDQM_Summary.h:56
CSCDCCFormatStatusDigi::getCSCStatus
ExaminerStatusType getCSCStatus(const CSCIdType CSCId) const
Definition: CSCDCCFormatStatusDigi.h:367
CSCComparatorData
Definition: CSCComparatorData.h:24
cscdqm::EventProcessor::fNotFirstEvent
std::map< uint32_t, bool > fNotFirstEvent
Definition: CSCDQM_EventProcessor.h:158
CSCALCTHeader::alctFirmwareVersion
unsigned short int alctFirmwareVersion() const
Definition: CSCALCTHeader.h:137
cscdqm::EventProcessor::L1ANumbers
std::map< uint32_t, uint32_t > L1ANumbers
Definition: CSCDQM_EventProcessor.h:157
Generated for CMSSW Reference Manual by doxygen 1.8.16