Reference Manual

Go to the documentation of this file.
00001 /*
00002  * =====================================================================================
00003  *
00004  *       Filename:  EventProcessor_updateEffHistos.cc
00005  *
00006  *    Description:  Update Efficiency histograms and parameters
00007  *
00008  *        Version:  1.0
00009  *        Created:  10/06/2008 11:44:34 AM
00010  *       Revision:  none
00011  *       Compiler:  gcc
00012  *
00013  *         Author:  Valdas Rapsevicius, valdas.rapsevicius@cern.ch
00014  *        Company:  CERN, CH
00015  *
00016  * =====================================================================================
00017  */
00018 
00019 #include "DQM/CSCMonitorModule/interface/CSCDQM_EventProcessor.h"
00020 
00021 namespace cscdqm {
00022   
00026   void EventProcessor::updateEfficiencyHistos() {
00027 
00028     MonitorObject *me = 0, *me1 = 0;
00029 
00030     if (config->getNEvents() > 0) {
00031 
00032       if (getEMUHisto(h::EMU_CSC_REPORTING, me)) {
00033   
00034         const TH2* rep = dynamic_cast<const TH2*>(me->getTH1());
00035   
00037         const TObject *tobj = me->getRefRootObject();
00038          
00042         if (tobj) {
00043           const TH2* ref = dynamic_cast<const TH2*>(tobj);
00044           summary.ReadReportingChambersRef(rep, ref, config->getEFF_COLD_THRESHOLD(), config->getEFF_COLD_SIGFAIL(), config->getEFF_HOT_THRESHOLD(), config->getEFF_HOT_SIGFAIL());
00045         } else {
00046           summary.ReadReportingChambers(rep, 1.0);
00047         }
00048   
00049         if (getEMUHisto(h::EMU_CSC_FORMAT_ERRORS, me1)) {
00050           const TH2* err = dynamic_cast<const TH2*>(me1->getTH1());
00051           summary.ReadErrorChambers(rep, err, FORMAT_ERR, config->getEFF_ERR_THRESHOLD(), config->getEFF_ERR_SIGFAIL());
00052         }
00053   
00054         if (getEMUHisto(h::EMU_CSC_L1A_OUT_OF_SYNC, me1)) {
00055           const TH2* err = dynamic_cast<const TH2*>(me1->getTH1());
00056           summary.ReadErrorChambers(rep, err, L1SYNC_ERR, config->getEFF_ERR_THRESHOLD(), config->getEFF_ERR_SIGFAIL());
00057         }
00058   
00059         if (getEMUHisto(h::EMU_CSC_DMB_INPUT_FIFO_FULL, me1)) {
00060           const TH2* err = dynamic_cast<const TH2*>(me1->getTH1());
00061           summary.ReadErrorChambers(rep, err, FIFOFULL_ERR, config->getEFF_ERR_THRESHOLD(), config->getEFF_ERR_SIGFAIL());
00062         }
00063   
00064         if (getEMUHisto(h::EMU_CSC_DMB_INPUT_TIMEOUT, me1)) {
00065           const TH2* err = dynamic_cast<const TH2*>(me1->getTH1());
00066           summary.ReadErrorChambers(rep, err, INPUTTO_ERR, config->getEFF_ERR_THRESHOLD(), config->getEFF_ERR_SIGFAIL());
00067         }
00068   
00069         if (getEMUHisto(h::EMU_CSC_WO_ALCT, me1)) {
00070           const TH2* err = dynamic_cast<const TH2*>(me1->getTH1());
00071           summary.ReadErrorChambers(rep, err, NODATA_ALCT, config->getEFF_NODATA_THRESHOLD(), config->getEFF_NODATA_SIGFAIL());
00072         }
00073   
00074         if (getEMUHisto(h::EMU_CSC_WO_CLCT, me1)) {
00075           const TH2* err = dynamic_cast<const TH2*>(me1->getTH1());
00076           summary.ReadErrorChambers(rep, err, NODATA_CLCT, config->getEFF_NODATA_THRESHOLD(), config->getEFF_NODATA_SIGFAIL());
00077         }
00078   
00079         if (getEMUHisto(h::EMU_CSC_WO_CFEB, me1)) {
00080           const TH2* err = dynamic_cast<const TH2*>(me1->getTH1());
00081           summary.ReadErrorChambers(rep, err, NODATA_CFEB, config->getEFF_NODATA_THRESHOLD(), config->getEFF_NODATA_SIGFAIL());
00082         }
00083   
00084         if (getEMUHisto(h::EMU_CSC_FORMAT_WARNINGS, me1)) {
00085           const TH2* err = dynamic_cast<const TH2*>(me1->getTH1());
00086           summary.ReadErrorChambers(rep, err, CFEB_BWORDS, config->getEFF_NODATA_THRESHOLD(), config->getEFF_NODATA_SIGFAIL());
00087         }
00088   
00089       }
00090 
00091       writeShifterHistograms();
00092   
00097       if (getEMUHisto(h::EMU_PHYSICS_ME1, me)){
00098         LockType lock(me->mutex);
00099         TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
00100         summary.Write(tmp, 1);
00101       }
00102     
00103       if (getEMUHisto(h::EMU_PHYSICS_ME2, me)){
00104         LockType lock(me->mutex);
00105         TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
00106         summary.Write(tmp, 2);
00107       }
00108   
00109       if (getEMUHisto(h::EMU_PHYSICS_ME3, me)){
00110         LockType lock(me->mutex);
00111         TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
00112         summary.Write(tmp, 3);
00113       }
00114   
00115       if (getEMUHisto(h::EMU_PHYSICS_ME4, me)){
00116         LockType lock(me->mutex);
00117         TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
00118         summary.Write(tmp, 4);
00119       }
00120   
00121       if (getEMUHisto(h::EMU_PHYSICS_EMU, me)) {
00122         LockType lock(me->mutex);
00123         TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
00124         summary.WriteMap(tmp);
00125       }
00126 
00127     }
00128 
00133     if (config->getPROCESS_EFF_PARAMETERS()) {
00134 
00135       { // Compute DQM information parameters
00136 
00137         Address adr;
00138         adr.mask.side = adr.mask.station = adr.mask.ring = true;
00139         adr.mask.chamber = adr.mask.layer = adr.mask.cfeb = adr.mask.hv = false;
00140   
00141         double   e_detector = 0.0, e_side = 0.0, e_station = 0.0, e_ring = 0.0;
00142         uint32_t e_detector_ch = 0, e_side_ch = 0, e_station_ch = 0;
00143       
00144         const HistoId parameters [] = {
00145           h::PAR_CSC_SIDEPLUS_STATION01_RING01,
00146           h::PAR_CSC_SIDEPLUS_STATION01_RING02,
00147           h::PAR_CSC_SIDEPLUS_STATION01_RING03,
00148           h::PAR_CSC_SIDEPLUS_STATION01,
00149           h::PAR_CSC_SIDEPLUS_STATION02_RING01,
00150           h::PAR_CSC_SIDEPLUS_STATION02_RING02,
00151           h::PAR_CSC_SIDEPLUS_STATION02,
00152           h::PAR_CSC_SIDEPLUS_STATION03_RING01,
00153           h::PAR_CSC_SIDEPLUS_STATION03_RING02,
00154           h::PAR_CSC_SIDEPLUS_STATION03,
00155           h::PAR_CSC_SIDEPLUS_STATION04_RING01,
00156           h::PAR_CSC_SIDEPLUS_STATION04_RING02,
00157           h::PAR_CSC_SIDEPLUS_STATION04,
00158           h::PAR_CSC_SIDEPLUS,
00159           h::PAR_CSC_SIDEMINUS_STATION01_RING01,
00160           h::PAR_CSC_SIDEMINUS_STATION01_RING02,
00161           h::PAR_CSC_SIDEMINUS_STATION01_RING03,
00162           h::PAR_CSC_SIDEMINUS_STATION01,
00163           h::PAR_CSC_SIDEMINUS_STATION02_RING01,
00164           h::PAR_CSC_SIDEMINUS_STATION02_RING02,
00165           h::PAR_CSC_SIDEMINUS_STATION02,
00166           h::PAR_CSC_SIDEMINUS_STATION03_RING01,
00167           h::PAR_CSC_SIDEMINUS_STATION03_RING02,
00168           h::PAR_CSC_SIDEMINUS_STATION03,
00169           h::PAR_CSC_SIDEMINUS_STATION04_RING01,
00170           h::PAR_CSC_SIDEMINUS_STATION04_RING02,
00171           h::PAR_CSC_SIDEMINUS_STATION04,
00172           h::PAR_CSC_SIDEMINUS
00173         };
00174 
00175         bool calc = (config->getNEvents() > 0);
00176 
00177         if (!calc) {
00178           e_detector = e_side = e_station = e_ring = -1.0;
00179         }
00180 
00181         unsigned int parameter = 0;
00182         for (adr.side = 1; adr.side <= N_SIDES; adr.side++) {
00183           
00184           if (calc) {
00185             e_side = 0.0;
00186             e_side_ch = 0;
00187           }
00188 
00189           adr.mask.station = true;
00190           for (adr.station = 1; adr.station <= N_STATIONS; adr.station++) {
00191             
00192             if (calc) {
00193               e_station = 0.0;
00194               e_station_ch = 0;
00195             }
00196             
00197             adr.mask.ring = true;
00198             for (adr.ring = 1; adr.ring <= summary.getDetector().NumberOfRings(adr.station); adr.ring++) {
00199 
00200               if (calc) {
00201                 e_ring = summary.GetEfficiencyHW(adr);
00202                 uint32_t ch = summary.getDetector().NumberOfChambers(adr.station, adr.ring);
00203                 e_station += (e_ring * ch);
00204                 e_station_ch += ch;
00205               }
00206 
00207               if (summary.getDetector().NumberOfRings(adr.station) > 1) {
00208                 if (getParHisto(parameters[parameter++], me)) me->Fill(e_ring);
00209               }
00210 
00211             }
00212 
00213             adr.mask.ring = false;
00214             if (calc) {
00215               e_side += e_station;
00216               e_side_ch += e_station_ch;
00217               e_station = e_station / e_station_ch;
00218             }
00219 
00220             if (getParHisto(parameters[parameter++], me)) me->Fill(e_station);
00221 
00222           }
00223 
00224           adr.mask.station = false;
00225           if (calc) {
00226             e_detector += e_side; 
00227             e_detector_ch += e_side_ch;
00228             e_side = e_side / e_side_ch;
00229           }
00230 
00231           if (getParHisto(parameters[parameter++], me)) me->Fill(e_side);
00232 
00233         }
00234 
00235         if (calc) {
00236           e_detector = e_detector / e_detector_ch;
00237         }
00238 
00239         if (getParHisto(h::PAR_REPORT_SUMMARY, me)) me->Fill(e_detector);
00240 
00241       }
00242 
00243     }
00244 
00245   }
00246 
00247   void EventProcessor::writeShifterHistograms() {
00248 
00249     MonitorObject *me = 0;
00250 
00251     //const int COLOR_WHITE   = 0;
00252     const int COLOR_GREEN   = 1;
00253     const int COLOR_RED     = 2;
00254     const int COLOR_BLUE    = 3;
00255     const int COLOR_GREY    = 4;
00256     const int COLOR_STANDBY = 5;
00257 
00258     if (getEMUHisto(h::EMU_CSC_STATS_SUMMARY, me)) {
00259       LockType lock(me->mutex);
00260       TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
00261       if (!config->getIN_FULL_STANDBY()) {
00262         summary.WriteChamberState(tmp, 0x1, COLOR_GREEN, true, false);
00263         summary.WriteChamberState(tmp, HWSTATUSERRORBITS, COLOR_RED, false, true);
00264       }
00265       summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
00266       summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false);
00267     }
00268 
00269     if (getEMUHisto(h::EMU_CSC_STATS_OCCUPANCY, me)){
00270       LockType lock(me->mutex);
00271       TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
00272       if (!config->getIN_FULL_STANDBY()) {
00273         summary.WriteChamberState(tmp, 0x4, COLOR_RED, true, false);
00274         summary.WriteChamberState(tmp, 0x8, COLOR_BLUE, false, false);
00275       }
00276       summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
00277       summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false, false);
00278     }
00279 
00280     if (getEMUHisto(h::EMU_CSC_STATS_FORMAT_ERR, me)){
00281       LockType lock(me->mutex);
00282       TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
00283       if (!config->getIN_FULL_STANDBY()) {
00284         summary.WriteChamberState(tmp, 0x10, COLOR_RED, true, false);
00285       }
00286       summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
00287       summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false, false);
00288     }
00289 
00290     if (getEMUHisto(h::EMU_CSC_STATS_L1SYNC_ERR, me)){
00291       LockType lock(me->mutex);
00292       TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
00293       if (!config->getIN_FULL_STANDBY()) {
00294         summary.WriteChamberState(tmp, 0x20, COLOR_RED, true, false);
00295       }
00296       summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
00297       summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false, false);
00298     }
00299 
00300     if (getEMUHisto(h::EMU_CSC_STATS_FIFOFULL_ERR, me)){
00301       LockType lock(me->mutex);
00302       TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
00303       if (!config->getIN_FULL_STANDBY()) {
00304         summary.WriteChamberState(tmp, 0x40, COLOR_RED, true, false);
00305       }
00306       summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
00307       summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false, false);
00308     }
00309 
00310     if (getEMUHisto(h::EMU_CSC_STATS_INPUTTO_ERR, me)){
00311       LockType lock(me->mutex);
00312       TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
00313       if (!config->getIN_FULL_STANDBY()) {
00314         summary.WriteChamberState(tmp, 0x80, COLOR_RED, true, false);
00315       }
00316       summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
00317       summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false, false);
00318     }
00319 
00320     if (getEMUHisto(h::EMU_CSC_STATS_WO_ALCT, me)){
00321       LockType lock(me->mutex);
00322       TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
00323       if (!config->getIN_FULL_STANDBY()) {
00324         summary.WriteChamberState(tmp, 0x100, COLOR_RED, true, false);
00325       }
00326       summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
00327       summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false, false);
00328     }
00329 
00330     if (getEMUHisto(h::EMU_CSC_STATS_WO_CLCT, me)){
00331       LockType lock(me->mutex);
00332       TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
00333       if (!config->getIN_FULL_STANDBY()) {
00334         summary.WriteChamberState(tmp, 0x200, COLOR_RED, true, false);
00335       }
00336       summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
00337       summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false, false);
00338     }
00339 
00340     if (getEMUHisto(h::EMU_CSC_STATS_WO_CFEB, me)){
00341       LockType lock(me->mutex);
00342       TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
00343       if (!config->getIN_FULL_STANDBY()) {
00344         summary.WriteChamberState(tmp, 0x400, COLOR_RED, true, false);
00345       }
00346       summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
00347       summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false, false);
00348     }
00349 
00350     if (getEMUHisto(h::EMU_CSC_STATS_CFEB_BWORDS, me)){
00351       LockType lock(me->mutex);
00352       TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
00353       if (!config->getIN_FULL_STANDBY()) {
00354         summary.WriteChamberState(tmp, 0x800, COLOR_RED, true, false);
00355       }
00356       summary.WriteChamberState(tmp, 0x1000, COLOR_STANDBY, false);
00357       summary.WriteChamberState(tmp, 0x2, COLOR_GREY, false, false);
00358     }
00359     
00360   }
00361 
00366   void EventProcessor::standbyEfficiencyHistos(HWStandbyType& standby) {
00367 
00368     Address adr;
00369     adr.mask.side = true;
00370     adr.mask.station = adr.mask.ring = adr.mask.chamber = adr.mask.layer = adr.mask.cfeb = adr.mask.hv = false;
00371 
00372     adr.side = 1;
00373     summary.SetValue(adr, STANDBY, (standby.MeP ? 1 : 0));
00374     if (!standby.MeP) {
00375       summary.SetValue(adr, WAS_ON);
00376     }
00377 
00378     adr.side = 2;
00379     summary.SetValue(adr, STANDBY, (standby.MeM ? 1 : 0));
00380     if (!standby.MeM) {
00381       summary.SetValue(adr, WAS_ON);
00382     }
00383 
00384     MonitorObject *me = 0;
00385     if (getEMUHisto(h::EMU_CSC_STANDBY, me)){
00386       LockType lock(me->mutex);
00387       TH2* tmp = dynamic_cast<TH2*>(me->getTH1Lock());
00388 
00389       // All standby
00390       summary.WriteChamberState(tmp, 0x1000, 5);
00391        
00392       // Temporary in standby (was ON)
00393       summary.WriteChamberState(tmp, 0x3000, 1, false);
00394 
00395     }
00396 
00397   }
00398 
00399 }
00400
/data/doxygen/doxygen-1.7.3/gen/CMSSW_4_2_8/src/DQM/CSCMonitorModule/src/CSCDQM_EventProcessor_updateEffHistos.cc
