00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #include "DQM/CSCMonitorModule/interface/CSCDQM_EventProcessor.h"
00020
00021
00022
00023 namespace cscdqm {
00024
00025 template<typename T> inline CSCCFEBDataWord const * const
00026 timeSample( T const & data, int nCFEB,int nSample,int nLayer, int nStrip) {
00027 return data.cfebData(nCFEB)->timeSlice(nSample)->timeSample(nLayer,nStrip);
00028 }
00029
00030 template<typename T> inline CSCCFEBTimeSlice const * const
00031 timeSlice( T const & data, int nCFEB, int nSample) { return (CSCCFEBTimeSlice *)(data.cfebData(nCFEB)->timeSlice(nSample));}
00032
00033
00034
00043 void EventProcessor::setEmuEventDisplayBit(MonitorObject*& mo, const unsigned int x, const unsigned int y, const unsigned int bit) {
00044 if (mo && x) {
00045 resetEmuEventDisplays();
00046 int bitset = (int) mo->GetBinContent(x, y);
00047 bitset |= 1 << bit;
00048 mo->SetBinContent(x, y, bitset);
00049 }
00050 }
00051
00052
00056 void EventProcessor::resetEmuEventDisplays() {
00057 if (!EmuEventDisplayWasReset) {
00058
00059
00060 MonitorObject* mo = 0;
00061 if (getEMUHisto(h::EMU_EVENT_DISPLAY_ANODE, mo)) {
00062 mo->getTH1Lock()->Reset("");
00063 }
00064
00065 if (getEMUHisto(h::EMU_EVENT_DISPLAY_CATHODE, mo)) {
00066 mo->getTH1Lock()->Reset("");
00067 }
00068
00069 if (getEMUHisto(h::EMU_EVENT_DISPLAY_XY, mo)) {
00070 mo->getTH1Lock()->Reset("");
00071 }
00072
00073 EmuEventDisplayWasReset = true;
00074
00075 }
00076 }
00077
00083 void EventProcessor::processCSC(const CSCEventData& data, const int dduID, const CSCDCCExaminer& binChecker) {
00084
00085 config->incNUnpackedCSC();
00086
00087 if (&data == 0) {
00088 LOG_ERROR << "Zero pointer. DMB data are not available for unpacking";
00089 return;
00090 }
00091
00092 int FEBunpacked = 0;
00093 int alct_unpacked = 0;
00094 int tmb_unpacked = 0;
00095 int cfeb_unpacked = 0;
00096
00097 int alct_keywg = -1;
00098 int clct_kewdistrip = -1;
00099
00100 bool L1A_out_of_sync = false;
00101
00102 MonitorObject* mo = NULL;
00103
00106 const CSCDMBHeader* dmbHeader = data.dmbHeader();
00107 const CSCDMBTrailer* dmbTrailer = data.dmbTrailer();
00108 if (!dmbHeader && !dmbTrailer) {
00109 LOG_ERROR << "Can not unpack DMB Header or/and Trailer";
00110 return;
00111 }
00112
00114 unsigned int crateID = 0xFF;
00115 unsigned int dmbID = 0xF;
00116 unsigned int chamberID = 0xFFF;
00117
00118 crateID = dmbHeader->crateID();
00119 dmbID = dmbHeader->dmbID();
00120 chamberID = (((crateID) << 4) + dmbID) & 0xFFF;
00121
00122 const std::string cscTag = CSCHistoDef::getPath(crateID, dmbID);
00123
00124 unsigned long errors = binChecker.errorsForChamber(chamberID);
00125 if ((errors & config->getBINCHECK_MASK()) > 0 ) {
00126 LOG_WARN << "Format Errors " << cscTag << ": 0x" << std::hex << errors << " Skipped CSC Unpacking";
00127 return;
00128 }
00129
00130 unsigned int cscType = 0;
00131 unsigned int cscPosition = 0;
00132 if (!getCSCFromMap(crateID, dmbID, cscType, cscPosition )) return;
00133
00134 CSCDetId cid;
00135 if (!config->fnGetCSCDetId(crateID, dmbID, cid)) {
00136 return;
00137 }
00138
00139
00140 if (summary.isChamberStandby(cid)) {
00141 return;
00142 }
00143
00144 double DMBEvents = 0.0;
00145 DMBEvents = config->getChamberCounterValue(DMB_EVENTS, crateID, dmbID);
00146
00147
00148 uint32_t evDisplNo = config->getChamberCounterValue(EVENT_DISPLAY_PLOT, crateID, dmbID);
00149 evDisplNo += 1;
00150 if (evDisplNo >= 5) {
00151 config->setChamberCounterValue(EVENT_DISPLAY_PLOT, crateID, dmbID, 0);
00152 } else {
00153 config->setChamberCounterValue(EVENT_DISPLAY_PLOT, crateID, dmbID, evDisplNo);
00154 }
00155 MonitorObject* mo_EventDisplay = 0;
00156 if (getCSCHisto(h::CSC_EVENT_DISPLAY_NOXX, crateID, dmbID, evDisplNo, mo_EventDisplay)) {
00157 mo_EventDisplay->getTH1Lock()->Reset("");
00158 }
00159
00160
00161 MonitorObject *mo_Emu_EventDisplay_Anode = 0, *mo_Emu_EventDisplay_Cathode = 0, *mo_Emu_EventDisplay_XY = 0;
00162 getEMUHisto(h::EMU_EVENT_DISPLAY_ANODE, mo_Emu_EventDisplay_Anode);
00163 getEMUHisto(h::EMU_EVENT_DISPLAY_CATHODE, mo_Emu_EventDisplay_Cathode);
00164 getEMUHisto(h::EMU_EVENT_DISPLAY_XY, mo_Emu_EventDisplay_XY);
00165
00166
00167 uint32_t glChamberIndex = 0;
00168
00169 if (mo_EventDisplay) {
00170 mo_EventDisplay->SetBinContent(1, 1, cid.endcap());
00171 mo_EventDisplay->SetBinContent(1, 2, cid.station());
00172 mo_EventDisplay->SetBinContent(1, 3, cid.ring());
00173 mo_EventDisplay->SetBinContent(1, 4, cscPosition);
00174 mo_EventDisplay->SetBinContent(1, 5, crateID);
00175 mo_EventDisplay->SetBinContent(1, 6, dmbID);
00176 mo_EventDisplay->SetBinContent(1, 7, dmbHeader->l1a());
00177 if (mo_Emu_EventDisplay_Anode || mo_Emu_EventDisplay_Cathode || mo_Emu_EventDisplay_XY) {
00178 glChamberIndex = summary.getDetector().GlobalChamberIndex(cid.endcap(), cid.station(), cid.ring(), cscPosition);
00179 }
00180 }
00181
00182 config->copyChamberCounterValue(DMB_EVENTS, DMB_TRIGGERS, crateID, dmbID);
00183
00184 if (cscType && cscPosition && getEMUHisto(h::EMU_CSC_UNPACKED, mo)){
00185 mo->Fill(cscPosition, cscType);
00186 }
00187
00189 float DMBEff = float(DMBEvents) / float(config->getNEvents());
00190 if(DMBEff > 1.0) {
00191 LOG_ERROR << cscTag << " has efficiency " << DMBEff << " which is greater than 1";
00192 }
00193
00197 int dmbHeaderL1A = dmbHeader->l1a()%64;
00199 int dmb_ddu_l1a_diff = (int)(dmbHeaderL1A-(int)(L1ANumber%64));
00200 if (dmb_ddu_l1a_diff != 0) L1A_out_of_sync = true;
00201
00204 if (getCSCHisto(h::CSC_DMB_L1A_DISTRIB, crateID, dmbID, mo)) mo->Fill(dmbHeaderL1A);
00205
00206 if (getCSCHisto(h::CSC_DMB_DDU_L1A_DIFF, crateID, dmbID, mo)) {
00207 if(dmb_ddu_l1a_diff < -32) {
00208 mo->Fill(dmb_ddu_l1a_diff + 64);
00209 } else {
00210 if(dmb_ddu_l1a_diff >= 32) mo->Fill(dmb_ddu_l1a_diff - 64);
00211 else mo->Fill(dmb_ddu_l1a_diff);
00212 }
00213 mo->SetAxisRange(0.1, 1.1 * (1.0 + mo->GetBinContent(mo->GetMaximumBin())), "Y");
00214 }
00215
00216 if (getCSCHisto(h::CSC_DMB_L1A_VS_DDU_L1A, crateID, dmbID, mo)) mo->Fill((int)(L1ANumber & 0xFF), (int)dmbHeaderL1A);
00217
00219 int dmbHeaderBXN = 0;
00220 int dmb_ddu_bxn_diff = 0;
00221
00226 dmbHeaderBXN = dmbHeader->bxn12();
00230 dmb_ddu_bxn_diff = dmbHeaderBXN%64-BXN%64;
00232 if (getCSCHisto(h::CSC_DMB_BXN_DISTRIB, crateID, dmbID, mo)) mo->Fill((int)(dmbHeader->bxn12()));
00233
00234 if (getCSCHisto(h::CSC_DMB_DDU_BXN_DIFF, crateID, dmbID, mo)) {
00235 if(dmb_ddu_bxn_diff < -32) mo->Fill(dmb_ddu_bxn_diff + 64);
00236 else {
00237 if(dmb_ddu_bxn_diff >= 32) mo->Fill(dmb_ddu_bxn_diff - 64);
00238 else mo->Fill(dmb_ddu_bxn_diff);
00239 }
00240 mo->SetAxisRange(0.1, 1.1 * (1.0 + mo->GetBinContent(mo->GetMaximumBin())), "Y");
00241 }
00242
00244 if (getCSCHisto(h::CSC_DMB_BXN_VS_DDU_BXN, crateID, dmbID, mo)) mo->Fill(((int)(BXN)) % 256, ((int)dmbHeaderBXN) % 256);
00245
00247 int cfeb_dav = 0;
00248 int cfeb_dav_num = 0;
00249 int cfeb_movlp = 0;
00250 int dmb_cfeb_sync = 0;
00251
00252 cfeb_dav = (int)dmbHeader->cfebAvailable();
00253 for (int i = 0; i < 5; i++) cfeb_dav_num += (cfeb_dav >> i) & 0x1;
00254 cfeb_movlp = (int)dmbHeader->cfebMovlp();
00255 dmb_cfeb_sync = (int)dmbHeader->dmbCfebSync();
00256
00257 if (getCSCHisto(h::CSC_DMB_CFEB_DAV, crateID, dmbID, mo)) {
00258 for (int i = 0; i < 5; i++) {
00259 int cfeb_present = (cfeb_dav >> i) & 0x1;
00260 if (cfeb_present) {
00261 mo->Fill(i);
00262 }
00263 }
00264 }
00265
00266 if (getCSCHisto(h::CSC_DMB_CFEB_DAV_MULTIPLICITY, crateID, dmbID, mo)) mo->Fill(cfeb_dav_num);
00267 if (getCSCHisto(h::CSC_DMB_CFEB_MOVLP, crateID, dmbID, mo)) mo->Fill(cfeb_movlp);
00268 if (getCSCHisto(h::CSC_DMB_CFEB_SYNC, crateID, dmbID, mo)) mo->Fill(dmb_cfeb_sync);
00269
00270 if (getEMUHisto(h::EMU_DMB_UNPACKED, mo)) {
00271 mo->Fill(crateID, dmbID);
00273 }
00274
00276 if (getCSCHisto(h::CSC_DMB_CFEB_ACTIVE, crateID, dmbID, mo)) mo->Fill(dmbHeader->cfebActive());
00277
00281 if (getCSCHisto(h::CSC_DMB_L1_PIPE, crateID, dmbID, mo)) mo->Fill(dmbTrailer->dmb_l1pipe);
00282
00284 if (getCSCHisto(h::CSC_DMB_FIFO_STATS, crateID, dmbID, mo)) {
00285 if (dmbTrailer->tmb_empty == 1) mo->Fill(1.0, 0.0);
00286 if (dmbTrailer->tmb_half == 0) mo->Fill(1.0, 1.0);
00287 if (dmbTrailer->tmb_full == 1) mo->Fill(1.0, 2.0);
00288 if (dmbTrailer->alct_empty == 1) mo->Fill(0.0, 0.0);
00289 if (dmbTrailer->alct_half == 0) mo->Fill(0.0, 1.0);
00290 if (dmbTrailer->alct_full == 1) mo->Fill(0.0, 2.0);
00291 for (int i = 0; i < 5; i++) {
00292 if ((int)((dmbTrailer->cfeb_empty>>i)&0x1) == 1) mo->Fill(i + 2, 0.0);
00293 if ((int)((dmbTrailer->cfeb_half>>i)&0x1) == 0) mo->Fill(i + 2, 1);
00294 if ((int)((dmbTrailer->cfeb_full>>i)&0x1) == 1) {
00295 mo->Fill(i + 2, 2);
00296 }
00297 }
00298 mo->SetEntries((int)DMBEvents);
00299 }
00300
00302 if (getCSCHisto(h::CSC_DMB_FEB_TIMEOUTS, crateID, dmbID, mo)) {
00303 if ((dmbTrailer->tmb_timeout == 0) && (dmbTrailer->alct_timeout == 0) && (dmbTrailer->cfeb_starttimeout == 0) && (dmbTrailer->cfeb_endtimeout == 0)) {
00304 mo->Fill(0.0);
00305 }else{
00306 if (dmbTrailer->alct_timeout) mo->Fill(1);
00307 if (dmbTrailer->tmb_timeout) mo->Fill(2);
00308 if (dmbTrailer->alct_endtimeout) mo->Fill(8);
00309 if (dmbTrailer->tmb_endtimeout) mo->Fill(9);
00310 }
00311 for (int i = 0; i < 5; i++) {
00312 if ((dmbTrailer->cfeb_starttimeout >> i) & 0x1) {
00313 mo->Fill(i + 3);
00314 }
00315 if ((dmbTrailer->cfeb_endtimeout >> i) & 0x1) {
00316 mo->Fill(i + 10);
00317 }
00318 }
00319 mo->SetEntries((int)DMBEvents);
00320 }
00321
00323 int alct_dav = dmbHeader->nalct();
00324 int tmb_dav = dmbHeader->nclct();
00325 int cfeb_dav2 = 0;
00326 for (int i = 0; i < 5; i++) cfeb_dav2 = cfeb_dav2 + (int)((dmbHeader->cfebAvailable() >> i) & 0x1);
00327
00330 if ((alct_dav > 0) && (getCSCHisto(h::CSC_DMB_FEB_DAV_RATE, crateID, dmbID, mo))) {
00331 mo->Fill(0.0);
00332 float alct_dav_number = mo->GetBinContent(1);
00333 if (getCSCHisto(h::CSC_DMB_FEB_DAV_EFFICIENCY, crateID, dmbID, mo)) {
00334 mo->SetBinContent(1, ((float)alct_dav_number / (float)(DMBEvents) * 100.0));
00335 mo->SetEntries((int)DMBEvents);
00336 }
00337 }
00338
00339 if ((tmb_dav > 0) && (getCSCHisto(h::CSC_DMB_FEB_DAV_RATE, crateID, dmbID, mo))) {
00340 mo->Fill(1.0);
00341 float tmb_dav_number = mo->GetBinContent(2);
00342 if (getCSCHisto(h::CSC_DMB_FEB_DAV_EFFICIENCY, crateID, dmbID, mo)) {
00343 mo->SetBinContent(2, ((float)tmb_dav_number / (float)(DMBEvents) * 100.0));
00344 mo->SetEntries((int)DMBEvents);
00345 }
00346 }
00347
00348 if ((cfeb_dav2 > 0) && (getCSCHisto(h::CSC_DMB_FEB_DAV_RATE, crateID, dmbID, mo))) {
00349 mo->Fill(2.0);
00350 float cfeb_dav2_number = mo->GetBinContent(3);
00351 if (getCSCHisto(h::CSC_DMB_FEB_DAV_EFFICIENCY, crateID, dmbID, mo)) {
00352 mo->SetBinContent(3, ((float)cfeb_dav2_number / (float)(DMBEvents) * 100.0));
00353 mo->SetEntries((int)DMBEvents);
00354 }
00355 }
00356
00357 float feb_combination_dav = -1.0;
00359 if (getCSCHisto(h::CSC_DMB_FEB_COMBINATIONS_DAV_RATE, crateID, dmbID, mo)) {
00360 if(alct_dav == 0 && tmb_dav == 0 && cfeb_dav2 == 0) feb_combination_dav = 0.0;
00361 if(alct_dav > 0 && tmb_dav == 0 && cfeb_dav2 == 0) feb_combination_dav = 1.0;
00362 if(alct_dav == 0 && tmb_dav > 0 && cfeb_dav2 == 0) feb_combination_dav = 2.0;
00363 if(alct_dav == 0 && tmb_dav == 0 && cfeb_dav2 > 0) feb_combination_dav = 3.0;
00364 if(alct_dav == 0 && tmb_dav > 0 && cfeb_dav2 > 0) feb_combination_dav = 4.0;
00365 if(alct_dav > 0 && tmb_dav > 0 && cfeb_dav2 == 0) feb_combination_dav = 5.0;
00366 if(alct_dav > 0 && tmb_dav == 0 && cfeb_dav2 > 0) feb_combination_dav = 6.0;
00367 if(alct_dav > 0 && tmb_dav > 0 && cfeb_dav2 > 0) feb_combination_dav = 7.0;
00368 mo->Fill(feb_combination_dav);
00369 float feb_combination_dav_number = mo->GetBinContent((int)(feb_combination_dav + 1.0));
00370 if (getCSCHisto(h::CSC_DMB_FEB_COMBINATIONS_DAV_EFFICIENCY, crateID, dmbID, mo)) {
00371 mo->SetBinContent((int)(feb_combination_dav + 1.0), ((float)feb_combination_dav_number / (float)(DMBEvents) * 100.0));
00372 mo->SetEntries((int)DMBEvents);
00373 }
00374 }
00375
00377 if (data.nalct()) {
00378
00379 const CSCALCTHeader* alctHeader = data.alctHeader();
00380 int fwVersion = alctHeader->alctFirmwareVersion();
00381 const CSCALCTTrailer* alctTrailer = data.alctTrailer();
00382 const CSCAnodeData* alctData = data.alctData();
00383
00384 if (alctHeader && alctTrailer) {
00385
00386 std::vector<CSCALCTDigi> alctsDatasTmp = alctHeader->ALCTDigis();
00387 std::vector<CSCALCTDigi> alctsDatas;
00388
00389 for (uint32_t lct = 0; lct < alctsDatasTmp.size(); lct++) {
00390 if (alctsDatasTmp[lct].isValid()) alctsDatas.push_back(alctsDatasTmp[lct]);
00391 }
00392
00393 FEBunpacked = FEBunpacked + 1;
00394 alct_unpacked = 1;
00395
00397 if (getCSCHisto(h::CSC_CSC_RATE, crateID, dmbID, mo)) {
00398 mo->Fill(2);
00399 uint32_t ALCTEvent = (uint32_t)mo->GetBinContent(3);
00400 config->setChamberCounterValue(ALCT_TRIGGERS, crateID, dmbID, ALCTEvent);
00401 if (getCSCHisto(h::CSC_CSC_EFFICIENCY, crateID, dmbID, mo)){
00402 if(config->getNEvents() > 0) {
00405 mo->SetBinContent(1, ((float)ALCTEvent / (float)(DMBEvents) * 100.0));
00407 mo->SetEntries((int)DMBEvents);
00408 }
00409 }
00410 }
00411
00412 if ((alct_dav >0) && (getCSCHisto(h::CSC_DMB_FEB_UNPACKED_VS_DAV, crateID, dmbID, mo))) {
00413 mo->Fill(0.0, 0.0);
00414 }
00415
00418 if (getCSCHisto(h::CSC_ALCT_L1A, crateID, dmbID, mo)) mo->Fill((int)(alctHeader->L1Acc()));
00419
00421 if (getCSCHisto(h::CSC_ALCT_DMB_L1A_DIFF, crateID, dmbID, mo)) {
00423 int alct_dmb_l1a_diff = (int)(alctHeader->L1Acc() % 64 - dmbHeader->l1a() % 64);
00424 if (alct_dmb_l1a_diff != 0) L1A_out_of_sync = true;
00425 if(alct_dmb_l1a_diff < -32) mo->Fill(alct_dmb_l1a_diff + 64);
00426 else {
00427 if(alct_dmb_l1a_diff >= 32) mo->Fill(alct_dmb_l1a_diff - 64);
00428 else mo->Fill(alct_dmb_l1a_diff);
00429 }
00430 mo->SetAxisRange(0.1, 1.1 * (1.0 + mo->GetBinContent(mo->GetMaximumBin())), "Y");
00431 }
00432
00434 if (getCSCHisto(h::CSC_DMB_L1A_VS_ALCT_L1A, crateID, dmbID, mo)) mo->Fill(alctHeader->L1Acc() % 256, dmbHeader->l1a());
00435
00438 if (getCSCHisto(h::CSC_ALCT_DMB_BXN_DIFF, crateID, dmbID, mo)) {
00439 int alct_dmb_bxn_diff = (int)(alctHeader->BXNCount()-dmbHeader->bxn12());
00440 if (alct_dmb_bxn_diff > 0) alct_dmb_bxn_diff -= 3564;
00441 alct_dmb_bxn_diff %= 64;
00442 mo->Fill(alct_dmb_bxn_diff);
00443 mo->SetAxisRange(0.1, 1.1 * (1.0 + mo->GetBinContent(mo->GetMaximumBin())), "Y");
00444 }
00445
00446 if (getCSCHisto(h::CSC_ALCT_BXN, crateID, dmbID, mo)) mo->Fill(alctHeader->BXNCount());
00447
00449 if (getCSCHisto(h::CSC_ALCT_BXN_VS_DMB_BXN, crateID, dmbID, mo)) mo->Fill((int)((alctHeader->BXNCount()) % 256), (int)(dmbHeader->bxn12()) % 256);
00450
00451 if (getCSCHisto(h::CSC_ALCT_NUMBER_RATE, crateID, dmbID, mo)) {
00452 mo->Fill(alctsDatas.size());
00453 int nALCT = (int)mo->GetBinContent((int)(alctsDatas.size() + 1));
00454 if (getCSCHisto(h::CSC_ALCT_NUMBER_EFFICIENCY, crateID, dmbID, mo))
00455 mo->SetBinContent((int)(alctsDatas.size() + 1), (float)(nALCT) / (float)(DMBEvents) * 100.0);
00456 }
00457
00458 if (getCSCHisto(h::CSC_ALCT_WORD_COUNT, crateID, dmbID, mo)) mo->Fill((int)(alctTrailer->wordCount()));
00459
00462 if (alctsDatas.size() == 2) {
00463 if (getCSCHisto(h::CSC_ALCT1_VS_ALCT0_KEYWG, crateID, dmbID, mo))
00464 mo->Fill(alctsDatas[0].getKeyWG(),alctsDatas[1].getKeyWG());
00465 }
00466
00467 MonitorObject* mo_CSC_ALCT0_BXN_mean = 0;
00468 getEMUHisto(h::EMU_CSC_ALCT0_BXN_MEAN, mo_CSC_ALCT0_BXN_mean);
00469
00470 MonitorObject* mo_CSC_ALCT0_BXN_rms = 0;
00471 getEMUHisto(h::EMU_CSC_ALCT0_BXN_RMS, mo_CSC_ALCT0_BXN_rms);
00472
00473 MonitorObject* mo_CSC_Plus_endcap_ALCT0_dTime = 0;
00474 getEMUHisto(h::EMU_CSC_ALCT0_ENDCAP_PLUS_DTIME, mo_CSC_Plus_endcap_ALCT0_dTime);
00475
00476 MonitorObject* mo_CSC_Minus_endcap_ALCT0_dTime = 0;
00477 getEMUHisto(h::EMU_CSC_ALCT0_ENDCAP_MINUS_DTIME, mo_CSC_Minus_endcap_ALCT0_dTime);
00478
00479 for (uint32_t lct = 0; lct < alctsDatas.size(); lct++) {
00480
00482 if (lct >= 2) continue;
00483
00484 if (getCSCHisto(h::CSC_ALCTXX_KEYWG, crateID, dmbID, lct, mo)) {
00485 mo->Fill(alctsDatas[lct].getKeyWG());
00486 }
00487
00488 if(lct == 0) alct_keywg = alctsDatas[lct].getKeyWG();
00489
00490 int alct_dtime = 0;
00491 if (fwVersion == 2007) {
00492 alct_dtime = alctsDatas[lct].getBX();
00493 } else {
00494
00495 alct_dtime = (int) (alctsDatas[lct].getBX() - (alctHeader->BXNCount()&0x1F));
00496 }
00497
00498 if (getCSCHisto(h::CSC_ALCTXX_DTIME, crateID, dmbID, lct, mo)) {
00499
00500 if(alct_dtime < -16) {
00501 mo->Fill(alct_dtime + 32);
00502 } else {
00503 if(alct_dtime >= 16) mo->Fill(alct_dtime - 32);
00504 else mo->Fill(alct_dtime);
00505 }
00506
00507 mo->SetAxisRange(0.1, 1.1 * (1.0 + mo->GetBinContent(mo->GetMaximumBin())), "Y");
00508
00509 double dTime_mean = mo->getTH1()->GetMean();
00510 double dTime_rms = mo->getTH1()->GetRMS();
00511
00512
00513 if (lct == 0) {
00514 if (cid.endcap() == 1) {
00515 if (mo_CSC_Plus_endcap_ALCT0_dTime) mo_CSC_Plus_endcap_ALCT0_dTime->Fill(alct_dtime);
00516 }
00517 if (cid.endcap() == 2) {
00518 if (mo_CSC_Minus_endcap_ALCT0_dTime) mo_CSC_Minus_endcap_ALCT0_dTime->Fill(alct_dtime);
00519 }
00520 if (cscPosition && cscType && mo_CSC_ALCT0_BXN_mean) {
00521 mo_CSC_ALCT0_BXN_mean->SetBinContent(cscPosition, cscType + 1, dTime_mean);
00522 }
00523 if (cscPosition && cscType && mo_CSC_ALCT0_BXN_rms) {
00524 mo_CSC_ALCT0_BXN_rms->SetBinContent(cscPosition, cscType + 1, dTime_rms);
00525 }
00526 }
00527
00528 }
00529
00530 if (getCSCHisto(h::CSC_ALCTXX_DTIME_VS_KEYWG, crateID, dmbID, lct, mo)) {
00531 if(alct_dtime < -16) {
00532 mo->Fill(alctsDatas[lct].getKeyWG(), alct_dtime + 32);
00533 } else {
00534 if(alct_dtime >= 16) mo->Fill(alctsDatas[lct].getKeyWG(), alct_dtime - 32);
00535 else mo->Fill(alctsDatas[lct].getKeyWG(), alct_dtime);
00536 }
00537 }
00538
00539 if (getCSCHisto(h::CSC_ALCTXX_DTIME_PROFILE, crateID, dmbID, lct, mo)) {
00540 if(alct_dtime < -16) {
00541 mo->Fill(alctsDatas[lct].getKeyWG(), alct_dtime + 32);
00542 } else {
00543 if (alct_dtime >= 16) mo->Fill(alctsDatas[lct].getKeyWG(), alct_dtime - 32);
00544 else mo->Fill(alctsDatas[lct].getKeyWG(), alct_dtime);
00545 }
00546 }
00547
00548 int alct_bxn = alctsDatas[lct].getBX();
00549 if (fwVersion == 2007) {
00550 alct_bxn = (alct_bxn + alctHeader->BXNCount())&0x1F;
00551 }
00552
00553 if (getCSCHisto(h::CSC_ALCTXX_BXN, crateID, dmbID, lct, mo)) mo->Fill(alct_bxn);
00554
00555 if (getCSCHisto(h::CSC_ALCTXX_QUALITY, crateID, dmbID, lct, mo)) mo->Fill(alctsDatas[lct].getKeyWG(), alctsDatas[lct].getQuality());
00556
00557 if (mo_EventDisplay) {
00558 mo_EventDisplay->SetBinContent(2, alctsDatas[lct].getKeyWG(), alct_bxn + 1 );
00559 mo_EventDisplay->SetBinContent(3, alctsDatas[lct].getKeyWG(), alctsDatas[lct].getQuality());
00560 }
00561
00562 if (getCSCHisto(h::CSC_ALCTXX_QUALITY_DISTR, crateID, dmbID, lct, mo)) {
00563 mo->Fill(alctsDatas[lct].getQuality());
00564 if (lct == 0) {
00565 MonitorObject* mo1 = 0;
00566 if (cscType && cscPosition && getEMUHisto(h::EMU_CSC_ALCT0_QUALITY, mo1)) {
00567 mo1->SetBinContent(cscPosition, cscType + 1, mo->getTH1()->GetMean());
00568 }
00569 }
00570 }
00571
00572 if (getCSCHisto(h::CSC_ALCTXX_QUALITY_PROFILE, crateID, dmbID, lct, mo)) mo->Fill(alctsDatas[lct].getKeyWG(), alctsDatas[lct].getQuality());
00573
00574 if (getCSCHisto(h::CSC_ALCTXX_PATTERN, crateID, dmbID, lct, mo)) {
00575 int pattern = (alctsDatas[lct].getAccelerator() << 1) + alctsDatas[lct].getCollisionB();
00576 int keywg = alctsDatas[lct].getKeyWG();
00577 mo->Fill(keywg, pattern );
00578 }
00579
00580 if (getCSCHisto(h::CSC_ALCTXX_PATTERN_DISTR, crateID, dmbID, lct, mo)) {
00581 int pattern = (alctsDatas[lct].getAccelerator()<<1) + alctsDatas[lct].getCollisionB();
00582 mo->Fill(pattern);
00583 }
00584
00585 }
00586
00587 int NumberOfLayersWithHitsInALCT = 0;
00588 int NumberOfWireGroupsWithHitsInALCT = 0;
00589
00590 if (alctData) {
00591
00592 MonitorObject* mo_AFEB_RawHits_TimeBins = 0;
00593 getCSCHisto(h::CSC_CFEB_AFEB_RAWHITS_TIMEBINS, crateID, dmbID, mo_AFEB_RawHits_TimeBins);
00594
00595 MonitorObject* mo_CSC_Plus_endcap_AFEB_RawHits_Time = 0;
00596 getEMUHisto(h::EMU_CSC_AFEB_ENDCAP_PLUS_RAWHITS_TIME, mo_CSC_Plus_endcap_AFEB_RawHits_Time);
00597
00598 MonitorObject* mo_CSC_Minus_endcap_AFEB_RawHits_Time = 0;
00599 getEMUHisto(h::EMU_CSC_AFEB_ENDCAP_MINUS_RAWHITS_TIME, mo_CSC_Minus_endcap_AFEB_RawHits_Time);
00600
00601 MonitorObject* mo_CSC_AFEB_RawHits_Time_mean = 0;
00602 getEMUHisto(h::EMU_CSC_AFEB_RAWHITS_TIME_MEAN, mo_CSC_AFEB_RawHits_Time_mean);
00603
00604 MonitorObject* mo_CSC_AFEB_RawHits_Time_rms = 0;
00605 getEMUHisto(h::EMU_CSC_AFEB_RAWHITS_TIME_RMS, mo_CSC_AFEB_RawHits_Time_rms);
00606
00607 for (int nLayer = 1; nLayer <= 6; nLayer++) {
00608
00609 int wg_previous = -1;
00610 int tbin_previous = -1;
00611 bool CheckLayerALCT = true;
00612
00613 std::vector<CSCWireDigi> wireDigis = alctData->wireDigis(nLayer);
00614 for (std::vector<CSCWireDigi>::iterator wireDigisItr = wireDigis.begin(); wireDigisItr != wireDigis.end(); ++wireDigisItr) {
00615
00616 int wg = wireDigisItr->getWireGroup();
00618 std::vector<int> tbins = wireDigisItr->getTimeBinsOn();
00619 int tbin = wireDigisItr->getTimeBin();
00620
00621 if (mo_EventDisplay) {
00622 mo_EventDisplay->SetBinContent(nLayer + 3, wg - 1, tbin + 1);
00623 setEmuEventDisplayBit(mo_Emu_EventDisplay_Anode, glChamberIndex, wg - 1, nLayer - 1);
00624 setEmuEventDisplayBit(mo_Emu_EventDisplay_XY, glChamberIndex, wg - 1, nLayer - 1);
00625 }
00626
00627 if (CheckLayerALCT) {
00628 NumberOfLayersWithHitsInALCT = NumberOfLayersWithHitsInALCT + 1;
00629 CheckLayerALCT = false;
00630 }
00631
00632 for (uint32_t n = 0; n < tbins.size(); n++) {
00633
00634 tbin = tbins[n];
00635 if(wg != wg_previous || (tbin != tbin_previous + 1 && tbin != tbin_previous - 1) ) {
00636
00637 if (getCSCHisto(h::CSC_ALCTTIME_LYXX, crateID, dmbID, nLayer, mo)) mo->Fill(wg - 1, tbin);
00638
00639 if (getCSCHisto(h::CSC_ALCTTIME_LYXX_PROFILE, crateID, dmbID, nLayer, mo)) mo->Fill(wg - 1, tbin);
00640
00641 if (mo_AFEB_RawHits_TimeBins) mo_AFEB_RawHits_TimeBins->Fill(tbin);
00642
00643 if (cid.endcap() == 1) {
00644 if (mo_CSC_Plus_endcap_AFEB_RawHits_Time) mo_CSC_Plus_endcap_AFEB_RawHits_Time->Fill(tbin);
00645 }
00646 if (cid.endcap() == 2) {
00647 if (mo_CSC_Minus_endcap_AFEB_RawHits_Time) mo_CSC_Minus_endcap_AFEB_RawHits_Time->Fill(tbin);
00648 }
00649
00650 if (getCSCHisto(h::CSC_ALCT_LYXX_RATE, crateID, dmbID, nLayer, mo)) {
00651 mo->Fill(wg - 1);
00652 int number_wg = (int)(mo->GetBinContent(wg));
00653 Double_t Number_of_entries_ALCT = mo->GetEntries();
00654 if (getCSCHisto(h::CSC_ALCT_LYXX_EFFICIENCY, crateID, dmbID, nLayer, mo)) {
00655 mo->SetBinContent(wg, ((float) number_wg));
00656 if((Double_t)(DMBEvents) > 0.0) {
00657 mo->SetNormFactor(100.0*Number_of_entries_ALCT/(Double_t)(DMBEvents));
00658 } else {
00659 mo->SetNormFactor(100.0);
00660 }
00661 mo->SetEntries((int)DMBEvents);
00662 }
00663 }
00664 }
00665 if(wg != wg_previous) {
00666 NumberOfWireGroupsWithHitsInALCT = NumberOfWireGroupsWithHitsInALCT + 1;
00667 }
00668
00669 wg_previous = wg;
00670 tbin_previous = tbin;
00671 }
00672 }
00673
00674
00675 if (mo_AFEB_RawHits_TimeBins) {
00676
00677 double rawhits_time_mean = mo_AFEB_RawHits_TimeBins->getTH1()->GetMean();
00678 double rawhits_time_rms = mo_AFEB_RawHits_TimeBins->getTH1()->GetRMS();
00679
00680 if (cscType && cscPosition && mo_CSC_AFEB_RawHits_Time_mean) {
00681 mo_CSC_AFEB_RawHits_Time_mean->SetBinContent(cscPosition, cscType + 1, rawhits_time_mean);
00682 }
00683
00684 if (cscType && cscPosition && mo_CSC_AFEB_RawHits_Time_rms) {
00685 mo_CSC_AFEB_RawHits_Time_rms->SetBinContent(cscPosition, cscType + 1, rawhits_time_rms);
00686 }
00687
00688 }
00689
00690 }
00691
00692 } else {
00693 LOG_ERROR << cscTag << " Can not unpack Anode Data";
00694 }
00695
00696 if (getCSCHisto(h::CSC_ALCT_NUMBER_OF_LAYERS_WITH_HITS, crateID, dmbID, mo)) {
00697 mo->Fill(NumberOfLayersWithHitsInALCT);
00698 MonitorObject* mo1 = 0;
00699 if (cscType && cscPosition && getEMUHisto(h::EMU_CSC_ALCT_PLANES_WITH_HITS, mo1)) {
00700 mo1->SetBinContent(cscPosition, cscType + 1, mo->getTH1()->GetMean());
00701 }
00702 }
00703
00704 if (getCSCHisto(h::CSC_ALCT_NUMBER_OF_WIREGROUPS_WITH_HITS, crateID, dmbID, mo)) mo->Fill(NumberOfWireGroupsWithHitsInALCT);
00705
00706 } else {
00707 LOG_ERROR << cscTag << " Can not unpack ALCT Header or/and Trailer";
00708 }
00709 } else {
00712 if (getCSCHisto(h::CSC_ALCT_NUMBER_RATE, crateID, dmbID, mo)) {
00713 mo->Fill(0);
00714 int nALCT = (int)mo->GetBinContent(1);
00715 if (getCSCHisto(h::CSC_ALCT_NUMBER_EFFICIENCY, crateID, dmbID, mo))
00716 mo->SetBinContent(1, (float)(nALCT) / (float)(DMBEvents) * 100.0);
00717 }
00718
00719 if ((alct_dav > 0) && (getCSCHisto(h::CSC_DMB_FEB_UNPACKED_VS_DAV, crateID, dmbID, mo))) {
00720 mo->Fill(0.0, 1.0);
00721 }
00722 }
00723
00725 if(data.nclct() && data.nalct()) {
00726
00727 CSCALCTHeader* alctHeader = data.alctHeader();
00728
00729 if (alctHeader) {
00730 std::vector<CSCALCTDigi> alctsDatasTmp = alctHeader->ALCTDigis();
00731 std::vector<CSCALCTDigi> alctsDatas;
00732
00733 for (uint32_t lct = 0; lct < alctsDatasTmp.size(); lct++) {
00734 if (alctsDatasTmp[lct].isValid())
00735 alctsDatas.push_back(alctsDatasTmp[lct]);
00736 }
00737
00738 CSCTMBData* tmbData = data.tmbData();
00739 if (tmbData) {
00740 CSCTMBHeader* tmbHeader = tmbData->tmbHeader();
00741 if (tmbHeader) {
00743 if (getCSCHisto(h::CSC_TMB_BXN_VS_ALCT_BXN, crateID, dmbID, mo))
00744 mo->Fill( ((int)(alctHeader->BXNCount())) % 256, ((int)(tmbHeader->BXNCount())) % 256 );
00745
00746 if (getCSCHisto(h::CSC_TMB_ALCT_BXN_DIFF, crateID, dmbID, mo)) {
00747 int clct_alct_bxn_diff = (int)(alctHeader->BXNCount() - tmbHeader->BXNCount());
00748 if(clct_alct_bxn_diff < -2048) mo->Fill(clct_alct_bxn_diff + 4096);
00749 else {
00750 if(clct_alct_bxn_diff > 2048) mo->Fill(clct_alct_bxn_diff - 4096);
00751 else mo->Fill(clct_alct_bxn_diff);
00752 }
00753 mo->SetAxisRange(0.1, 1.1*(1.0+mo->GetBinContent(mo->GetMaximumBin())), "Y");
00754 }
00755
00756 if (getCSCHisto(h::CSC_TMB_L1A_VS_ALCT_L1A, crateID, dmbID, mo))
00757 mo->Fill((int)(alctHeader->L1Acc()%256),(int)(tmbHeader->L1ANumber()%256));
00758
00759 if (getCSCHisto(h::CSC_TMB_ALCT_L1A_DIFF, crateID, dmbID, mo)) {
00760 int clct_alct_l1a_diff = (int)(tmbHeader->L1ANumber() - alctHeader->L1Acc());
00761 if(clct_alct_l1a_diff < -2048) mo->Fill(clct_alct_l1a_diff + 4096);
00762 else {
00763 if(clct_alct_l1a_diff > 2048) mo->Fill(clct_alct_l1a_diff - 4096);
00764 else mo->Fill(clct_alct_l1a_diff);
00765 }
00766 mo->SetAxisRange(0.1, 1.1*(1.0+mo->GetBinContent(mo->GetMaximumBin())), "Y");
00767 }
00768 } else {
00769 LOG_ERROR << cscTag << " Can not unpack TMB Header";
00770 }
00771
00772 } else {
00773 LOG_ERROR << cscTag << " Can not unpack TMB Data";
00774 }
00775 } else {
00776 LOG_ERROR << cscTag << " Can not unpack ALCT Header";
00777 }
00778 }
00779
00781 if (data.nclct()) {
00782
00785 CSCTMBData* tmbData = data.tmbData();
00786 if (tmbData) {
00787
00788 CSCTMBHeader* tmbHeader = tmbData->tmbHeader();
00789 CSCTMBTrailer* tmbTrailer = tmbData->tmbTrailer();
00790
00791 if (tmbHeader && tmbTrailer) {
00792
00793 CSCCLCTData* clctData = data.clctData();
00794
00795 std::vector<CSCCLCTDigi> clctsDatasTmp = tmbHeader->CLCTDigis(cid.rawId());
00796 std::vector<CSCCLCTDigi> clctsDatas;
00797
00798 for (uint32_t lct = 0; lct < clctsDatasTmp.size(); lct++) {
00799 if (clctsDatasTmp[lct].isValid()) clctsDatas.push_back(clctsDatasTmp[lct]);
00800 }
00801
00802 FEBunpacked = FEBunpacked +1;
00803 tmb_unpacked = 1;
00804
00805 if (getCSCHisto(h::CSC_ALCT_MATCH_TIME, crateID, dmbID, mo)) {
00806
00807 mo->Fill(tmbHeader->ALCTMatchTime());
00808 double alct_match_mean = mo->getTH1()->GetMean();
00809 double alct_match_rms = mo->getTH1()->GetRMS();
00810 MonitorObject* mo1 = 0;
00811
00812 if (cid.endcap() == 1) {
00813 if (cscType && cscPosition && getEMUHisto(h::EMU_CSC_ENDCAP_PLUS_ALCT_CLCT_MATCH_TIME, mo1)) {
00814 mo1->Fill(tmbHeader->ALCTMatchTime());
00815 }
00816 }
00817
00818 if (cid.endcap() == 2) {
00819 if (cscType && cscPosition && getEMUHisto(h::EMU_CSC_ENDCAP_MINUS_ALCT_CLCT_MATCH_TIME, mo1)) {
00820 mo1->Fill(tmbHeader->ALCTMatchTime());
00821 }
00822 }
00823
00824 if (cscType && cscPosition && getEMUHisto(h::EMU_CSC_ALCT_CLCT_MATCH_MEAN, mo1)) {
00825 mo1->SetBinContent(cscPosition, cscType + 1, alct_match_mean);
00826 }
00827
00828 if (cscType && cscPosition && getEMUHisto(h::EMU_CSC_ALCT_CLCT_MATCH_RMS, mo1)) {
00829 mo1->SetBinContent(cscPosition, cscType + 1, alct_match_rms);
00830 }
00831
00832 }
00833
00834 if (getCSCHisto(h::CSC_LCT_MATCH_STATUS, crateID, dmbID, mo)) {
00835 if (tmbHeader->CLCTOnly()) mo->Fill(0.0,0.0);
00836 if (tmbHeader->ALCTOnly()) mo->Fill(0.0,1.0);
00837 if (tmbHeader->TMBMatch()) mo->Fill(0.0,2.0);
00838 }
00839
00840 if (getCSCHisto(h::CSC_LCT0_MATCH_BXN_DIFFERENCE, crateID, dmbID, mo)) mo->Fill(tmbHeader->Bxn0Diff());
00841 if (getCSCHisto(h::CSC_LCT1_MATCH_BXN_DIFFERENCE, crateID, dmbID, mo)) mo->Fill(tmbHeader->Bxn1Diff());
00842
00843 if ((tmb_dav > 0) && (getCSCHisto(h::CSC_DMB_FEB_UNPACKED_VS_DAV, crateID, dmbID, mo))) {
00844 mo->Fill(1.0, 0.0);
00845 }
00846
00848 if (getCSCHisto(h::CSC_CSC_RATE, crateID, dmbID, mo)) {
00849 mo->Fill(3);
00850 uint32_t CLCTEvent = (uint32_t)mo->GetBinContent(4);
00851 config->setChamberCounterValue(CLCT_TRIGGERS, crateID, dmbID, CLCTEvent);
00852 if (getCSCHisto(h::CSC_CSC_EFFICIENCY, crateID, dmbID, mo)) {
00853 if(config->getNEvents() > 0) {
00854 mo->SetBinContent(2,((float)CLCTEvent/(float)(DMBEvents)*100.0));
00855 mo->SetEntries(DMBEvents);
00856 }
00857 }
00858 }
00859
00860 if (getCSCHisto(h::CSC_CLCT_L1A, crateID, dmbID, mo)) mo->Fill(tmbHeader->L1ANumber());
00861
00863 if (getCSCHisto(h::CSC_CLCT_DMB_L1A_DIFF, crateID, dmbID, mo)) {
00864 int clct_dmb_l1a_diff = (int)((tmbHeader->L1ANumber() % 64)-dmbHeader->l1a() % 64);
00865 if (clct_dmb_l1a_diff != 0) L1A_out_of_sync = true;
00866 if(clct_dmb_l1a_diff < -32) mo->Fill(clct_dmb_l1a_diff + 64);
00867 else {
00868 if(clct_dmb_l1a_diff >= 32) mo->Fill(clct_dmb_l1a_diff - 64);
00869 else mo->Fill(clct_dmb_l1a_diff);
00870 }
00871 mo->SetAxisRange(0.1, 1.1*(1.0+mo->GetBinContent(mo->GetMaximumBin())), "Y");
00872 }
00873
00875 if (getCSCHisto(h::CSC_DMB_L1A_VS_CLCT_L1A, crateID, dmbID, mo)) mo->Fill(tmbHeader->L1ANumber()%256,dmbHeader->l1a());
00876
00877 if (getCSCHisto(h::CSC_CLCT_DMB_BXN_DIFF, crateID, dmbID, mo)) {
00878 int clct_dmb_bxn_diff = (int)(tmbHeader->BXNCount()%64-dmbHeader->bxn12()%64);
00879 if(clct_dmb_bxn_diff < -32) mo->Fill(clct_dmb_bxn_diff + 64);
00880 else {
00881 if(clct_dmb_bxn_diff >= 32) mo->Fill(clct_dmb_bxn_diff - 64);
00882 else mo->Fill(clct_dmb_bxn_diff);
00883 }
00884 mo->SetAxisRange(0.1, 1.1*(1.0+mo->GetBinContent(mo->GetMaximumBin())), "Y");
00885 }
00886
00887 if (getCSCHisto(h::CSC_CLCT_BXN, crateID, dmbID, mo)) mo->Fill((int)(tmbHeader->BXNCount()));
00888
00890 if (getCSCHisto(h::CSC_CLCT_BXN_VS_DMB_BXN, crateID, dmbID, mo)) mo->Fill(tmbHeader->BXNCount()%256,dmbHeader->bxn12()%256);
00891
00892 if (getCSCHisto(h::CSC_CLCT_NUMBER_RATE, crateID, dmbID, mo)) {
00893 mo->Fill(clctsDatas.size());
00894 int nCLCT = (int)mo->GetBinContent((int)(clctsDatas.size()+1));
00895 if (getCSCHisto(h::CSC_CLCT_NUMBER, crateID, dmbID, mo)) mo->SetBinContent((int)(clctsDatas.size() + 1), (float)(nCLCT) / (float)(DMBEvents) * 100.0);
00896 }
00897
00898 if (clctsDatas.size() == 1) {
00899 if (getCSCHisto(h::CSC_CLCT0_CLSSIFICATION, crateID, dmbID, mo)) {
00900 if (clctsDatas[0].getStripType()) mo->Fill(0.0);
00901 else mo->Fill(1.0);
00902 }
00903 }
00904
00905 if (clctsDatas.size() == 2) {
00906 if (getCSCHisto(h::CSC_CLCT1_VS_CLCT0_KEY_STRIP, crateID, dmbID, mo))
00907 mo->Fill(clctsDatas[0].getKeyStrip(),clctsDatas[1].getKeyStrip());
00908 if (getCSCHisto(h::CSC_CLCT0_CLCT1_CLSSIFICATION, crateID, dmbID, mo)) {
00909 if ( clctsDatas[0].getStripType() && clctsDatas[1].getStripType()) mo->Fill(0.0);
00910 if ( clctsDatas[0].getStripType() && !clctsDatas[1].getStripType()) mo->Fill(1.0);
00911 if (!clctsDatas[0].getStripType() && clctsDatas[1].getStripType()) mo->Fill(2.0);
00912 if (!clctsDatas[0].getStripType() && !clctsDatas[1].getStripType()) mo->Fill(3.0);
00913 }
00914 }
00915
00916 if (getCSCHisto(h::CSC_TMB_WORD_COUNT, crateID, dmbID, mo)) mo->Fill((int)(tmbTrailer->wordCount()));
00919 MonitorObject* mo_CSC_Plus_endcap_CLCT0_dTime = 0;
00920 getEMUHisto(h::EMU_CSC_ENDCAP_PLUS_CLCT0_DTIME, mo_CSC_Plus_endcap_CLCT0_dTime);
00921
00922 MonitorObject* mo_CSC_Minus_endcap_CLCT0_dTime = 0;
00923 getEMUHisto(h::EMU_CSC_ENDCAP_MINUS_CLCT0_DTIME, mo_CSC_Minus_endcap_CLCT0_dTime);
00924
00925 MonitorObject* mo_CSC_CLCT0_BXN_mean = 0;
00926 getEMUHisto(h::EMU_CSC_CLCT0_BXN_MEAN, mo_CSC_CLCT0_BXN_mean);
00927
00928 MonitorObject* mo_CSC_CLCT0_BXN_rms = 0;
00929
00930 for (uint32_t lct = 0; lct < clctsDatas.size(); lct++) {
00931
00932 if (getCSCHisto(h::CSC_CLCTXX_BXN, crateID, dmbID, lct, mo)) mo->Fill(clctsDatas[lct].getFullBX()%64);
00933
00934 int clct_dtime = clctsDatas[lct].getFullBX() - tmbHeader->BXNCount();
00935 if (clct_dtime > 0) {
00936 clct_dtime -= 3564;
00937 }
00938
00939 if (getCSCHisto(h::CSC_CLCTXX_DTIME, crateID, dmbID, lct, mo)) {
00940 int dTime = clct_dtime;
00941
00942
00943
00944
00945
00946
00947
00948
00949 mo->Fill(dTime);
00950 mo->SetAxisRange(0.1, 1.1 * (1.0 + mo->GetBinContent(mo->GetMaximumBin())), "Y");
00951
00952 double dTime_mean = mo->getTH1()->GetMean();
00953 double dTime_rms = mo->getTH1()->GetRMS();
00954
00955
00956 if (lct == 0) {
00957 if (cid.endcap() == 1) {
00958 if (mo_CSC_Plus_endcap_CLCT0_dTime) mo_CSC_Plus_endcap_CLCT0_dTime->Fill(dTime);
00959 }
00960 if (cid.endcap() == 2) {
00961 if (mo_CSC_Minus_endcap_CLCT0_dTime) mo_CSC_Minus_endcap_CLCT0_dTime->Fill(dTime);
00962 }
00963 if ( cscType && cscPosition && mo_CSC_CLCT0_BXN_mean) {
00964 mo_CSC_CLCT0_BXN_mean->SetBinContent(cscPosition, cscType + 1, dTime_mean);
00965 }
00966 if (cscType && cscPosition && mo_CSC_CLCT0_BXN_rms) {
00967 mo_CSC_CLCT0_BXN_rms->SetBinContent(cscPosition, cscType + 1, dTime_rms);
00968 }
00969 }
00970
00971 }
00972
00975 LOG_DEBUG << "LCT:" << lct << " Type:" << clctsDatas[lct].getStripType() << " Strip:" << clctsDatas[lct].getKeyStrip();
00976
00977 if (clctsDatas[lct].getStripType()) {
00978
00979 if (getCSCHisto(h::CSC_CLCTXX_KEYHALFSTRIP, crateID, dmbID, lct, mo))
00980 mo->Fill(clctsDatas[lct].getKeyStrip());
00981
00982 if (getCSCHisto(h::CSC_CLCTXX_DTIME_VS_HALF_STRIP, crateID, dmbID, lct, mo)) {
00983 mo->Fill((int)(clctsDatas[lct].getKeyStrip()), clct_dtime);
00984
00985
00986
00987
00988
00989
00990
00991
00992 }
00993
00994 if (getCSCHisto(h::CSC_CLCTXX_DTIME_PROFILE, crateID, dmbID, lct, mo)) {
00995 mo->Fill((int)(clctsDatas[lct].getKeyStrip()), clct_dtime);
00996
00997
00998
00999
01000
01001
01002
01003
01004 }
01005
01006 if (getCSCHisto(h::CSC_CLCTXX_HALF_STRIP_PATTERN, crateID, dmbID, lct, mo)) {
01007
01008 int pattern_clct = clctsDatas[lct].getPattern();
01012 double tbin = -1;
01013
01014 switch (pattern_clct) {
01015 case 0: tbin=0.; break;
01016 case 1: tbin=1.; break;
01017 case 2: tbin=2.; break;
01018 case 3: tbin=10.; break;
01019 case 4: tbin=3.; break;
01020 case 5: tbin=9.; break;
01021 case 6: tbin=4.; break;
01022 case 7: tbin=8.; break;
01023 case 8: tbin=5.; break;
01024 case 9: tbin=7.; break;
01025 case 10: tbin=6.; break;
01026 }
01027
01028 if (tbin >= 0) mo->Fill(clctsDatas[lct].getKeyStrip(), tbin);
01029
01030 MonitorObject* mo1 = 0;
01031 if (getCSCHisto(h::CSC_CLCT_HALF_STRIP_PATTERN_DISTR, crateID, dmbID, lct, mo1)) mo1->Fill(tbin);
01032
01033 }
01034
01035 if (getCSCHisto(h::CSC_CLCTXX_HALF_STRIP_QUALITY, crateID, dmbID, lct, mo))
01036 mo->Fill((int)(clctsDatas[lct].getKeyStrip()),(int)(clctsDatas[lct].getQuality()));
01037
01038 if (mo_EventDisplay) {
01039 mo_EventDisplay->SetBinContent(10, clctsDatas[lct].getKeyStrip(), clct_dtime);
01040 mo_EventDisplay->SetBinContent(11, clctsDatas[lct].getKeyStrip(), clctsDatas[lct].getQuality());
01041 }
01042
01043 if (getCSCHisto(h::CSC_CLCTXX_HALF_STRIP_QUALITY_DISTR, crateID, dmbID, lct, mo)) {
01044 mo->Fill((int)(clctsDatas[lct].getQuality()));
01045 if (lct == 0) {
01046 MonitorObject* mo1 = 0;
01047 if (cscType && cscPosition && getEMUHisto(h::EMU_CSC_CLCT0_QUALITY, mo1))
01048 mo1->SetBinContent(cscPosition, cscType + 1, mo->getTH1()->GetMean());
01049 }
01050 }
01051
01052 if (getCSCHisto(h::CSC_CLCTXX_HALF_STRIP_QUALITY_PROFILE, crateID, dmbID, lct, mo))
01053 mo->Fill((int)(clctsDatas[lct].getKeyStrip()), (int)(clctsDatas[lct].getQuality()));
01054
01055 } else {
01056
01057 LOG_INFO << "Entering block!";
01058
01059 if (getCSCHisto(h::CSC_CLCTXX_KEYDISTRIP, crateID, dmbID, lct, mo)) mo->Fill(clctsDatas[lct].getKeyStrip());
01060 else LOG_ERROR << "Not found h::CSC_CLCTXX_KEYDISTRIP = " << h::CSC_CLCTXX_KEYDISTRIP;
01061
01062 if(lct == 0) clct_kewdistrip = clctsDatas[lct].getKeyStrip();
01063
01064 if (getCSCHisto(h::CSC_CLCTXX_DTIME_VS_DISTRIP, crateID, dmbID, lct, mo)) {
01065 mo->Fill((int)(clctsDatas[lct].getKeyStrip()), clct_dtime);
01066
01067
01068
01069
01070
01071
01072
01073 }
01074
01075 if (getCSCHisto(h::CSC_CLCTXX_DISTRIP_PATTERN, crateID, dmbID, lct, mo)) {
01076 int pattern_clct = (int)((clctsDatas[lct].getPattern() >> 1) & 0x3);
01079 if(pattern_clct == 1) mo->Fill(clctsDatas[lct].getKeyStrip(), 7.0);
01080 if(pattern_clct == 3) mo->Fill(clctsDatas[lct].getKeyStrip(), 6.0);
01081 if(pattern_clct == 5) mo->Fill(clctsDatas[lct].getKeyStrip(), 5.0);
01082 if(pattern_clct == 7) mo->Fill(clctsDatas[lct].getKeyStrip(), 4.0);
01083 if(pattern_clct == 6) mo->Fill(clctsDatas[lct].getKeyStrip(), 3.0);
01084 if(pattern_clct == 4) mo->Fill(clctsDatas[lct].getKeyStrip(), 2.0);
01085 if(pattern_clct == 2) mo->Fill(clctsDatas[lct].getKeyStrip(), 1.0);
01086 if(pattern_clct == 0) mo->Fill(clctsDatas[lct].getKeyStrip(), 0.0);
01087 }
01088
01089 if (getCSCHisto(h::CSC_CLCTXX_DISTRIP_QUALITY, crateID, dmbID, lct, mo))
01090 mo->Fill((int)(clctsDatas[lct].getKeyStrip()),(int)(clctsDatas[lct].getQuality()));
01091
01092 if (getCSCHisto(h::CSC_CLCTXX_DISTRIP_QUALITY_PROFILE, crateID, dmbID, lct, mo))
01093 mo->Fill((int)(clctsDatas[lct].getKeyStrip()), (int)(clctsDatas[lct].getQuality()));
01094 }
01095 }
01096
01097 int N_CFEBs = 5;
01098
01099 int NumberOfLayersWithHitsInCLCT = 0;
01100 int NumberOfHalfStripsWithHitsInCLCT = 0;
01101
01102 if (clctData && clctData->check()) {
01103
01104 MonitorObject* mo_CFEB_Comparators_TimeSamples = 0;
01105 getCSCHisto(h::CSC_CFEB_COMPARATORS_TIMESAMPLES, crateID, dmbID, mo_CFEB_Comparators_TimeSamples);
01106
01107 MonitorObject* mo_CSC_Plus_endcap_CFEB_Comparators_Time = 0;
01108 getEMUHisto(h::EMU_CSC_ENDCAP_PLUS_CFEB_COMPARATORS_TIME, mo_CSC_Plus_endcap_CFEB_Comparators_Time);
01109
01110 MonitorObject* mo_CSC_Minus_endcap_CFEB_Comparators_Time = 0;
01111 getEMUHisto(h::EMU_CSC_ENDCAP_MINUS_CFEB_COMPARATORS_TIME, mo_CSC_Minus_endcap_CFEB_Comparators_Time);
01112
01113 MonitorObject* mo_CSC_CFEB_Comparators_Time_mean = 0;
01114 getEMUHisto(h::EMU_CSC_CFEB_COMPARATORS_TIME_MEAN, mo_CSC_CFEB_Comparators_Time_mean);
01115
01116 MonitorObject* mo_CSC_CFEB_Comparators_Time_rms = 0;
01117 getEMUHisto(h::EMU_CSC_CFEB_COMPARATORS_TIME_RMS, mo_CSC_CFEB_Comparators_Time_rms);
01118
01119 for(int nCFEB = 0; nCFEB < N_CFEBs; ++nCFEB) {
01120 for (int nLayer = 1; nLayer <= 6; nLayer++) {
01121
01122 int hstrip_previous = -1;
01123 int tbin_clct_previous = -1;
01124 bool CheckLayerCLCT = true;
01125
01126 std::vector<CSCComparatorDigi> compOutData = clctData->comparatorDigis(nLayer, nCFEB);
01127
01128 for (std::vector<CSCComparatorDigi>::iterator compOutDataItr = compOutData.begin(); compOutDataItr != compOutData.end(); ++compOutDataItr) {
01130 int hstrip = 2 * (compOutDataItr->getStrip() - 1) + compOutDataItr->getComparator();
01131 std::vector<int> tbins_clct = compOutDataItr->getTimeBinsOn();
01132 int tbin_clct = (int)compOutDataItr->getTimeBin();
01133
01134 if (mo_EventDisplay) {
01135 mo_EventDisplay->SetBinContent(nLayer + 11, hstrip, tbin_clct + 1);
01136 setEmuEventDisplayBit(mo_Emu_EventDisplay_Anode, glChamberIndex, 160 + hstrip, nLayer - 1);
01137 setEmuEventDisplayBit(mo_Emu_EventDisplay_XY, glChamberIndex, 160 + hstrip, nLayer - 1);
01138 }
01139
01140 if(CheckLayerCLCT) {
01141 NumberOfLayersWithHitsInCLCT = NumberOfLayersWithHitsInCLCT + 1;
01142 CheckLayerCLCT = false;
01143 }
01144
01145 for (uint32_t n=0; n < tbins_clct.size(); n++) {
01146 tbin_clct = tbins_clct[n];
01147 if(hstrip != hstrip_previous || (tbin_clct != tbin_clct_previous + 1 && tbin_clct != tbin_clct_previous - 1) ) {
01148
01149 if (getCSCHisto(h::CSC_CLCTTIME_LYXX, crateID, dmbID, nLayer, mo)) mo->Fill(hstrip, tbin_clct);
01150
01151 if (mo_CFEB_Comparators_TimeSamples) mo_CFEB_Comparators_TimeSamples->Fill(tbin_clct);
01152
01153 if (cid.endcap() == 1) {
01154 if (mo_CSC_Plus_endcap_CFEB_Comparators_Time) mo_CSC_Plus_endcap_CFEB_Comparators_Time->Fill(tbin_clct);
01155 }
01156
01157 if (cid.endcap() == 2) {
01158 if (mo_CSC_Minus_endcap_CFEB_Comparators_Time) mo_CSC_Minus_endcap_CFEB_Comparators_Time->Fill(tbin_clct);
01159 }
01160
01161 if (getCSCHisto(h::CSC_CLCTTIME_LYXX_PROFILE, crateID, dmbID, nLayer, mo)) mo->Fill(hstrip, tbin_clct);
01162
01163 if (getCSCHisto(h::CSC_CLCT_LYXX_RATE, crateID, dmbID, nLayer, mo)) {
01164
01165 mo->Fill(hstrip);
01166
01167 double number_hstrip = mo->GetBinContent(hstrip+1);
01168 double Number_of_entries_CLCT = mo->GetEntries();
01169
01170 if (getCSCHisto(h::CSC_CLCT_LYXX_EFFICIENCY, crateID, dmbID, nLayer, mo)) {
01171 mo->SetBinContent(hstrip + 1, number_hstrip);
01172 if(DMBEvents > 0) {
01173 double norm = (100.0 * Number_of_entries_CLCT) / ((double)(DMBEvents));
01175 mo->SetNormFactor(norm);
01176 } else {
01177 mo->SetNormFactor(100.0);
01178 }
01179 mo->SetEntries(DMBEvents);
01180 }
01181 }
01182 }
01183
01184 if(hstrip != hstrip_previous) {
01185 NumberOfHalfStripsWithHitsInCLCT = NumberOfHalfStripsWithHitsInCLCT + 1;
01186 }
01187 hstrip_previous = hstrip;
01188 tbin_clct_previous = tbin_clct;
01189 }
01190 }
01191 }
01192 }
01193
01194 if (mo_CFEB_Comparators_TimeSamples) {
01195
01196 double comps_time_mean = mo_CFEB_Comparators_TimeSamples->getTH1()->GetMean();
01197 double comps_time_rms = mo_CFEB_Comparators_TimeSamples->getTH1()->GetRMS();
01198
01199 if ( cscType && cscPosition && mo_CSC_CFEB_Comparators_Time_mean) {
01200 mo_CSC_CFEB_Comparators_Time_mean->SetBinContent(cscPosition, cscType + 1, comps_time_mean);
01201 }
01202 if ( cscType && cscPosition && mo_CSC_CFEB_Comparators_Time_rms) {
01203 mo_CSC_CFEB_Comparators_Time_rms->SetBinContent(cscPosition, cscType + 1, comps_time_rms);
01204 }
01205
01206 }
01207
01208 } else {
01209 LOG_ERROR << cscTag << " Can not unpack CLCT Data";
01210 }
01211
01212 if (getCSCHisto(h::CSC_CLCT_NUMBER_OF_LAYERS_WITH_HITS, crateID, dmbID, mo)) {
01213 mo->Fill(NumberOfLayersWithHitsInCLCT);
01214 MonitorObject* mo1 = 0;
01215 if (cscType && cscPosition && getEMUHisto(h::EMU_CSC_CLCT_PLANES_WITH_HITS, mo1)) {
01216 mo1->SetBinContent(cscPosition, cscType + 1, mo->getTH1()->GetMean());
01217 }
01218 }
01219
01220 if (getCSCHisto(h::CSC_CLCT_NUMBER_OF_HALFSTRIPS_WITH_HITS, crateID, dmbID, mo))
01221 mo->Fill(NumberOfHalfStripsWithHitsInCLCT);
01222 } else {
01223 LOG_ERROR << cscTag << " Can not unpack TMB Header or/and Trailer";
01224 }
01225 } else {
01226 LOG_ERROR << cscTag << " Can not unpack TMB Data";
01227 }
01228
01229 } else {
01232 if (getCSCHisto(h::CSC_CLCT_NUMBER_RATE, crateID, dmbID, mo)) {
01233 mo->Fill(0);
01234 int nCLCT = (int)mo->GetBinContent(1);
01235 if (getCSCHisto(h::CSC_CLCT_NUMBER, crateID, dmbID, mo)) mo->SetBinContent(1, (float)(nCLCT) / (float)(DMBEvents) * 100.0);
01236 }
01237 if ((tmb_dav > 0) && (getCSCHisto(h::CSC_DMB_FEB_UNPACKED_VS_DAV, crateID, dmbID, mo))) {
01238 mo->Fill(1.0, 1.0);
01239 }
01240 }
01241
01243 int NumberOfUnpackedCFEBs = 0;
01244 const int N_CFEBs = 5, N_Samples = 16, N_Layers = 6, N_Strips = 16;
01245 int ADC = 0, OutOffRange, Threshold = 30;
01247
01248
01249
01250 int Pedestal[5][6][16];
01251 std::pair<int,int> CellPeak[5][6][16];
01252 memset(CellPeak, 0, sizeof(CellPeak));
01253
01254
01255 bool CheckCFEB = true;
01257 float Clus_Sum_Charge;
01258 int TrigTime, L1APhase, UnpackedTrigTime, LCTPhase, SCA_BLK, NmbTimeSamples;
01260 int FreeCells, LCT_Pipe_Empty, LCT_Pipe_Full, LCT_Pipe_Count, L1_Pipe_Empty, L1_Pipe_Full, Buffer_Count;
01263 bool CheckThresholdStripInTheLayer[6][80];
01264 for(int i=0; i<6; i++) {
01265 for(int j = 0; j < 80; j++) CheckThresholdStripInTheLayer[i][j] = true;
01266 }
01267
01268 bool CheckOutOffRangeStripInTheLayer[6][80];
01269 for(int i=0; i<6; i++) {
01270 for(int j=0; j<80; j++) CheckOutOffRangeStripInTheLayer[i][j] = true;
01271 }
01272
01274 float cscdata[N_CFEBs * 16][N_Samples][N_Layers];
01276 int SCABlockData[N_CFEBs * 16][N_Samples][N_Layers];
01277 memset(cscdata, 0, sizeof(cscdata));
01279 memset(SCABlockData, 0, sizeof(SCABlockData));
01282 char hbuf[255];
01283 memset(hbuf, 0, sizeof(hbuf));
01284
01285 MonitorObject* mo_CFEB_SCA_CellPeak_Time = 0;
01286 getCSCHisto(h::CSC_CFEB_SCA_CELLPEAK_TIME, crateID, dmbID, mo_CFEB_SCA_CellPeak_Time);
01287
01288 MonitorObject* mo_CSC_Plus_endcap_CFEB_SCA_CellPeak_Time = 0;
01289 getEMUHisto(h::EMU_CSC_PLUS_ENDCAP_CFEB_SCA_CELLPEAK_TIME, mo_CSC_Plus_endcap_CFEB_SCA_CellPeak_Time);
01290
01291 MonitorObject* mo_CSC_Minus_endcap_CFEB_SCA_CellPeak_Time = 0;
01292 getEMUHisto(h::EMU_CSC_MINUS_ENDCAP_CFEB_SCA_CELLPEAK_TIME, mo_CSC_Minus_endcap_CFEB_SCA_CellPeak_Time);
01293
01294 MonitorObject* mo_CSC_CFEB_SCA_CellPeak_Time_mean = 0;
01295 getEMUHisto(h::EMU_CSC_CFEB_SCA_CELLPEAK_TIME_MEAN, mo_CSC_CFEB_SCA_CellPeak_Time_mean);
01296
01297 MonitorObject* mo_CSC_CFEB_SCA_CellPeak_Time_rms = 0;
01298 getEMUHisto(h::EMU_CSC_CFEB_SCA_CELLPEAK_TIME_RMS, mo_CSC_CFEB_SCA_CellPeak_Time_rms);
01299
01300 for(int nCFEB = 0; nCFEB < N_CFEBs; ++nCFEB) {
01301
01302
01303 if (data.cfebData(nCFEB) !=0) {
01304 if (!data.cfebData(nCFEB)->check()) continue;
01306 FEBunpacked = FEBunpacked +1;
01307 NumberOfUnpackedCFEBs = NumberOfUnpackedCFEBs + 1;
01308 cfeb_unpacked = 1;
01309 if(CheckCFEB == true){
01310 if (getCSCHisto(h::CSC_CSC_RATE, crateID, dmbID, mo)) {
01311 mo->Fill(4);
01312 uint32_t CFEBEvent = (uint32_t)mo->GetBinContent(5);
01313 config->setChamberCounterValue(CFEB_TRIGGERS, crateID, dmbID, CFEBEvent);
01314 if (getCSCHisto(h::CSC_CSC_EFFICIENCY, crateID, dmbID, mo)) {
01315 if(config->getNEvents() > 0) {
01316 mo->SetBinContent(3, ((float)CFEBEvent/(float)(DMBEvents)*100.0));
01317 mo->SetEntries((int)DMBEvents);
01318 }
01319 }
01320 }
01321
01322 if ((cfeb_dav2 > 0) && (getCSCHisto(h::CSC_DMB_FEB_UNPACKED_VS_DAV, crateID, dmbID, mo))) {
01323 mo->Fill(2.0, 0.0);
01324 }
01325 CheckCFEB = false;
01326 }
01328 NmbTimeSamples= (data.cfebData(nCFEB))->nTimeSamples();
01334 MonitorObject* mo_CFEB_SCA_Block_Occupancy = 0;
01335 getCSCHisto(h::CSC_CFEBXX_SCA_BLOCK_OCCUPANCY, crateID, dmbID, nCFEB + 1, mo_CFEB_SCA_Block_Occupancy);
01336 MonitorObject* mo_CFEB_Free_SCA_Cells = 0;
01337 getCSCHisto(h::CSC_CFEBXX_FREE_SCA_CELLS, crateID, dmbID, nCFEB + 1, mo_CFEB_Free_SCA_Cells);
01338 MonitorObject* mo_CFEB_SCA_Blocks_Locked_by_LCTs = 0;
01339 getCSCHisto(h::CSC_CFEBXX_SCA_BLOCKS_LOCKED_BY_LCTS, crateID, dmbID, nCFEB + 1, mo_CFEB_SCA_Blocks_Locked_by_LCTs);
01340 MonitorObject* mo_CFEB_SCA_Blocks_Locked_by_LCTxL1 = 0;
01341 getCSCHisto(h::CSC_CFEBXX_SCA_BLOCKS_LOCKED_BY_LCTXL1, crateID, dmbID, nCFEB + 1, mo_CFEB_SCA_Blocks_Locked_by_LCTxL1);
01342 MonitorObject* mo_CFEB_DMB_L1A_diff = 0;
01343 getCSCHisto(h::CSC_CFEBXX_DMB_L1A_DIFF, crateID, dmbID, nCFEB + 1, mo_CFEB_DMB_L1A_diff);
01344
01347 for(int nLayer = 1; nLayer <= N_Layers; ++nLayer) {
01349 MonitorObject * mo_CFEB_Out_Off_Range_Strips = 0;
01350 getCSCHisto(h::CSC_CFEB_OUT_OFF_RANGE_STRIPS_LYXX, crateID, dmbID, nLayer, mo_CFEB_Out_Off_Range_Strips);
01351 MonitorObject * mo_CFEB_Active_Samples_vs_Strip = 0;
01352 getCSCHisto(h::CSC_CFEB_ACTIVE_SAMPLES_VS_STRIP_LYXX, crateID, dmbID, nLayer, mo_CFEB_Active_Samples_vs_Strip);
01353 MonitorObject * mo_CFEB_Active_Samples_vs_Strip_Profile = 0;
01354 getCSCHisto(h::CSC_CFEB_ACTIVE_SAMPLES_VS_STRIP_LYXX_PROFILE, crateID, dmbID, nLayer, mo_CFEB_Active_Samples_vs_Strip_Profile);
01355 MonitorObject * mo_CFEB_ActiveStrips = 0;
01356 getCSCHisto(h::CSC_CFEB_ACTIVESTRIPS_LYXX, crateID, dmbID, nLayer, mo_CFEB_ActiveStrips);
01357 MonitorObject * mo_CFEB_SCA_Cell_Peak = 0;
01358 getCSCHisto(h::CSC_CFEB_SCA_CELL_PEAK_LY_XX, crateID, dmbID, nLayer, mo_CFEB_SCA_Cell_Peak);
01359
01360 MonitorObject * mo_CFEB_Pedestal_withEMV_Sample = 0;
01361 getCSCHisto(h::CSC_CFEB_PEDESTAL_WITHEMV_SAMPLE_01_LYXX, crateID, dmbID, nLayer, mo_CFEB_Pedestal_withEMV_Sample);
01362 MonitorObject * mo_CFEB_Pedestal_withRMS_Sample = 0;
01363 getCSCHisto(h::CSC_CFEB_PEDESTAL_WITHRMS_SAMPLE_01_LYXX, crateID, dmbID, nLayer, mo_CFEB_Pedestal_withRMS_Sample);
01364 MonitorObject * mo_CFEB_PedestalRMS_Sample = 0;
01365 getCSCHisto(h::CSC_CFEB_PEDESTALRMS_SAMPLE_01_LYXX, crateID, dmbID, nLayer, mo_CFEB_PedestalRMS_Sample);
01366
01367 for(int nSample = 0; nSample < NmbTimeSamples; ++nSample) {
01368
01369 if (timeSlice(data, nCFEB, nSample) == 0) {
01370 LOG_WARN << "CFEB" << nCFEB << " nSample: " << nSample << " - B-Word";
01371 continue;
01372 }
01373
01374 if (mo_CFEB_DMB_L1A_diff && !fCloseL1As ) {
01376 int cfeb_dmb_l1a_diff = (int)((timeSlice(data, nCFEB, nSample)->get_L1A_number())-dmbHeader->l1a()%64);
01377 if (cfeb_dmb_l1a_diff != 0) {
01378 L1A_out_of_sync = true;
01379 }
01380 if(cfeb_dmb_l1a_diff < -32) mo->Fill(cfeb_dmb_l1a_diff + 64);
01381 else {
01382 if(cfeb_dmb_l1a_diff >= 32) mo->Fill(cfeb_dmb_l1a_diff - 64);
01383 else mo_CFEB_DMB_L1A_diff->Fill(cfeb_dmb_l1a_diff);
01384 }
01385 mo_CFEB_DMB_L1A_diff->SetAxisRange(0.1, 1.1*(1.0+mo_CFEB_DMB_L1A_diff->GetBinContent(mo_CFEB_DMB_L1A_diff->GetMaximumBin())), "Y");
01386 }
01387
01390
01391
01392 TrigTime = (int)(timeSlice(data, nCFEB, nSample)->scaControllerWord(nLayer).trig_time);
01394 FreeCells = timeSlice(data, nCFEB, nSample)->get_n_free_sca_blocks();
01395 LCT_Pipe_Empty = timeSlice(data, nCFEB, nSample)->get_lctpipe_empty();
01396 LCT_Pipe_Full = timeSlice(data, nCFEB, nSample)->get_lctpipe_full();
01397 LCT_Pipe_Count = timeSlice(data, nCFEB, nSample)->get_lctpipe_count();
01398 L1_Pipe_Empty = timeSlice(data, nCFEB, nSample)->get_l1pipe_empty();
01399 L1_Pipe_Full = timeSlice(data, nCFEB, nSample)->get_l1pipe_full();
01401 Buffer_Count = timeSlice(data, nCFEB, nSample)->get_buffer_count();
01402
01403 SCA_BLK = (int)(timeSlice(data, nCFEB, nSample)->scaControllerWord(nLayer).sca_blk);
01407 for(int nStrip = 0; nStrip < N_Strips; ++nStrip) {
01408 SCABlockData[nCFEB*16+nStrip][nSample][nLayer-1] = SCA_BLK;
01410 }
01415 if (mo_CFEB_SCA_Block_Occupancy) mo_CFEB_SCA_Block_Occupancy->Fill(SCA_BLK);
01416
01419 if (mo_CFEB_Free_SCA_Cells) {
01420 if (timeSlice(data, nCFEB, nSample)->scaControllerWord(nLayer).sca_full == 1) mo_CFEB_Free_SCA_Cells->Fill(-1);
01421 mo_CFEB_Free_SCA_Cells->Fill(FreeCells);
01422 }
01423
01426 if (mo_CFEB_SCA_Blocks_Locked_by_LCTs) {
01427 if (LCT_Pipe_Empty == 1) mo_CFEB_SCA_Blocks_Locked_by_LCTs->Fill(-0.5);
01428 if (LCT_Pipe_Full == 1) mo_CFEB_SCA_Blocks_Locked_by_LCTs->Fill(16.5);
01429 mo_CFEB_SCA_Blocks_Locked_by_LCTs->Fill(LCT_Pipe_Count);
01430 }
01431
01434 if (mo_CFEB_SCA_Blocks_Locked_by_LCTxL1) {
01435 if (L1_Pipe_Empty == 1) mo_CFEB_SCA_Blocks_Locked_by_LCTxL1->Fill(-0.5);
01436 if (L1_Pipe_Full == 1) mo_CFEB_SCA_Blocks_Locked_by_LCTxL1->Fill(31.5);
01437 mo_CFEB_SCA_Blocks_Locked_by_LCTxL1->Fill(Buffer_Count);
01438 }
01439
01442 if(nSample == 0 && nLayer == 1) {
01443 TrigTime = (int)(timeSlice(data, nCFEB, nSample)->scaControllerWord(nLayer).trig_time);
01444 int k = 1;
01445 while (((TrigTime >> (k-1)) & 0x1) != 1 && k <= 8) {
01446 k = k + 1;
01447 }
01448 L1APhase = (int)((timeSlice(data, nCFEB, nSample)->scaControllerWord(nLayer).l1a_phase) & 0x1);
01449 UnpackedTrigTime = ((k << 1) & 0xE) + L1APhase;
01450
01451 if (getCSCHisto(h::CSC_CFEBXX_L1A_SYNC_TIME, crateID, dmbID, nCFEB + 1, mo))
01452 mo->Fill((int)UnpackedTrigTime);
01453 LCTPhase = (int)((timeSlice(data, nCFEB, nSample)->scaControllerWord(nLayer).lct_phase)&0x1);
01454
01455 if (getCSCHisto(h::CSC_CFEBXX_LCT_PHASE_VS_L1A_PHASE, crateID, dmbID, nCFEB + 1, mo))
01456 mo->Fill(LCTPhase, L1APhase);
01457
01460 if (getCSCHisto(h::CSC_CFEBXX_L1A_SYNC_TIME_VS_DMB, crateID, dmbID, nCFEB + 1, mo))
01461 mo->Fill((int)(dmbHeader->dmbCfebSync()), (int)UnpackedTrigTime);
01462
01463 if (getCSCHisto(h::CSC_CFEBXX_L1A_SYNC_TIME_DMB_DIFF, crateID, dmbID, nCFEB + 1, mo)) {
01464 int cfeb_dmb_L1A_sync_time = (int)(dmbHeader->dmbCfebSync()) - (int)UnpackedTrigTime;
01465 if(cfeb_dmb_L1A_sync_time < -8) mo->Fill(cfeb_dmb_L1A_sync_time+16);
01466 else {
01467 if(cfeb_dmb_L1A_sync_time >= 8) mo->Fill(cfeb_dmb_L1A_sync_time-16);
01468 else mo->Fill(cfeb_dmb_L1A_sync_time);
01469 }
01470 mo->SetAxisRange(0.1, 1.1*(1.0+mo->GetBinContent(mo->GetMaximumBin())), "Y");
01471 }
01472
01473 }
01474
01475
01476 for(int nStrip = 1; nStrip <= N_Strips; ++nStrip) {
01477
01478 ADC = (int) ((timeSample(data, nCFEB, nSample, nLayer, nStrip)->adcCounts) & 0xFFF);
01480 OutOffRange = (int) ((timeSample(data, nCFEB, nSample, nLayer, nStrip)->adcOverflow) & 0x1);
01481
01482 if(nSample == 0) {
01483 CellPeak[nCFEB][nLayer-1][nStrip-1] = std::make_pair(nSample,ADC);
01484 Pedestal[nCFEB][nLayer-1][nStrip-1] = ADC;
01486 }
01487
01488 if(OutOffRange == 1 && CheckOutOffRangeStripInTheLayer[nLayer - 1][nCFEB * 16 + nStrip - 1] == true) {
01490 if ( mo_CFEB_Out_Off_Range_Strips)
01491 mo_CFEB_Out_Off_Range_Strips->Fill((int)(nCFEB * 16 + nStrip - 1));
01492 CheckOutOffRangeStripInTheLayer[nLayer - 1][nCFEB * 16 + nStrip - 1] = false;
01493 }
01494 if(ADC - Pedestal[nCFEB][nLayer - 1][nStrip - 1] > Threshold && OutOffRange != 1) {
01496 if (mo_CFEB_Active_Samples_vs_Strip)
01497 mo_CFEB_Active_Samples_vs_Strip->Fill((int)(nCFEB * 16 + nStrip - 1), nSample);
01498
01500 if (mo_CFEB_Active_Samples_vs_Strip_Profile)
01501 mo_CFEB_Active_Samples_vs_Strip_Profile->Fill((int)(nCFEB * 16 + nStrip - 1), nSample);
01502
01503 if(CheckThresholdStripInTheLayer[nLayer - 1][nCFEB * 16 + nStrip - 1] == true) {
01505 if (mo_CFEB_ActiveStrips)
01506 mo_CFEB_ActiveStrips->Fill((int)(nCFEB * 16 + nStrip));
01507 CheckThresholdStripInTheLayer[nLayer - 1][nCFEB * 16 + nStrip - 1] = false;
01508 }
01510 if(ADC - Pedestal[nCFEB][nLayer - 1][nStrip - 1] > Threshold) {
01512 cscdata[nCFEB * 16 + nStrip - 1][nSample][nLayer - 1] = ADC - Pedestal[nCFEB][nLayer - 1][nStrip - 1];
01513 }
01515 if(ADC > CellPeak[nCFEB][nLayer - 1][nStrip - 1].second) {
01516 CellPeak[nCFEB][nLayer - 1][nStrip - 1].first = nSample;
01517 CellPeak[nCFEB][nLayer - 1][nStrip - 1].second = ADC;
01518 }
01519 }
01522 if(nSample == 1) {
01523 int channel_threshold = 40;
01524 if (std::abs(ADC - Pedestal[nCFEB][nLayer - 1][nStrip - 1]) < channel_threshold) {
01526 if (mo_CFEB_Pedestal_withEMV_Sample)
01527 mo_CFEB_Pedestal_withEMV_Sample->Fill((int)(nCFEB * 16 + nStrip - 1), Pedestal[nCFEB][nLayer - 1][nStrip - 1]);
01528
01530 if (mo_CFEB_Pedestal_withRMS_Sample) {
01531 mo_CFEB_Pedestal_withRMS_Sample->Fill((int)(nCFEB * 16 + nStrip - 1), Pedestal[nCFEB][nLayer - 1][nStrip - 1]);
01532
01533
01535 if (mo_CFEB_PedestalRMS_Sample) {
01536 mo_CFEB_PedestalRMS_Sample->SetBinContent(nCFEB * 16 + nStrip - 1, mo_CFEB_Pedestal_withRMS_Sample->GetBinError(nCFEB * 16 + nStrip));
01537 mo_CFEB_PedestalRMS_Sample->SetBinError(nCFEB * 16 + nStrip - 1, 0.00000000001);
01538 }
01539 }
01540 }
01541 Pedestal[nCFEB][nLayer-1][nStrip-1] += ADC;
01542 Pedestal[nCFEB][nLayer-1][nStrip-1] /= 2;
01543 }
01545 }
01546 }
01547
01548 for(int nStrip = 1; nStrip <= N_Strips; ++nStrip) {
01549 if (mo_CFEB_SCA_Cell_Peak && CellPeak[nCFEB][nLayer - 1][nStrip - 1].first) {
01550 mo_CFEB_SCA_Cell_Peak->Fill((int)(nCFEB * 16 + nStrip - 1), CellPeak[nCFEB][nLayer - 1][nStrip - 1].first);
01551 if (mo_CFEB_SCA_CellPeak_Time) {
01552 mo_CFEB_SCA_CellPeak_Time->Fill(CellPeak[nCFEB][nLayer - 1][nStrip - 1].first);
01553 }
01554
01555 if (mo_EventDisplay) {
01556 int peak_sample = CellPeak[nCFEB][nLayer-1][nStrip-1].first;
01557 int peak_adc = CellPeak[nCFEB][nLayer-1][nStrip-1].second;
01558 int pedestal = Pedestal[nCFEB][nLayer-1][nStrip-1];
01559 int peak_sca_charge = peak_adc - pedestal;
01560
01561 if (peak_adc - pedestal > Threshold) {
01562 if (peak_sample >=1) {
01563 peak_sca_charge += ((timeSample(data, nCFEB, peak_sample-1, nLayer, nStrip)->adcCounts)&0xFFF)-pedestal;
01564 }
01565 if (peak_sample < NmbTimeSamples-1) {
01566 peak_sca_charge += ((timeSample(data, nCFEB, peak_sample+1, nLayer, nStrip)->adcCounts)&0xFFF)-pedestal;
01567 }
01568 mo_EventDisplay->SetBinContent(nLayer + 17, nCFEB * 16 + nStrip - 1, peak_sca_charge);
01569 setEmuEventDisplayBit(mo_Emu_EventDisplay_Cathode, glChamberIndex, nCFEB * 16 + nStrip - 1, nLayer - 1);
01570 }
01571 }
01572
01573 if (cid.endcap() == 1) {
01574 if (mo_CSC_Plus_endcap_CFEB_SCA_CellPeak_Time)
01575 mo_CSC_Plus_endcap_CFEB_SCA_CellPeak_Time->Fill(CellPeak[nCFEB][nLayer - 1][nStrip - 1].first);
01576 }
01577 if (cid.endcap() == 2) {
01578 if (mo_CSC_Minus_endcap_CFEB_SCA_CellPeak_Time)
01579 mo_CSC_Minus_endcap_CFEB_SCA_CellPeak_Time->Fill(CellPeak[nCFEB][nLayer - 1][nStrip - 1].first);
01580 }
01581 }
01582 }
01583
01584 }
01585 }
01586
01587 }
01588
01589
01590 if (mo_CFEB_SCA_CellPeak_Time) {
01591 double cellpeak_time_mean = mo_CFEB_SCA_CellPeak_Time->getTH1()->GetMean();
01592 double cellpeak_time_rms = mo_CFEB_SCA_CellPeak_Time->getTH1()->GetRMS();
01593 if (cscType && cscPosition && mo_CSC_CFEB_SCA_CellPeak_Time_mean) {
01594 mo_CSC_CFEB_SCA_CellPeak_Time_mean->SetBinContent(cscPosition, cscType + 1, cellpeak_time_mean);
01595 }
01596 if (cscType && cscPosition && mo_CSC_CFEB_SCA_CellPeak_Time_rms) {
01597 mo_CSC_CFEB_SCA_CellPeak_Time_rms->SetBinContent(cscPosition, cscType + 1 ,cellpeak_time_rms);
01598 }
01599 }
01600
01603 const int a = N_CFEBs * N_Strips;
01604 const int b = a * N_Samples;
01605 float Cathodes[b * N_Layers];
01606 for(int i = 0; i < N_Layers; ++i) {
01607 const int b1 = i * b;
01608 for(int j = 0; j < a; ++j) {
01609 const int b2 = b1 + j;
01610 for(int k = 0; k < N_Samples; ++k) {
01611 Cathodes[b2 + a * k] = cscdata[j][k][i];
01612 }
01613 }
01614 }
01615
01616 std::vector<StripCluster> Clus;
01617 Clus.clear();
01618 StripClusterFinder ClusterFinder(N_Layers, N_Samples, N_CFEBs, N_Strips);
01619
01620 for(int nLayer = 1; nLayer <= N_Layers; ++nLayer) {
01621
01624 ClusterFinder.DoAction(nLayer - 1, Cathodes);
01625 Clus = ClusterFinder.getClusters();
01626
01629 if (getCSCHisto(h::CSC_CFEB_NUMBER_OF_CLUSTERS_LY_XX, crateID, dmbID, nLayer, mo)) {
01630
01631
01632 mo->Fill(Clus.size());
01633 }
01634
01635 for(uint32_t u = 0; u < Clus.size(); u++){
01636
01637 Clus_Sum_Charge = 0.0;
01638
01639 for(uint32_t k = 0;k < Clus[u].ClusterPulseMapHeight.size(); k++) {
01640
01643 for(int n = Clus[u].LFTBNDTime; n < Clus[u].IRTBNDTime; n++) {
01644 Clus_Sum_Charge = Clus_Sum_Charge + Clus[u].ClusterPulseMapHeight[k].height_[n];
01645 }
01646
01647 }
01648
01650 if (getCSCHisto(h::CSC_CFEB_CLUSTERS_CHARGE_LY_XX, crateID, dmbID, nLayer, mo)) {
01651 mo->Fill(Clus_Sum_Charge);
01652 }
01653
01655 if (getCSCHisto(h::CSC_CFEB_WIDTH_OF_CLUSTERS_LY_XX, crateID, dmbID, nLayer, mo)) {
01656 mo->Fill(Clus[u].IRTBNDStrip - Clus[u].LFTBNDStrip + 1);
01657 }
01658
01660 if (getCSCHisto(h::CSC_CFEB_CLUSTER_DURATION_LY_XX, crateID, dmbID, nLayer, mo)) {
01661 mo->Fill(Clus[u].IRTBNDTime - Clus[u].LFTBNDTime + 1);
01662 }
01663
01664 }
01665
01666 Clus.clear();
01667
01669 }
01670
01674 if (getCSCHisto(h::CSC_DMB_FEB_COMBINATIONS_UNPACKED_VS_DAV, crateID, dmbID, mo)) {
01675 float feb_combination_unpacked = -1.0;
01676 if(alct_unpacked == 0 && tmb_unpacked == 0 && cfeb_unpacked == 0) feb_combination_unpacked = 0.0;
01677 if(alct_unpacked > 0 && tmb_unpacked == 0 && cfeb_unpacked == 0) feb_combination_unpacked = 1.0;
01678 if(alct_unpacked == 0 && tmb_unpacked > 0 && cfeb_unpacked == 0) feb_combination_unpacked = 2.0;
01679 if(alct_unpacked == 0 && tmb_unpacked == 0 && cfeb_unpacked > 0) feb_combination_unpacked = 3.0;
01680 if(alct_unpacked > 0 && tmb_unpacked > 0 && cfeb_unpacked == 0) feb_combination_unpacked = 4.0;
01681 if(alct_unpacked > 0 && tmb_unpacked == 0 && cfeb_unpacked > 0) feb_combination_unpacked = 5.0;
01682 if(alct_unpacked == 0 && tmb_unpacked > 0 && cfeb_unpacked > 0) feb_combination_unpacked = 6.0;
01683 if(alct_unpacked > 0 && tmb_unpacked > 0 && cfeb_unpacked > 0) feb_combination_unpacked = 7.0;
01684 mo->Fill(feb_combination_dav, feb_combination_unpacked);
01685 }
01686
01687 if((clct_kewdistrip > -1 && alct_keywg > -1) && (getCSCHisto(h::CSC_CLCT0_KEYDISTRIP_VS_ALCT0_KEYWIREGROUP, crateID, dmbID, mo))) {
01688 mo->Fill(alct_keywg, clct_kewdistrip);
01689 }
01690
01691 if (L1A_out_of_sync && cscType && cscPosition && getEMUHisto(h::EMU_CSC_L1A_OUT_OF_SYNC, mo)){
01692 mo->Fill(cscPosition, cscType);
01693 }
01694
01695 if (L1A_out_of_sync && getEMUHisto(h::EMU_DMB_L1A_OUT_OF_SYNC, mo)){
01696 mo->Fill(crateID, dmbID);
01697 }
01698
01699 }
01700
01701 }
1.7.3