CMS 3D CMS Logo

CSCMonitorModule Class Reference

Online CSC DQM module. More...

#include <DQM/CSCMonitorModule/interface/CSCMonitorModule.h>

Inheritance diagram for CSCMonitorModule:

edm::EDAnalyzer

List of all members.

Public Member Functions

 CSCMonitorModule (const edm::ParameterSet &ps)
 MonitorModule Constructor.
virtual ~CSCMonitorModule ()
 MonitorModule Destructor.

Protected Member Functions

void analyze (const edm::Event &e, const edm::EventSetup &c)
 Main Analyzer function that receives Events andi starts the acctual analysis (histogram filling) and so on chain.
void beginJob (const edm::EventSetup &c)
 Function that is being executed prior job.
void beginLuminosityBlock (const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &context)
void beginRun (const edm::Run &r, const edm::EventSetup &c)
void endJob ()
 Function that is being executed at the very end of the job.
void endRun (const edm::Run &r, const edm::EventSetup &c)
void setup ()

Private Member Functions

void book (const std::string prefix)
 Book a group of histograms.
const bool getCSCFromMap (const int crate, const int slot, int &csctype, int &cscposition) const
const bool isMEValid (const std::string name, MonitorElement *&me)
 Get MonitorElement by using path name.
int loadCollection ()
 Load XML file and create definitions.
const bool MEDDU (const unsigned int dduId, const std::string name, MonitorElement *&me)
 Checks if MonitorElement of DDU level is available and returns it.
const bool MEEMU (const std::string name, MonitorElement *&me)
 Find histograms (aka previous macros).
const bool MEEventInfo (const std::string name, MonitorElement *&me)
 Checks if MonitorElement of EventInfo level is available and returns it.
const bool MEReportSummaryContents (const std::string name, MonitorElement *&me)
 Checks if MonitorElement of EventInfo/reportSummaryContents level is available and returns it.
void monitorCSC (const CSCEventData &cscEvent, const int32_t &dduID)
 MonitorCSC function that grabs CSCEventData and processes it.
void monitorDCC (const CSCDCCEventData &dccEvent)
 MonitorDCC function that grabs DCCEventData and processes it.
void monitorDDU (const CSCDDUEventData &dduEvent)
 MonitorDDU function that grabs DDUEventData and processes it.
void monitorEvent (const edm::Event &e)
 Histogram filling and calculation methods.
bool monitorExaminer (CSCDCCExaminer &examiner)
 Examiner object analyzer.
void printCollection ()
 Print collection of available histograms and their parameters.
void updateFracHistos ()

Private Attributes

bool bCSCEventCounted
std::string bookingFile
HistoDefMap collection
 Histogram collection.
DQMStoredbe
edm::ParameterSet effParameters
Bitset32 examinerCRCKey
bool examinerForce
unsigned int examinerMask
 Examiner and its stuff.
bool examinerOutput
uint32_t fractUpdateEvF
Bitset32 fractUpdateKey
 Fractional histograms update stuff.
bool hitBookDDU
 List of loaded (preloaded) DDU's.
bool init
 If histos have been initialized?
edm::InputTag inputObjectsTag
 Source related stuff.
uint32_t L1ANumber
std::map< uint32_t, uint32_t > L1ANumbers
std::string monitorName
uint32_t nCSCEvents
uint32_t nEvents
 Histogram mapping, increments, etc.
edm::ParameterSet parameters
 Global Module-wide parameters.
const CSCCrateMappcrate
 Pointer to crate mapping from database.
std::string rootDir
cscdqm::Summary summary
 CSC summary map.


Detailed Description

Online CSC DQM module.

Definition at line 78 of file CSCMonitorModule.h.


Constructor & Destructor Documentation

CSCMonitorModule::CSCMonitorModule ( const edm::ParameterSet ps  ) 

MonitorModule Constructor.

Parameters:
ps ParameterSet
Returns:

Definition at line 26 of file CSCMonitorModule.cc.

References bookingFile, dbe, effParameters, examinerCRCKey, examinerForce, examinerMask, examinerOutput, fractUpdateEvF, fractUpdateKey, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), hitBookDDU, init, inputObjectsTag, L1ANumber, loadCollection(), LOGERROR, LOGINFO, monitorName, nCSCEvents, nEvents, parameters, rootDir, cscdqm::Summary::setMaskedHWElements(), and summary.

00026                                                            {
00027     
00028     parameters = ps;
00029     
00030     edm::FileInPath fp;
00031     
00032     hitBookDDU     = parameters.getUntrackedParameter<bool>("hitBookDDU", true);
00033     examinerMask   = parameters.getUntrackedParameter<unsigned int>("ExaminerMask", 0x7FB7BF6);
00034     examinerForce  = parameters.getUntrackedParameter<bool>("ExaminerForce", false);
00035     examinerOutput = parameters.getUntrackedParameter<bool>("ExaminerOutput", false);
00036     examinerCRCKey = parameters.getUntrackedParameter<unsigned int>("ExaminerCRCKey", 0);
00037     fractUpdateKey = parameters.getUntrackedParameter<unsigned int>("FractUpdateKey", 1);
00038     fractUpdateEvF = parameters.getUntrackedParameter<unsigned int>("FractUpdateEventFreq", 1);
00039     effParameters  = parameters.getUntrackedParameter<edm::ParameterSet>("effParameters");
00040     
00041     // Get ant apply dead HW element masks if any
00042     std::vector<std::string> hwMasks = parameters.getUntrackedParameter<std::vector<std::string> >("AddressMask");
00043     unsigned int masks_ok = summary.setMaskedHWElements(hwMasks);
00044     LOGINFO("HW Address Masks") << masks_ok << " out of " << hwMasks.size() << " HW Masks are accepted.";
00045     
00046     // Initialize some variables
00047     inputObjectsTag = parameters.getUntrackedParameter<edm::InputTag>("InputObjects", (edm::InputTag)"source");
00048     monitorName = parameters.getUntrackedParameter<std::string>("monitorName", "CSC");
00049     fp = parameters.getParameter<edm::FileInPath>("BookingFile");
00050     bookingFile = fp.fullPath();
00051     
00052     rootDir = monitorName + "/";
00053     nEvents = 0;
00054     nCSCEvents = 0;
00055     L1ANumber = 0;
00056     
00057     // Loading histogram collection from XML file
00058     if(loadCollection()) {
00059         LOGERROR("initialize") << "Histogram booking failed .. exiting.";
00060         return;
00061     }
00062     
00063     // Get back-end interface
00064     dbe = edm::Service<DQMStore>().operator->();
00065     
00066     this->init = false;
00067     
00068 }

CSCMonitorModule::~CSCMonitorModule (  )  [virtual]

MonitorModule Destructor.

Parameters:
@return 

Definition at line 75 of file CSCMonitorModule.cc.

00075                                    {
00076     
00077     
00078 }


Member Function Documentation

void CSCMonitorModule::analyze ( const edm::Event e,
const edm::EventSetup c 
) [protected, virtual]

Main Analyzer function that receives Events andi starts the acctual analysis (histogram filling) and so on chain.

Parameters:
e Event
c EventSetup
Returns:

Implements edm::EDAnalyzer.

Definition at line 152 of file CSCMonitorModule.cc.

References fractUpdateEvF, fractUpdateKey, edm::EventSetup::get(), monitorEvent(), nCSCEvents, nEvents, pcrate, edm::ESHandle< T >::product(), setup(), and updateFracHistos().

00152                                                                        {
00153     
00154     // Get crate mapping from database
00155     edm::ESHandle<CSCCrateMap> hcrate;
00156     c.get<CSCCrateMapRcd>().get(hcrate);
00157     pcrate = hcrate.product();
00158     
00159     // Lets initialize MEs if it was not done so before
00160     if (!this->init) {
00161         this->setup();
00162     }
00163     
00164     // Pass event to monitoring chain
00165     monitorEvent(e);
00166     
00167     // Update fractional histograms if appropriate
00168     if (nCSCEvents > 0 && fractUpdateKey.test(2) && (nEvents % fractUpdateEvF) == 0) {
00169         updateFracHistos();
00170     }
00171     
00172 }

void CSCMonitorModule::beginJob ( const edm::EventSetup c  )  [protected, virtual]

Function that is being executed prior job.

Actuall histogram bookings are done here. All initialization tasks as well.

Parameters:
c Event setup object
Returns:

Reimplemented from edm::EDAnalyzer.

Definition at line 86 of file CSCMonitorModule.cc.

00086                                                      {
00087     
00088 }

void CSCMonitorModule::beginLuminosityBlock ( const edm::LuminosityBlock lumiSeg,
const edm::EventSetup context 
) [protected, virtual]

Reimplemented from edm::EDAnalyzer.

Definition at line 195 of file CSCMonitorModule.cc.

References fractUpdateKey, nCSCEvents, and updateFracHistos().

00195                                                                                                            {
00196     if (nCSCEvents > 0 && fractUpdateKey.test(1)) {
00197         updateFracHistos();
00198     }
00199 }

void CSCMonitorModule::beginRun ( const edm::Run r,
const edm::EventSetup c 
) [protected, virtual]

Reimplemented from edm::EDAnalyzer.

Definition at line 185 of file CSCMonitorModule.cc.

00185                                                                              {
00186     
00187 }

void CSCMonitorModule::book ( const std::string  prefix  )  [private]

Book a group of histograms.

Parameters:
prefix name of histogram group to book
Returns:

Definition at line 179 of file CSCMonitorModule_collection.cc.

References DQMStore::book1D(), DQMStore::book2D(), DQMStore::book3D(), DQMStore::bookProfile(), DQMStore::bookProfile2D(), collection, d, dbe, DEF_HISTO_COLOR, e, f, findHistoValue, g, getHistoValue, MonitorElement::getTH1(), h, i, j, k, edm::es::l(), hlt_scaler_cfg::labels, me, name, NULL, ParseAxisLabels, s, MonitorElement::setAxisTitle(), indexGen::title, tokenize, and v.

Referenced by MEDDU(), and setup().

00179                                                   {
00180 
00181   HistoDefMapIter hdmi = collection.find(prefix);
00182 
00183   if( hdmi != collection.end()) {
00184 
00185     for(HistoDefIter hdi = hdmi->second.begin(); hdi != hdmi->second.end(); hdi++) {
00186       
00187       MonitorElement* me = NULL;
00188       std::string name, type, title, s;
00189       int i, j, l;
00190       double d, e, f, g, h, k;
00191       
00192       name  = hdi->first;
00193       type  = getHistoValue(hdi->second, "Type", type, "h1");
00194       title = getHistoValue(hdi->second, "Title", title, hdi->first);
00195 
00196       if (type == "h1") {
00197         me = dbe->book1D(name, title,
00198             getHistoValue(hdi->second, "XBins", i, 1),
00199             getHistoValue(hdi->second, "XMin",  d, 0),
00200             getHistoValue(hdi->second, "XMax",  e, 1));
00201       }
00202       if(type == "h2") {
00203         me = dbe->book2D(name, title,
00204             getHistoValue(hdi->second, "XBins", i, 1),
00205             getHistoValue(hdi->second, "XMin",  d, 0),
00206             getHistoValue(hdi->second, "XMax",  e, 1),
00207             getHistoValue(hdi->second, "YBins", j, 1),
00208             getHistoValue(hdi->second, "YMin",  f, 0),
00209             getHistoValue(hdi->second, "YMax",  g, 1));
00210       }
00211       if(type == "h3") {
00212         me = dbe->book3D(name, title,
00213             getHistoValue(hdi->second, "XBins", i, 1),
00214             getHistoValue(hdi->second, "XMin",  d, 0),
00215             getHistoValue(hdi->second, "XMax",  e, 1),
00216             getHistoValue(hdi->second, "YBins", j, 1),
00217             getHistoValue(hdi->second, "YMin",  f, 0),
00218             getHistoValue(hdi->second, "YMax",  g, 1),
00219             getHistoValue(hdi->second, "ZBins", l, 1),
00220             getHistoValue(hdi->second, "ZMin",  h, 0),
00221             getHistoValue(hdi->second, "ZMax",  k, 1));
00222       }
00223       if(type == "hp") {
00224         me = dbe->bookProfile(name, title,
00225             getHistoValue(hdi->second, "XBins", i, 1),
00226             getHistoValue(hdi->second, "XMin",  d, 0),
00227             getHistoValue(hdi->second, "XMax",  e, 1),
00228             getHistoValue(hdi->second, "YBins", j, 1),
00229             getHistoValue(hdi->second, "YMin",  f, 0),
00230             getHistoValue(hdi->second, "YMax",  g, 1));
00231       }
00232       if(type == "hp2") {
00233         me = dbe->bookProfile2D(name, title,
00234             getHistoValue(hdi->second, "XBins", i, 1),
00235             getHistoValue(hdi->second, "XMin",  d, 0),
00236             getHistoValue(hdi->second, "XMax",  e, 1),
00237             getHistoValue(hdi->second, "YBins", j, 1),
00238             getHistoValue(hdi->second, "YMin",  f, 0),
00239             getHistoValue(hdi->second, "YMax",  g, 1),
00240             getHistoValue(hdi->second, "ZBins", l, 1),
00241             getHistoValue(hdi->second, "ZMin",  h, 0),
00242             getHistoValue(hdi->second, "ZMax",  k, 1));
00243       }
00244 
00245       if(me != NULL) {
00246         TH1 *h = me->getTH1();
00247         if(findHistoValue(hdi->second, "XTitle", s)) me->setAxisTitle(s, 1);
00248         if(findHistoValue(hdi->second, "YTitle", s)) me->setAxisTitle(s, 2);
00249         if(findHistoValue(hdi->second, "ZTitle", s)) me->setAxisTitle(s, 3);
00250         if(findHistoValue(hdi->second, "SetOption", s)) h->SetOption(s.c_str());
00251         if(findHistoValue(hdi->second, "SetStats", i)) h->SetStats(i);
00252         h->SetFillColor(getHistoValue(hdi->second, "SetFillColor", i, DEF_HISTO_COLOR));
00253         if(findHistoValue(hdi->second, "SetXLabels", s)) {
00254           std::map<int, std::string> labels;
00255           ParseAxisLabels(s, labels);
00256           for (std::map<int, std::string>::iterator l_itr = labels.begin(); l_itr != labels.end(); ++l_itr) {
00257             h->GetXaxis()->SetBinLabel(l_itr->first, l_itr->second.c_str());
00258           }
00259         }
00260         if(findHistoValue(hdi->second, "SetYLabels", s)) {
00261           std::map<int, std::string> labels;
00262           ParseAxisLabels(s, labels);
00263           for (std::map<int, std::string>::iterator l_itr = labels.begin(); l_itr != labels.end(); ++l_itr) {
00264             h->GetYaxis()->SetBinLabel(l_itr->first, l_itr->second.c_str());
00265           }
00266         }
00267         if(findHistoValue(hdi->second, "LabelOption", s)) {
00268           std::vector<std::string> v;
00269           if(2 == tokenize(s, v, ",")) {
00270             h->LabelsOption(v[0].c_str(), v[1].c_str());
00271           }
00272         }
00273         if(findHistoValue(hdi->second, "SetLabelSize", s)) {
00274           std::vector<std::string> v;
00275           if(2 == tokenize(s, v, ",")) {
00276             h->SetLabelSize((double) atof(v[0].c_str()), v[1].c_str());
00277           }
00278         }
00279         if(findHistoValue(hdi->second, "SetTitleOffset", s)) {
00280           std::vector<std::string> v;
00281           if(2 == tokenize(s, v, ",")) {
00282             h->SetTitleOffset((double) atof(v[0].c_str()), v[1].c_str());
00283           }
00284         }
00285         if(findHistoValue(hdi->second, "SetMinimum", d)) h->SetMinimum(d);
00286         if(findHistoValue(hdi->second, "SetMaximum", d)) h->SetMaximum(d);
00287         if(findHistoValue(hdi->second, "SetNdivisionsX", i)) {
00288           h->SetNdivisions(i, "X");
00289           h->GetXaxis()->CenterLabels(true);
00290         }
00291         if(findHistoValue(hdi->second, "SetNdivisionsY", i)) {
00292           h->SetNdivisions(i, "Y");
00293           h->GetYaxis()->CenterLabels(true);
00294         }
00295         if(findHistoValue(hdi->second, "SetTickLengthX", d)) h->SetTickLength(d, "X");
00296         if(findHistoValue(hdi->second, "SetTickLengthY", d)) h->SetTickLength(d, "Y");
00297         if(findHistoValue(hdi->second, "SetLabelSizeX", d)) h->SetLabelSize(d, "X");
00298         if(findHistoValue(hdi->second, "SetLabelSizeY", d)) h->SetLabelSize(d, "Y");
00299         if(findHistoValue(hdi->second, "SetLabelSizeZ", d)) h->SetLabelSize(d, "Z");
00300         if(findHistoValue(hdi->second, "SetErrorOption", s)) reinterpret_cast<TProfile*>(h)->SetErrorOption(s.c_str());
00301 
00302       }
00303 
00304     }
00305   }
00306 }

void CSCMonitorModule::endJob ( void   )  [protected, virtual]

Function that is being executed at the very end of the job.

Histogram savings, calculation of fractional histograms, etc. should be done here.

Parameters:
@return 

Reimplemented from edm::EDAnalyzer.

Definition at line 181 of file CSCMonitorModule.cc.

00181                                  {
00182     
00183 }

void CSCMonitorModule::endRun ( const edm::Run r,
const edm::EventSetup c 
) [protected, virtual]

Reimplemented from edm::EDAnalyzer.

Definition at line 189 of file CSCMonitorModule.cc.

References fractUpdateKey, nCSCEvents, and updateFracHistos().

00189                                                                            {
00190     if (nCSCEvents > 0 && fractUpdateKey.test(0)) {
00191         updateFracHistos();
00192     }
00193 }

const bool CSCMonitorModule::getCSCFromMap ( const int  crate,
const int  slot,
int csctype,
int cscposition 
) const [private]

Definition at line 201 of file CSCMonitorModule.cc.

References CSCDetId::chamber(), CSCCrateMap::detId(), CSCDetId::endcap(), CSCUtility::getCSCTypeBin(), CSCUtility::getCSCTypeLabel(), pcrate, CSCDetId::ring(), and CSCDetId::station().

Referenced by monitorCSC(), and monitorExaminer().

00201                                                                                                                 {
00202     
00203     if (crate < 1 || crate > 60 || slot < 1 || slot > 10) return false;
00204 
00205     CSCDetId cid = pcrate->detId(crate, slot, 0, 0);
00206     cscposition  = cid.chamber();
00207     int iring    = cid.ring();
00208     int istation = cid.station();
00209     int iendcap  = cid.endcap();
00210     
00211     std::string tlabel = CSCUtility::getCSCTypeLabel(iendcap, istation, iring);
00212     csctype = CSCUtility::getCSCTypeBin(tlabel);
00213 
00214     return true;
00215     
00216 }

const bool CSCMonitorModule::isMEValid ( const std::string  name,
MonitorElement *&  me 
) [private]

Get MonitorElement by using path name.

Parameters:
name Path to the histogram (MonitorElement)
me Pointer to resulting MonitorElement
Returns:
true if histogram found and pointer value changed, false - otherwise

Definition at line 37 of file CSCMonitorModule_collection.cc.

References dbe, DQMStore::get(), LOGINFO, and NULL.

Referenced by MEDDU(), MEEMU(), MEEventInfo(), and MEReportSummaryContents().

00037                                                                                 {
00038   me = dbe->get(name);
00039   if(me == NULL) {
00040     LOGINFO("ME not found") << "MonitorElement [" << name << "] not found.";
00041     return false;
00042   } else {
00043     return true;
00044   }
00045 }

int CSCMonitorModule::loadCollection (  )  [private]

Load XML file and create definitions.

Parameters:
@return 

Definition at line 107 of file CSCMonitorModule_collection.cc.

References bookingFile, collection, doc, lat::endl(), h, i, it, j, LOGERROR, LOGINFO, name, indexGen::parser, prof2calltree::prefix, and transcode().

Referenced by CSCMonitorModule().

00107                                      {
00108 
00109   XMLPlatformUtils::Initialize();
00110   XercesDOMParser *parser = new XercesDOMParser();
00111   parser->setValidationScheme(XercesDOMParser::Val_Always);
00112   parser->setDoNamespaces(true);
00113   parser->setDoSchema(true);
00114   parser->setValidationSchemaFullChecking(false); // this is default
00115   parser->setCreateEntityReferenceNodes(true);  // this is default
00116   parser->setIncludeIgnorableWhitespace (false);
00117 
00118   parser->parse(bookingFile.c_str());
00119   DOMDocument *doc = parser->getDocument();
00120   DOMNode *docNode = (DOMNode*) doc->getDocumentElement();
00121   
00122   std::string nodeName = XMLString::transcode(docNode->getNodeName());
00123   if( nodeName != "Booking" ){
00124     LOGERROR("loadCollection") << "Wrong booking root node: " << XMLString::transcode(docNode->getNodeName());
00125     delete parser;
00126     return 1;
00127   }
00128   DOMNodeList *itemList = docNode->getChildNodes();
00129 
00130   for(uint32_t i=0; i < itemList->getLength(); i++) {
00131 
00132     nodeName = XMLString::transcode(itemList->item(i)->getNodeName());
00133     if(nodeName != "Histogram") {
00134       continue;
00135     }
00136 
00137     DOMNodeList *props  = itemList->item(i)->getChildNodes();
00138     Histo h;
00139     std::string prefix = "", name = "";
00140     for(uint32_t j = 0; j < props->getLength(); j++) {
00141       std::string tname  = XMLString::transcode(props->item(j)->getNodeName());
00142       std::string tvalue = XMLString::transcode(props->item(j)->getTextContent());
00143       h.insert(std::make_pair(tname, tvalue));
00144       if(tname == "Name")   name   = tvalue;
00145       if(tname == "Prefix") prefix = tvalue;
00146     }
00147 
00148     if(!name.empty() && !prefix.empty()) {
00149       HistoDefMapIter it = collection.find(prefix);
00150       if( it == collection.end()) {
00151         HistoDef hd;
00152         hd.insert(make_pair(name, h));
00153         collection.insert(make_pair(prefix, hd)); 
00154       } else {
00155         it->second.insert(make_pair(name, h));
00156       }
00157     }
00158 
00159   }
00160 
00161   delete parser;
00162 
00163   std::ostringstream buffer;
00164   buffer << std::endl;
00165   for(HistoDefMapIter hdmi = collection.begin(); hdmi != collection.end(); hdmi++) {
00166     buffer << " # of " << hdmi->first << " histograms loaded =  " << hdmi->second.size() << std::endl;
00167   }
00168   LOGINFO("Histograms loaded") << buffer.str();
00169 
00170   return 0;
00171 }

const bool CSCMonitorModule::MEDDU ( const unsigned int  dduId,
const std::string  name,
MonitorElement *&  me 
) [private]

Checks if MonitorElement of DDU level is available and returns it.

Parameters:
dduId DDU number
name Histogram name
me Pointer to the histogram to be returned
Returns:
true if histogram was found and false otherwise

Definition at line 85 of file CSCMonitorModule_collection.cc.

References book(), dbe, DDU_FOLDER, CSCUtility::getDDUTag(), hitBookDDU, isMEValid(), LOGINFO, HLT_VtxMuL3::result, rootDir, and DQMStore::setCurrentFolder().

Referenced by monitorDDU().

00085                                                                                                       {
00086 
00087   std::string buffer;
00088 
00089   bool result = isMEValid(rootDir + DDU_FOLDER + CSCUtility::getDDUTag(dduId, buffer) + "/" + name, me);
00090   if (!result && hitBookDDU) {
00091     LOGINFO("DDU ME booking on demand") << "DDU id = " << dduId << " is being booked on demand (hitBookDDU = " << std::boolalpha << hitBookDDU << ")";
00092     dbe->setCurrentFolder(rootDir + DDU_FOLDER + CSCUtility::getDDUTag(dduId, buffer));
00093     book("DDU");
00094     result = isMEValid(rootDir + DDU_FOLDER + CSCUtility::getDDUTag(dduId, buffer) + "/" + name, me);
00095   }
00096 
00097   return result;
00098 
00099 }

const bool CSCMonitorModule::MEEMU ( const std::string  name,
MonitorElement *&  me 
) [private]

Find histograms (aka previous macros).

Checks if MonitorElement of EMU level is available and returns it.

Parameters:
name Histogram name
me Pointer to the histogram to be returned
Returns:
true if histogram was found and false otherwise

Definition at line 73 of file CSCMonitorModule_collection.cc.

References isMEValid(), rootDir, and SUMMARY_FOLDER.

Referenced by monitorCSC(), monitorDDU(), monitorExaminer(), and updateFracHistos().

00073                                                                             {
00074   return isMEValid(rootDir + SUMMARY_FOLDER + name, me);
00075 }

const bool CSCMonitorModule::MEEventInfo ( const std::string  name,
MonitorElement *&  me 
) [private]

Checks if MonitorElement of EventInfo level is available and returns it.

Parameters:
name Object name
me Pointer to the Object to be returned
Returns:
true if object was found and false otherwise

Definition at line 53 of file CSCMonitorModule_collection.cc.

References EVENTINFO_FOLDER, isMEValid(), and rootDir.

Referenced by updateFracHistos().

00053                                                                                   {
00054   return isMEValid(rootDir + EVENTINFO_FOLDER + name, me);
00055 }

const bool CSCMonitorModule::MEReportSummaryContents ( const std::string  name,
MonitorElement *&  me 
) [private]

Checks if MonitorElement of EventInfo/reportSummaryContents level is available and returns it.

Parameters:
name Object name
me Pointer to the Object to be returned
Returns:
true if object was found and false otherwise

Definition at line 63 of file CSCMonitorModule_collection.cc.

References isMEValid(), rootDir, and SUMCONTENTS_FOLDER.

Referenced by updateFracHistos().

00063                                                                                               {
00064   return isMEValid(rootDir + SUMCONTENTS_FOLDER + name, me);
00065 }

void CSCMonitorModule::monitorCSC ( const CSCEventData cscEvent,
const int32_t &  dduID 
) [private]

MonitorCSC function that grabs CSCEventData and processes it.

Parameters:
cscData CSC data
dduID DDU ID
Returns:

Definition at line 27 of file CSCMonitorModule_monitorCSC.cc.

References CSCEventData::alctHeader(), CSCEventData::cfebData(), HcalDataFrameFilter_impl::check(), CSCDMBHeader::crateID(), CSCEventData::dmbHeader(), CSCDMBHeader::dmbID(), CSCEventData::dmbTrailer(), MonitorElement::Fill(), CSCCFEBTimeSlice::get_L1A_number(), getCSCFromMap(), CSCDMBHeader::l1a(), CSCALCTHeader::L1Acc(), L1ANumber, CSCTMBHeader::L1ANumber(), me, MEEMU(), CSCEventData::nalct(), CSCEventData::nclct(), CSCEventData::tmbData(), and CSCTMBData::tmbHeader().

Referenced by monitorDDU().

00027                                                                                    {
00028 
00029   MonitorElement* me;
00030 
00031   // Unpacking DMB header and trailer
00032   const CSCDMBHeader* dmbHeader = cscEvent.dmbHeader();
00033   const CSCDMBTrailer* dmbTrailer = cscEvent.dmbTrailer();
00034   if (!dmbHeader || !dmbTrailer) return;
00035 
00036   // Unpacking of Chamber Identification number
00037   int crateID   = dmbHeader->crateID();
00038   int dmbID     = dmbHeader->dmbID();
00039   // int ChamberID      = (((crateID) << 4) + dmbID) & 0xFFF;
00040 
00041   bool L1A_out_of_sync = false;
00042 
00043   // To be switched on on CSC enter :) 
00044   // int iendcap  = -1;
00045   // int istation = -1;
00046   // int icfeb    = 0;
00047   // int ilayer   = 0;
00048   // CSCDetId cid = pcrate->detId( crateID, dmbID, icfeb, ilayer);
00049   // int id = cscMapping.chamber(iendcap, istation, crateID, dmbID, -1);
00050   // if (id == 0) return;
00051   // CSCDetId cid(id);
00052   
00053   int CSCtype = 0;
00054   int CSCposition = 0;
00055   if (!getCSCFromMap(crateID, dmbID, CSCtype, CSCposition )) return;
00056 
00057   // Top level L1A synchronization
00058   int dmbHeaderL1A = dmbHeader->l1a()%64;
00059   if ((int)(dmbHeaderL1A - (int)(L1ANumber%64)) != 0) L1A_out_of_sync = true;
00060 
00061   if (CSCtype && CSCposition && MEEMU("CSC_Unpacked", me)) me->Fill(CSCposition, CSCtype);
00062 
00063   if (MEEMU("DMB_Unpacked", me)) me->Fill(crateID, dmbID);
00064 
00065   if (cscEvent.nalct()) {
00066     if (cscEvent.alctHeader()) {
00067       const CSCALCTHeader* alctHeader = cscEvent.alctHeader();
00068       if ((int)(alctHeader->L1Acc()%64 - dmbHeaderL1A) != 0) L1A_out_of_sync = true;
00069     }
00070   }
00071 
00072   //
00073   // Checking CFEBs
00074   //
00075  
00076   int NumberOfUnpackedCFEBs = 0;
00077   const int N_CFEBs  = 5;
00078   const int N_Layers = 6;
00079 
00080   CSCCFEBData* cfebData[5];
00081   CSCCFEBTimeSlice* timeSlice[5][16];
00082 
00083   for(int nCFEB = 0; nCFEB < N_CFEBs; ++nCFEB) {
00084 
00085     cfebData[nCFEB] = cscEvent.cfebData(nCFEB);
00086 
00087     if (cfebData[nCFEB] !=0) {
00088 
00089       if (!cfebData[nCFEB]->check()) continue;
00090 
00091       NumberOfUnpackedCFEBs++;
00092       int NmbTimeSamples= (cfebData[nCFEB])->nTimeSamples();
00093 
00094       for(int nLayer = 1; nLayer <= N_Layers; ++nLayer) {
00095         for(int nSample = 0; nSample < NmbTimeSamples; ++nSample) {
00096 
00097           timeSlice[nCFEB][nSample] = (CSCCFEBTimeSlice * )((cfebData[nCFEB])->timeSlice(nSample));
00098           if ((int)((timeSlice[nCFEB][nSample]->get_L1A_number()) - dmbHeaderL1A) != 0) {
00099             L1A_out_of_sync = true;
00100           }
00101 
00102         }
00103       }
00104 
00105     }
00106   }
00107 
00108   // Checking L1A out of sync occurancies
00109   if (cscEvent.nclct() && cscEvent.nalct()) {
00110     if (cscEvent.alctHeader()) {
00111       if (cscEvent.tmbData()) {
00112         CSCTMBData* tmbData = cscEvent.tmbData();
00113         if (tmbData->tmbHeader()) {
00114           CSCTMBHeader* tmbHeader = tmbData->tmbHeader();
00115           if (((int)(tmbHeader->L1ANumber()%64) - dmbHeaderL1A) != 0) L1A_out_of_sync = true;
00116         }
00117       }
00118     }
00119   }
00120 
00121   if (CSCtype && CSCposition && L1A_out_of_sync && MEEMU("CSC_L1A_out_of_sync", me)) {
00122     me->Fill(CSCposition, CSCtype);
00123   }
00124 
00125 }

void CSCMonitorModule::monitorDCC ( const CSCDCCEventData dccEvent  )  [private]

MonitorDCC function that grabs DCCEventData and processes it.

Parameters:
dccData DCC data
Returns:

Definition at line 26 of file CSCMonitorModule_monitorDCC.cc.

References CSCDCCEventData::dduData(), int, and monitorDDU().

Referenced by monitorEvent().

00026                                                                 {
00027   const std::vector<CSCDDUEventData> & dduData = dccEvent.dduData();
00028 
00029   for (int ddu = 0; ddu < (int)dduData.size(); ++ddu) {
00030     monitorDDU(dduData[ddu]);
00031   }
00032 
00033 }

void CSCMonitorModule::monitorDDU ( const CSCDDUEventData dduEvent  )  [private]

MonitorDDU function that grabs DDUEventData and processes it.

Parameters:
dduData DDU data
Returns:

Definition at line 26 of file CSCMonitorModule_monitorDDU.cc.

References CSCDDUHeader::bxnum(), CSCDDUEventData::cscData(), CSCDDUHeader::dmb_dav(), CSCDDUTrailer::dmb_full(), CSCDDUTrailer::dmb_warn(), CSCDDUTrailer::errorstat(), MonitorElement::Fill(), MonitorElement::getBinContent(), CSCDDUEventData::header(), i, int, it, L1ANumber, L1ANumbers, CSCDDUHeader::live_cscs(), CSCDDUHeader::lvl1num(), me, MEDDU(), MEEMU(), monitorCSC(), CSCDDUHeader::ncsc(), nEvents, NULL, MonitorElement::setBinContent(), MonitorElement::setEntries(), CSCDDUEventData::size(), CSCDDUHeader::source_id(), CSCDDUEventData::trailer(), and CSCDDUTrailer::wordcount().

Referenced by monitorDCC().

00026                                                                 {
00027 
00028   MonitorElement* me = NULL;
00029    
00030   // Get DDU header and trailer objects
00031   CSCDDUHeader dduHeader  = dduEvent.header();
00032   CSCDDUTrailer dduTrailer = dduEvent.trailer();
00033 
00034   int dduID = dduHeader.source_id()&0xFF; // Only 8bits are significant; format of DDU id is Dxx;
00035 
00036   if (MEEMU("All_DDUs_in_Readout", me)) me->Fill(dduID);
00037 
00038   if (MEDDU(dduID, "Buffer_Size", me)) me->Fill(dduEvent.size());
00039 
00040   int trl_word_count = dduTrailer.wordcount();
00041   if (MEDDU(dduID, "Word_Count", me)) me->Fill(trl_word_count);
00042   if (trl_word_count > 0) {
00043     if (MEEMU("All_DDUs_Event_Size", me)) me->Fill(dduID, log10((double)trl_word_count));
00044   }
00045 
00046   if (MEEMU("All_DDUs_Average_Event_Size", me)) me->Fill(dduID, trl_word_count);
00047 
00048   uint32_t BXN=dduHeader.bxnum();
00049   if (MEDDU(dduID, "BXN", me)) me->Fill((double) BXN);
00050 
00051   std::map<uint32_t,uint32_t>::iterator it = L1ANumbers.find(dduID);
00052   if(it == L1ANumbers.end()) {
00053     L1ANumbers[dduID] = (int)(dduHeader.lvl1num());
00054   } else {
00055 
00056     int L1ANumber_previous_event = L1ANumbers[dduID];
00057     L1ANumbers[dduID] = (int)(dduHeader.lvl1num());
00058     int L1A_inc = L1ANumbers[dduID] - L1ANumber_previous_event;
00059 
00060     if (MEDDU(dduID, "L1A_Increment", me)) me->Fill(L1A_inc);
00061 
00062     if (MEEMU("All_DDUs_L1A_Increment", me)) {
00063       if (L1A_inc > 100000) L1A_inc = 19;
00064       else if (L1A_inc > 30000) L1A_inc = 18;
00065       else if (L1A_inc > 10000) L1A_inc = 17;
00066       else if (L1A_inc > 3000)  L1A_inc = 16;
00067       else if (L1A_inc > 1000)  L1A_inc = 15;
00068       else if (L1A_inc > 300)   L1A_inc = 14;
00069       else if (L1A_inc > 100)   L1A_inc = 13;
00070       else if (L1A_inc > 30)    L1A_inc = 12;
00071       else if (L1A_inc > 10)    L1A_inc = 11;
00072       me->Fill(dduID, L1A_inc);
00073     }
00074   }
00075 
00076   L1ANumber = L1ANumbers[dduID];
00077 
00078   int dmb_dav_header      = dduHeader.dmb_dav();
00079   int ddu_connected_inputs= dduHeader.live_cscs();
00080   int csc_error_state     = dduTrailer.dmb_full()&0x7FFF; // Only 15 inputs for DDU
00081   int csc_warning_state   = dduTrailer.dmb_warn()&0x7FFF; // Only 15 inputs for DDU
00082   int dmb_active_header   = (int)(dduHeader.ncsc()&0xF);
00083   int dmb_dav_header_cnt  = 0;
00084   int ddu_connected_inputs_cnt = 0;
00085 
00086   double freq = 0;
00087   for (int i=0; i<15; ++i) {
00088 
00089     if ((dmb_dav_header>>i) & 0x1) {
00090       dmb_dav_header_cnt++;
00091       if (MEDDU(dduID, "DMB_DAV_Header_Occupancy_Rate", me)) {
00092         me->Fill(i + 1);
00093         freq = (100.0 * me->getBinContent(i + 1)) / nEvents;
00094         if (MEDDU(dduID, "DMB_DAV_Header_Occupancy", me)) me->setBinContent(i + 1, freq);
00095       }
00096       if (MEEMU("All_DDUs_Inputs_with_Data", me)) me->Fill(dduID, i);
00097     }
00098 
00099     if( (ddu_connected_inputs>>i) & 0x1 ){
00100       ddu_connected_inputs_cnt++;
00101       if (MEDDU(dduID, "DMB_Connected_Inputs_Rate", me)) {
00102         me->Fill(i + 1);
00103         freq = (100.0 * me->getBinContent(i + 1)) / nEvents;
00104         if (MEDDU(dduID, "DMB_Connected_Inputs", me)) me->setBinContent(i + 1, freq);
00105       }
00106       if (MEEMU("All_DDUs_Live_Inputs", me)) me->Fill(dduID, i);
00107     }
00108 
00109     if( (csc_error_state>>i) & 0x1 ){
00110       if (MEDDU(dduID, "CSC_Errors_Rate", me)) {
00111         me->Fill(i + 1);
00112         freq = (100.0 * me->getBinContent(i + 1)) / nEvents;
00113         if (MEDDU(dduID, "CSC_Errors", me)) me->setBinContent(i + 1, freq);
00114       }
00115       if (MEEMU("All_DDUs_Inputs_Errors", me)) me->Fill(dduID, i+2);
00116     }
00117 
00118     if( (csc_warning_state>>i) & 0x1 ){
00119       if (MEDDU(dduID, "CSC_Warnings_Rate", me)) {
00120         me->Fill(i + 1);
00121         freq = (100.0 * me->getBinContent(i + 1)) / nEvents;
00122         if (MEDDU(dduID, "CSC_Warnings", me)) me->setBinContent(i + 1, freq);
00123       }
00124       if (MEEMU("All_DDUs_Inputs_Warnings", me)) me->Fill(dduID, i+2);
00125     }
00126 
00127   }
00128 
00129   if (MEEMU("All_DDUs_Average_Live_Inputs", me)) me->Fill(dduID, ddu_connected_inputs_cnt);
00130 
00131   if (MEEMU("All_DDUs_Average_Inputs_with_Data", me)) me->Fill(dduID, dmb_dav_header_cnt);
00132 
00133   if (MEEMU("All_DDUs_Inputs_Errors", me)) {
00134     if (csc_error_state > 0) me->Fill(dduID, 1);   // Any Input
00135     else me->Fill(dduID, 0);                       // No errors
00136   }
00137 
00138   if (MEEMU("All_DDUs_Inputs_Warnings", me)) {
00139     if (csc_warning_state > 0) me->Fill(dduID, 1); // Any Input
00140     else me->Fill(dduID, 0);                       // No warnings
00141   }
00142 
00143   if (MEDDU(dduID,"DMB_DAV_Header_Occupancy",me)) me->setEntries(nEvents);
00144 
00145   if (MEDDU(dduID, "DMB_Connected_Inputs", me)) me->setEntries(nEvents);
00146 
00147   if (MEDDU(dduID, "CSC_Errors", me)) me->setEntries(nEvents);
00148 
00149   if (MEDDU(dduID, "CSC_Warnings", me)) me->setEntries(nEvents);
00150 
00151   if (MEDDU(dduID, "DMB_Active_Header_Count", me)) me->Fill(dmb_active_header);
00152 
00153   if (MEDDU(dduID, "DMB_DAV_Header_Count_vs_DMB_Active_Header_Count", me)) me->Fill(dmb_active_header, dmb_dav_header_cnt);
00154 
00155   uint32_t trl_errorstat = dduTrailer.errorstat();
00156   if (dmb_dav_header_cnt==0) trl_errorstat &= ~0x20000000; // Ignore No Good DMB CRC bit of no DMB is present
00157   for (int i=0; i<32; i++) {
00158     if ((trl_errorstat>>i) & 0x1) {
00159       if (MEDDU(dduID, "Trailer_ErrorStat_Rate", me)) { 
00160         me->Fill(i);
00161         double freq = (100.0 * me->getBinContent(i + 1)) / nEvents;
00162         if (MEDDU(dduID, "Trailer_ErrorStat_Frequency", me)) me->setBinContent(i + 1, freq);
00163       }
00164       if (MEDDU(dduID, "Trailer_ErrorStat_Table", me)) me->Fill(0., i);
00165     }
00166   }
00167   if (MEEMU("All_DDUs_Trailer_Errors", me)) {
00168     if (trl_errorstat) {
00169       me->Fill(dduID, 1); // Any Error
00170       for (int i=0; i<32; i++) {
00171         if ((trl_errorstat>>i) & 0x1) {
00172           me->Fill(dduID, i+2);
00173         }
00174       }
00175     } else {
00176       me->Fill(dduID, 0); // No Errors
00177     }
00178   }
00179 
00180   if (MEDDU(dduID, "Trailer_ErrorStat_Table", me)) me->setEntries(nEvents);
00181 
00182   if (MEDDU(dduID, "Trailer_ErrorStat_Frequency", me)) me->setEntries(nEvents);
00183 
00184   std::vector<CSCEventData> chamberDatas = dduEvent.cscData();
00185 
00186   int nCSCs = chamberDatas.size();
00187   if (nCSCs != dduHeader.ncsc()) {
00188     // == Current trick to maximize number of unpacked CSCs.
00189     // == Unpacker gives up after screwed chamber.
00190     // == So we need to exclude it from the list by reducing chamberDatas vector size
00191     nCSCs-=1;
00192     return;
00193   }
00194 
00195   uint32_t unpackedDMBcount = 0;
00196 
00197   for(unsigned int i=0; i < chamberDatas.size(); i++) {
00198     unpackedDMBcount++;
00199     monitorCSC(chamberDatas[i], dduID);
00200   }
00201 
00202   if (MEDDU(dduID, "DMB_unpacked_vs_DAV", me)) me->Fill(dmb_active_header, unpackedDMBcount);
00203 
00204 }

void CSCMonitorModule::monitorEvent ( const edm::Event e  )  [private]

Histogram filling and calculation methods.

Monitoring function that receives Events.

Parameters:
e Event
c EventSetup
Returns:

Definition at line 28 of file CSCMonitorModule_monitorEvent.cc.

References bCSCEventCounted, CSCDCCExaminer::check(), CSCDCCExaminer::crcALCT(), CSCDCCExaminer::crcCFEB(), CSCDCCExaminer::crcTMB(), data, FEDRawData::data(), lat::endl(), examinerCRCKey, examinerOutput, edm::Event::getByLabel(), FEDNumbering::getCSCFEDIds(), id, inputObjectsTag, LOGINFO, monitorDCC(), monitorExaminer(), nCSCEvents, nEvents, CSCDCCExaminer::output1(), CSCDCCExaminer::output2(), and FEDRawData::size().

Referenced by analyze().

00028                                                     {
00029 
00030   nEvents++;
00031   bCSCEventCounted = false;
00032   if(nEvents %1000 == 0) {
00033     LOGINFO("monitorEvent") << " # of events = " << nEvents << ", # of CSC events = " << nCSCEvents << std::endl;
00034   }
00035 
00036   // Get a handle to the FED data collection
00037   // actualy the FED_EVENT_LABEL part of the event
00038   edm::Handle<FEDRawDataCollection> rawdata;
00039   if (!e.getByLabel( inputObjectsTag, rawdata)) {
00040     // LOGWARNING("e.getByLabel") << "No product: " << inputObjectsTag << " in FEDRawDataCollection";
00041     return; 
00042   }
00043 
00044   // Lets run through the DCC's 
00045   for (int id = FEDNumbering::getCSCFEDIds().first; id <= FEDNumbering::getCSCFEDIds().second; ++id) {
00046 
00047     // Implement and set examiner
00048     CSCDCCExaminer examiner;
00049 
00050     if(examinerCRCKey.test(0)) examiner.crcALCT(1);
00051     if(examinerCRCKey.test(1)) examiner.crcCFEB(1);
00052     if(examinerCRCKey.test(2)) examiner.crcTMB(1);
00053 
00054     if(examinerOutput) {
00055       examiner.output1().show();
00056       examiner.output2().show();
00057     } else {
00058       examiner.output1().hide();
00059       examiner.output2().hide();
00060     }
00061 
00062     // Take a reference to this FED's data and
00063     // construct the DCC data object
00064     const FEDRawData& fedData = rawdata->FEDData(id);
00065 
00066     // LOGWARNING("MonitorEvent") << "Event No." << nEvents << " size = " << fedData.size() << std::endl;
00067 
00068     //if fed has data then unpack it
00069     if ( fedData.size() >= 32 ) {
00070 
00071       // Fed contains valid CSC data - lets count this in
00072       if (!bCSCEventCounted) {
00073         nCSCEvents++;
00074         bCSCEventCounted = true;
00075       }
00076        
00077       const short unsigned int *data = (short unsigned int *) fedData.data();
00078 
00079       // If Event has not yet been passed via Examiner - lets do it now.
00080       // Examiner will set up the flag if event is good or not.
00081       if (examiner.check(data, long(fedData.size()/2)) < 0 ) {
00082         // No ddu trailer found - force checker to summarize errors by adding artificial trailer
00083         const uint16_t dduTrailer[4] = { 0x8000, 0x8000, 0xFFFF, 0x8000 };
00084         data = dduTrailer;
00085         examiner.check(data, uint32_t(4));
00086       }
00087 
00088       bool goodEvent = monitorExaminer(examiner);
00089      
00090       // If event is OK then proceed with other procedures...
00091       if (goodEvent) {
00092         CSCDCCEventData dccData((short unsigned int *) fedData.data());
00093         monitorDCC(dccData);
00094       } 
00095 
00096      // LOGWARNING("MonitorEvent") << "Event No." << nEvents << " is " << std::boolalpha << goodEvent << std::endl;
00097 
00098     }
00099   }
00100 
00101 }

bool CSCMonitorModule::monitorExaminer ( CSCDCCExaminer examiner  )  [private]

Examiner object analyzer.

Parameters:
examiner Examiner object to monitor
Returns:
true if event is good following examiner data, false otherwise

Definition at line 109 of file CSCMonitorModule_monitorEvent.cc.

References CSCDCCExaminer::errors(), CSCDCCExaminer::errorsDetailed(), CSCDCCExaminer::errorsForDDU(), examinerMask, MonitorElement::Fill(), getCSCFromMap(), i, CSCDCCExaminer::listOfDDUs(), me, MEEMU(), CSCDCCExaminer::nERRORS, NULL, CSCDCCExaminer::payloadDetailed(), CSCDCCExaminer::statusDetailed(), and CSCDCCExaminer::warnings().

Referenced by monitorEvent().

00109                                                                {
00110 
00111   MonitorElement* me = NULL;
00112 
00113   if (MEEMU("All_DDUs_Format_Errors", me)) {
00114     std::vector<int> DDUs = examiner.listOfDDUs();
00115     for (std::vector<int>::iterator ddu_itr = DDUs.begin(); ddu_itr != DDUs.end(); ++ddu_itr) {
00116       if (*ddu_itr != 0xFFF) {
00117         long errs = examiner.errorsForDDU(*ddu_itr);
00118         int dduID = (*ddu_itr)&0xFF;
00119         std::string dduTag = Form("DDU_%d", dduID);
00120         if (errs != 0) {
00121           for(int i=0; i<examiner.nERRORS; i++) { // run over all errors
00122             if ((errs>>i) & 0x1 ) me->Fill(dduID, i+1);
00123           }
00124         } else {
00125           me->Fill(dduID, 0);
00126         }
00127       }
00128     }
00129   }
00130 
00131   bool goodEvent = true;
00132 
00133   if ((examiner.errors() & examinerMask) > 0) {
00134     goodEvent = false;
00135   }
00136 
00137   std::map<int,long> payloads = examiner.payloadDetailed();
00138   for(std::map<int,long>::const_iterator chamber = payloads.begin(); chamber != payloads.end(); chamber++) {
00139 
00140     //int ChamberID = chamber->first;
00141     int CrateID = (chamber->first>>4) & 0xFF;
00142     int DMBSlot = chamber->first & 0xF;
00143 
00144     if (CrateID == 255) { continue; }
00145 
00146     if (MEEMU("DMB_Reporting", me)) me->Fill(CrateID, DMBSlot);
00147 
00148     int CSCtype   = 0;
00149     int CSCposition = 0;
00150     if (!getCSCFromMap(CrateID, DMBSlot, CSCtype, CSCposition )) continue;
00151 
00152     if (CSCtype && CSCposition && MEEMU("CSC_Reporting", me)) me->Fill(CSCposition, CSCtype);
00153 
00154     long payload = chamber->second;
00155     int cfeb_dav = (payload>>7) & 0x1F;
00156     int alct_dav = (payload>>5) & 0x1;
00157     int tmb_dav = (payload>>6) & 0x1; 
00158       
00159     if (alct_dav == 0) {
00160       if (CSCtype && CSCposition && MEEMU("CSC_wo_ALCT", me)) me->Fill(CSCposition, CSCtype);
00161       if (MEEMU("DMB_wo_ALCT", me)) me->Fill(CrateID, DMBSlot);
00162     }
00163      
00164     if (tmb_dav == 0) {
00165       if (CSCtype && CSCposition && MEEMU("CSC_wo_CLCT", me)) me->Fill(CSCposition, CSCtype);
00166       if (MEEMU("DMB_wo_CLCT", me)) me->Fill(CrateID, DMBSlot);
00167     }
00168 
00169     if (cfeb_dav == 0) {
00170       if (CSCtype && CSCposition && MEEMU("CSC_wo_CFEB", me)) me->Fill(CSCposition, CSCtype);
00171       if (MEEMU("DMB_wo_CFEB", me)) me->Fill(CrateID,DMBSlot);
00172     }
00173       
00174   }
00175 
00176   if ((examiner.errors() != 0) || (examiner.warnings() != 0)) {
00177 
00178     std::map<int,long> checkerErrors = examiner.errorsDetailed();
00179     for( std::map<int,long>::const_iterator chamber = checkerErrors.begin(); chamber != checkerErrors.end() ; chamber++ ){
00180     
00181       //int ChamberID = chamber->first;
00182       int CrateID = (chamber->first>>4) & 0xFF;
00183       int DMBSlot = chamber->first & 0xF;
00184 
00185       if ((CrateID == 255) || (chamber->second & 0x80)) continue; // = Skip chamber detection if DMB header is missing (Error code 6)
00186 
00187       bool isCSCError = false;
00188       for(int bit=5; bit<24; bit++) {
00189         if( chamber->second & (1<<bit) ) {
00190           isCSCError = true;
00191         }
00192         if( chamber->second & (1<<25) ) {
00193           isCSCError = true;
00194         }
00195       }
00196 
00197       if (isCSCError && MEEMU("DMB_Format_Errors", me)) {
00198         me->Fill(CrateID, DMBSlot);
00199       }
00200 
00201       if (goodEvent && isCSCError && MEEMU("DMB_Unpacked_with_errors", me)) {
00202         me->Fill(CrateID, DMBSlot);
00203       }
00204 
00205       int CSCtype   = 0;
00206       int CSCposition = 0;
00207       if (!getCSCFromMap(CrateID, DMBSlot, CSCtype, CSCposition)) continue;
00208 
00209       if (isCSCError && CSCtype && CSCposition && MEEMU("CSC_Format_Errors", me)) {
00210         me->Fill(CSCposition, CSCtype);
00211       }
00212 
00213       if (goodEvent && isCSCError && CSCtype && CSCposition && MEEMU("CSC_Unpacked_with_errors", me)) {
00214         me->Fill(CSCposition, CSCtype);
00215       }
00216 
00217     }
00218 
00219   }
00220   
00221   std::map<int,long> statuses = examiner.statusDetailed();
00222   for(std::map<int,long>::const_iterator chamber = statuses.begin(); chamber != statuses.end(); chamber++) {
00223 
00224     //int ChamberID = chamber->first;
00225     int CrateID = (chamber->first>>4) & 0xFF;
00226     int DMBSlot = chamber->first & 0xF;
00227     std::string cscTag(Form("CSC_%03d_%02d", CrateID, DMBSlot));
00228     if (CrateID == 255) {continue;}
00229     
00230     int CSCtype   = 0;
00231     int CSCposition = 0;
00232     if (!getCSCFromMap(CrateID, DMBSlot, CSCtype, CSCposition )) continue;
00233 
00234     int anyInputFull = chamber->second & 0x3F;
00235     if(anyInputFull){
00236       if (CSCtype && CSCposition && MEEMU("CSC_DMB_input_fifo_full", me)) me->Fill(CSCposition, CSCtype);
00237       if (MEEMU("DMB_input_fifo_full", me)) me->Fill(CrateID, DMBSlot);
00238     }
00239 
00240     int anyInputTO = (chamber->second >> 7) & 0x3FFF;
00241     if(anyInputTO){
00242       if (CSCtype && CSCposition && MEEMU("CSC_DMB_input_timeout", me)) me->Fill(CSCposition, CSCtype);
00243       if (MEEMU("DMB_input_timeout", me)) me->Fill(CrateID, DMBSlot);
00244     }
00245 
00246     if (chamber->second & (1<<22)) {
00247       if (MEEMU("DMB_Format_Warnings", me)) me->Fill(CrateID, DMBSlot);
00248       if (CSCtype && CSCposition && MEEMU("CSC_Format_Warnings", me)) me->Fill(CSCposition, CSCtype);
00249     }
00250 
00251   }
00252 
00253   return goodEvent;
00254 }

void CSCMonitorModule::printCollection (  )  [private]

Print collection of available histograms and their parameters.

Parameters:
@return 

Definition at line 313 of file CSCMonitorModule_collection.cc.

References collection, lat::endl(), and LOGINFO.

00313                                       {
00314 
00315   std::ostringstream buffer;
00316   for(HistoDefMapIter hdmi = collection.begin(); hdmi != collection.end(); hdmi++) {
00317     buffer << hdmi->first << " [" << std::endl;
00318     for(HistoDefIter hdi = hdmi->second.begin(); hdi != hdmi->second.end(); hdi++) {
00319       buffer << "   " << hdi->first << " [" << std::endl;
00320       for(HistoIter hi = hdi->second.begin(); hi != hdi->second.end(); hi++) {
00321         buffer << "     " << hi->first << " = " << hi->second << std::endl;
00322       }
00323       buffer << "   ]" << std::endl;
00324     }
00325     buffer << " ]" << std::endl;
00326   }
00327   LOGINFO("Histogram collection") << buffer.str();
00328 
00329 }

void CSCMonitorModule::setup (  )  [protected]

Definition at line 90 of file CSCMonitorModule.cc.

References book(), DQMStore::bookFloat(), dbe, effParameters, EVENTINFO_FOLDER, MonitorElement::Fill(), fractUpdateEvF, fractUpdateKey, cscdqm::Summary::getDetector(), edm::ParameterSet::getParameterNamesForType(), edm::ParameterSet::getUntrackedParameter(), init, iter, LOGINFO, cscdqm::Address::mask, me, N_SIDES, N_STATIONS, cscdqm::Address::ring, rootDir, DQMStore::setCurrentFolder(), cscdqm::Address::side, cscdqm::Address::station, SUMCONTENTS_FOLDER, summary, and SUMMARY_FOLDER.

Referenced by analyze().

00090                              {
00091     
00092     // Base folder for the contents of this job
00093     dbe->setCurrentFolder(rootDir + SUMMARY_FOLDER);
00094     
00095     // Book EMU level histograms
00096     book("EMU");
00097     
00098     // Book detector summary histograms and stuff
00099     MonitorElement* me;
00100     
00101     // reportSummary stuff booking
00102     dbe->setCurrentFolder(rootDir + EVENTINFO_FOLDER);
00103     book("EventInfo");
00104     me = dbe->bookFloat("reportSummary");
00105     me->Fill(-1.0);
00106     
00107     // reportSummaryContents booking
00108     dbe->setCurrentFolder(rootDir + SUMCONTENTS_FOLDER);
00109     cscdqm::Address adr;
00110     adr.mask.chamber = adr.mask.layer = adr.mask.cfeb = adr.mask.hv = false;
00111     adr.mask.side = true;
00112     for (adr.side = 1; adr.side <= N_SIDES; adr.side++) {
00113         adr.mask.station = adr.mask.ring = false;
00114         me = dbe->bookFloat(summary.getDetector().AddressName(adr));
00115         me->Fill(-1.0);
00116         adr.mask.station = true;
00117         for (adr.station = 1; adr.station <= N_STATIONS; adr.station++) {
00118             adr.mask.ring = false;
00119             dbe->bookFloat(summary.getDetector().AddressName(adr));
00120             me->Fill(-1.0);
00121             if (summary.getDetector().NumberOfRings(adr.station) > 1) {
00122                 adr.mask.ring = true;
00123                 for (adr.ring = 1; adr.ring <= summary.getDetector().NumberOfRings(adr.station); adr.ring++) {
00124                     dbe->bookFloat(summary.getDetector().AddressName(adr));
00125                     me->Fill(-1.0);
00126                 }
00127             }
00128         }
00129     }
00130     
00131     // Write down STATS parameters
00132     dbe->setCurrentFolder(rootDir + EVENTINFO_FOLDER + "effParameters");
00133     std::vector<std::string> effParamNames = effParameters.getParameterNamesForType<float>(false);
00134     for (std::vector<std::string>::iterator iter = effParamNames.begin(); iter != effParamNames.end(); iter++) {
00135         me = dbe->bookFloat(*iter);
00136         me->Fill(effParameters.getUntrackedParameter<double>(*iter, -1.0));
00137     }
00138     
00139     LOGINFO("Fraction histograms") << " updateKey = " << fractUpdateKey << ", update on events (freq) = " << fractUpdateEvF;
00140     
00141     this->init = true;
00142     
00143 }

void CSCMonitorModule::updateFracHistos (  )  [private]

Definition at line 22 of file CSCMonitorModule_updateFracHistos.cc.

References cscdqm::CFEB_BWORDS, effParameters, err, cscdqm::FIFOFULL_ERR, MonitorElement::Fill(), cscdqm::FORMAT_ERR, cscdqm::Summary::getDetector(), cscdqm::Summary::GetEfficiencyHW(), MonitorElement::getRefRootObject(), MonitorElement::getTH1(), edm::ParameterSet::getUntrackedParameter(), HWSTATUSERRORBITS, cscdqm::INPUTTO_ERR, cscdqm::L1SYNC_ERR, cscdqm::Address::mask, MEEMU(), MEEventInfo(), MEReportSummaryContents(), N_SIDES, N_STATIONS, cscdqm::NODATA_ALCT, cscdqm::NODATA_CFEB, cscdqm::NODATA_CLCT, NULL, cscdqm::Summary::ReadErrorChambers(), cscdqm::Summary::ReadReportingChambers(), cscdqm::Summary::ReadReportingChambersRef(), cscdqm::Address::ring, cscdqm::Address::side, cscdqm::Address::station, summary, dimuonsSequences_cff::threshold, tmp, cscdqm::Summary::Write(), cscdqm::Summary::WriteChamberState(), and cscdqm::Summary::WriteMap().

Referenced by analyze(), beginLuminosityBlock(), and endRun().

00022                                         {
00023 
00024   MonitorElement *me1 = NULL, *me2 = NULL, *me3 = NULL;
00025 
00026   //
00027   // Calculate Fractional Histograms
00028   //
00029 
00030   if (MEEMU("DMB_Format_Errors_Fract", me1) && MEEMU("DMB_Reporting", me2) && MEEMU("DMB_Format_Errors", me3)) 
00031     me1->getTH1()->Divide(me3->getTH1(), me2->getTH1());
00032 
00033   if (MEEMU("CSC_Format_Errors_Fract", me1) && MEEMU("CSC_Reporting", me2) && MEEMU("CSC_Format_Errors", me3)) 
00034     me1->getTH1()->Divide(me3->getTH1(), me2->getTH1());
00035 
00036   if (MEEMU("DMB_Unpacked_Fract", me1) && MEEMU("DMB_Reporting", me2) && MEEMU("DMB_Unpacked", me3)) 
00037     me1->getTH1()->Divide(me3->getTH1(), me2->getTH1());
00038 
00039   if (MEEMU("CSC_Unpacked_Fract", me1) && MEEMU("CSC_Reporting", me2) && MEEMU("CSC_Unpacked", me3)) 
00040     me1->getTH1()->Divide(me3->getTH1(), me2->getTH1());
00041 
00042   if (MEEMU("DMB_wo_ALCT_Fract", me1) && MEEMU("DMB_Reporting", me2) && MEEMU("DMB_wo_ALCT", me3)) 
00043     me1->getTH1()->Divide(me3->getTH1(), me2->getTH1());
00044 
00045   if (MEEMU("CSC_wo_ALCT_Fract", me1) && MEEMU("CSC_Reporting", me2) && MEEMU("CSC_wo_ALCT", me3)) 
00046     me1->getTH1()->Divide(me3->getTH1(), me2->getTH1());
00047 
00048   if (MEEMU("DMB_wo_CLCT_Fract", me1) && MEEMU("DMB_Reporting", me2) && MEEMU("DMB_wo_CLCT", me3)) 
00049     me1->getTH1()->Divide(me3->getTH1(), me2->getTH1());
00050 
00051   if (MEEMU("CSC_wo_CLCT_Fract", me1) && MEEMU("CSC_Reporting", me2) && MEEMU("CSC_wo_CLCT", me3)) 
00052     me1->getTH1()->Divide(me3->getTH1(), me2->getTH1());
00053 
00054   if (MEEMU("DMB_wo_CFEB_Fract", me1) && MEEMU("DMB_Reporting", me2) && MEEMU("DMB_wo_CFEB", me3)) 
00055     me1->getTH1()->Divide(me3->getTH1(), me2->getTH1());
00056 
00057   if (MEEMU("CSC_wo_CFEB_Fract", me1) && MEEMU("CSC_Reporting", me2) && MEEMU("CSC_wo_CFEB", me3)) 
00058     me1->getTH1()->Divide(me3->getTH1(), me2->getTH1());
00059 
00060   if (MEEMU("CSC_DMB_input_fifo_full_Fract", me1) && MEEMU("CSC_Reporting", me2) && MEEMU("CSC_DMB_input_fifo_full", me3)) 
00061     me1->getTH1()->Divide(me3->getTH1(), me2->getTH1());
00062 
00063   if (MEEMU("DMB_input_fifo_full_Fract", me1) && MEEMU("DMB_Reporting", me2) && MEEMU("DMB_input_fifo_full", me3)) 
00064     me1->getTH1()->Divide(me3->getTH1(), me2->getTH1());
00065 
00066   if (MEEMU("CSC_DMB_input_timeout_Fract", me1) && MEEMU("CSC_Reporting", me2) && MEEMU("CSC_DMB_input_timeout", me3)) 
00067     me1->getTH1()->Divide(me3->getTH1(), me2->getTH1());
00068 
00069   if (MEEMU("DMB_input_timeout_Fract", me1) && MEEMU("DMB_Reporting", me2) && MEEMU("DMB_input_timeout", me3)) 
00070     me1->getTH1()->Divide(me3->getTH1(), me2->getTH1());
00071 
00072   if (MEEMU("CSC_L1A_out_of_sync_Fract", me1) && MEEMU("CSC_Reporting", me2) && MEEMU("CSC_L1A_out_of_sync", me3)) 
00073     me1->getTH1()->Divide(me3->getTH1(), me2->getTH1());
00074 
00075   if (MEEMU("DMB_Format_Warnings_Fract", me1) && MEEMU("DMB_Reporting", me2) && MEEMU("DMB_Format_Warnings", me3))
00076     me1->getTH1()->Divide(me3->getTH1(), me2->getTH1());
00077 
00078   if (MEEMU("CSC_Format_Warnings_Fract", me1) && MEEMU("CSC_Reporting", me2) && MEEMU("CSC_Format_Warnings", me3))
00079     me1->getTH1()->Divide(me3->getTH1(), me2->getTH1());
00080 
00081   //
00082   // Set detector information
00083   //
00084   
00085   if (MEEMU("CSC_Reporting", me1)) {
00086 
00087     // Getting reference and reporting histograms for CSC_Reporting
00088     const TH2* ref = dynamic_cast<const TH2*>(me1->getRefRootObject());
00089     const TH2* rep = dynamic_cast<const TH2*>(me1->getTH1());
00090     if (ref) {
00091       summary.ReadReportingChambersRef(rep, ref, 
00092         effParameters.getUntrackedParameter<double>("threshold_cold", 0.1), 
00093         effParameters.getUntrackedParameter<double>("sigfail_cold"  , 5.0), 
00094         effParameters.getUntrackedParameter<double>("threshold_hot" , 0.1), 
00095         effParameters.getUntrackedParameter<double>("sigfail_hot"   , 2.0));
00096     } else {
00097       summary.ReadReportingChambers(rep, 1.0);
00098     }
00099 
00100     double threshold = effParameters.getUntrackedParameter<double>("threshold_err", 0.1);
00101     double sigfail   = effParameters.getUntrackedParameter<double>("sigfail_err", 5.0);
00102 
00103     if (MEEMU("CSC_Format_Errors", me2)) {
00104       const TH2* err = dynamic_cast<TH2*>(me2->getTH1());
00105       summary.ReadErrorChambers(rep, err, cscdqm::FORMAT_ERR, threshold, sigfail);
00106     }
00107 
00108     if (MEEMU("CSC_L1A_out_of_sync", me2)) {
00109       const TH2* err = dynamic_cast<const TH2*>(me2->getTH1());
00110       summary.ReadErrorChambers(rep, err, cscdqm::L1SYNC_ERR, threshold, sigfail);
00111     }
00112 
00113     if (MEEMU("CSC_DMB_input_fifo_full", me2)) {
00114       const TH2* err = dynamic_cast<const TH2*>(me2->getTH1());
00115       summary.ReadErrorChambers(rep, err, cscdqm::FIFOFULL_ERR, threshold, sigfail);
00116     }
00117 
00118     if (MEEMU("CSC_DMB_input_timeout", me2)) {
00119       const TH2* err = dynamic_cast<const TH2*>(me2->getTH1());
00120       summary.ReadErrorChambers(rep, err, cscdqm::INPUTTO_ERR, threshold, sigfail);
00121     }
00122 
00123     threshold = effParameters.getUntrackedParameter<double>("threshold_nodata", 1.0);
00124     sigfail   = effParameters.getUntrackedParameter<double>("sigfail_nodata", 5.0);
00125 
00126     if (MEEMU("CSC_wo_ALCT", me2)) {
00127       const TH2* err = dynamic_cast<const TH2*>(me2->getTH1());
00128       summary.ReadErrorChambers(rep, err, cscdqm::NODATA_ALCT, threshold, sigfail);
00129     }
00130 
00131     if (MEEMU("CSC_wo_CLCT", me2)) {
00132       const TH2* err = dynamic_cast<const TH2*>(me2->getTH1());
00133       summary.ReadErrorChambers(rep, err, cscdqm::NODATA_CLCT, threshold, sigfail);
00134     }
00135 
00136     if (MEEMU("CSC_wo_CFEB", me2)) {
00137       const TH2* err = dynamic_cast<const TH2*>(me2->getTH1());
00138       summary.ReadErrorChambers(rep, err, cscdqm::NODATA_CFEB, threshold, sigfail);
00139     }
00140 
00141     if (MEEMU("CSC_Format_Warnings", me2)) {
00142       const TH2* err = dynamic_cast<const TH2*>(me2->getTH1());
00143       summary.ReadErrorChambers(rep, err, cscdqm::CFEB_BWORDS, threshold, sigfail);
00144     }
00145   }
00146 
00147   //
00148   // Write Global DQM shifter chamber error maps 
00149   //
00150    
00151   if (MEEventInfo("reportSummaryMap", me1)) {
00152     TH2* tmp = dynamic_cast<TH2*>(me1->getTH1());
00153     summary.WriteChamberState(tmp, 0x1, 3, true, false);
00154     summary.WriteChamberState(tmp, HWSTATUSERRORBITS, 2, false, true);
00155   }
00156 
00157   if (MEEMU("CSC_STATS_occupancy", me1)){
00158     TH2* tmp = dynamic_cast<TH2*>(me1->getTH1());
00159     summary.WriteChamberState(tmp, 0x4, 2, true, false);
00160     summary.WriteChamberState(tmp, 0x8, 4, false, false);
00161   }
00162 
00163   if (MEEMU("CSC_STATS_format_err", me1)){
00164     TH2* tmp = dynamic_cast<TH2*>(me1->getTH1());
00165     summary.WriteChamberState(tmp, 0x10, 2, true, false);
00166   }
00167 
00168   if (MEEMU("CSC_STATS_l1sync_err", me1)){
00169     TH2* tmp = dynamic_cast<TH2*>(me1->getTH1());
00170     summary.WriteChamberState(tmp, 0x20, 2, true, false);
00171   }
00172 
00173   if (MEEMU("CSC_STATS_fifofull_err", me1)){
00174     TH2* tmp = dynamic_cast<TH2*>(me1->getTH1());
00175     summary.WriteChamberState(tmp, 0x40, 2, true, false);
00176   }
00177 
00178   if (MEEMU("CSC_STATS_inputto_err", me1)){
00179     TH2* tmp = dynamic_cast<TH2*>(me1->getTH1());
00180     summary.WriteChamberState(tmp, 0x80, 2, true, false);
00181   }
00182 
00183   if (MEEMU("CSC_STATS_wo_alct", me1)){
00184     TH2* tmp = dynamic_cast<TH2*>(me1->getTH1());
00185     summary.WriteChamberState(tmp, 0x100, 2, true, false);
00186   }
00187 
00188   if (MEEMU("CSC_STATS_wo_clct", me1)){
00189     TH2* tmp = dynamic_cast<TH2*>(me1->getTH1());
00190     summary.WriteChamberState(tmp, 0x200, 2, true, false);
00191   }
00192 
00193   if (MEEMU("CSC_STATS_wo_cfeb", me1)){
00194     TH2* tmp = dynamic_cast<TH2*>(me1->getTH1());
00195     summary.WriteChamberState(tmp, 0x400, 2, true, false);
00196   }
00197 
00198   if (MEEMU("CSC_STATS_cfeb_bwords", me1)){
00199     TH2* tmp = dynamic_cast<TH2*>(me1->getTH1());
00200     summary.WriteChamberState(tmp, 0x800, 2, true, false);
00201   }
00202 
00203   //
00204   // Write summary information
00205   //
00206 
00207   if (MEEMU("Physics_ME1", me1)){
00208     TH2* tmp = dynamic_cast<TH2*>(me1->getTH1());
00209     summary.Write(tmp, 1);
00210   }
00211 
00212   if (MEEMU("Physics_ME2", me1)){
00213     TH2* tmp = dynamic_cast<TH2*>(me1->getTH1());
00214     summary.Write(tmp, 2);
00215   }
00216 
00217   if (MEEMU("Physics_ME3", me1)){
00218     TH2* tmp = dynamic_cast<TH2*>(me1->getTH1());
00219     summary.Write(tmp, 3);
00220   }
00221 
00222   if (MEEMU("Physics_ME4", me1)){
00223     TH2* tmp = dynamic_cast<TH2*>(me1->getTH1());
00224     summary.Write(tmp, 4);
00225   }
00226 
00227   if (MEEMU("Physics_EMU", me1)) {
00228     TH2* tmp=dynamic_cast<TH2*>(me1->getTH1());
00229     summary.WriteMap(tmp);
00230   }
00231 
00232   // Looping via addresses (scope: side->station->ring) and
00233   // filling in HW efficiencies
00234   cscdqm::Address adr;
00235   adr.mask.station = adr.mask.ring = adr.mask.chamber = adr.mask.layer = adr.mask.cfeb = adr.mask.hv = false;
00236   adr.mask.side = true;
00237 
00238   double e_detector = 0, e_side = 0, e_station = 0, e_ring = 0;
00239 
00240   for (adr.side = 1; adr.side <= N_SIDES; adr.side++) {
00241     
00242     e_side = 0;
00243     adr.mask.station = true;
00244 
00245     for (adr.station = 1; adr.station <= N_STATIONS; adr.station++) {
00246 
00247       e_station = 0;
00248       adr.mask.ring = true;
00249 
00250       for (adr.ring = 1; adr.ring <= summary.getDetector().NumberOfRings(adr.station); adr.ring++) {
00251 
00252         e_ring = summary.GetEfficiencyHW(adr);
00253         e_station += e_ring;
00254 
00255         if (summary.getDetector().NumberOfRings(adr.station) > 1) {
00256 
00257           if (MEReportSummaryContents(summary.getDetector().AddressName(adr), me1)) {
00258 
00259             me1->Fill(e_ring);
00260 
00261           }
00262 
00263         }
00264 
00265       }
00266 
00267       adr.mask.ring = false;
00268       e_station = e_station / summary.getDetector().NumberOfRings(adr.station);
00269       if (MEReportSummaryContents(summary.getDetector().AddressName(adr), me1)) me1->Fill(e_station);
00270       e_side += e_station;
00271 
00272     }
00273 
00274     adr.mask.station = false;
00275     e_side = e_side / N_STATIONS;
00276     if (MEReportSummaryContents(summary.getDetector().AddressName(adr), me1)) me1->Fill(e_side);
00277     e_detector += e_side; 
00278 
00279   }
00280 
00281   e_detector = e_detector / N_SIDES;
00282   if (MEEventInfo("reportSummary", me1)) me1->Fill(e_detector);
00283 
00284 }


Member Data Documentation

bool CSCMonitorModule::bCSCEventCounted [private]

Definition at line 147 of file CSCMonitorModule.h.

Referenced by monitorEvent().

std::string CSCMonitorModule::bookingFile [private]

Definition at line 117 of file CSCMonitorModule.h.

Referenced by CSCMonitorModule(), and loadCollection().

HistoDefMap CSCMonitorModule::collection [private]

Histogram collection.

Definition at line 142 of file CSCMonitorModule.h.

Referenced by book(), loadCollection(), and printCollection().

DQMStore* CSCMonitorModule::dbe [private]

Definition at line 114 of file CSCMonitorModule.h.

Referenced by book(), CSCMonitorModule(), isMEValid(), MEDDU(), and setup().

edm::ParameterSet CSCMonitorModule::effParameters [private]

Definition at line 113 of file CSCMonitorModule.h.

Referenced by CSCMonitorModule(), setup(), and updateFracHistos().

Bitset32 CSCMonitorModule::examinerCRCKey [private]

Definition at line 136 of file CSCMonitorModule.h.

Referenced by CSCMonitorModule(), and monitorEvent().

bool CSCMonitorModule::examinerForce [private]

Definition at line 134 of file CSCMonitorModule.h.

Referenced by CSCMonitorModule().

unsigned int CSCMonitorModule::examinerMask [private]

Examiner and its stuff.

Definition at line 133 of file CSCMonitorModule.h.

Referenced by CSCMonitorModule(), and monitorExaminer().

bool CSCMonitorModule::examinerOutput [private]

Definition at line 135 of file CSCMonitorModule.h.

Referenced by CSCMonitorModule(), and monitorEvent().

uint32_t CSCMonitorModule::fractUpdateEvF [private]

Definition at line 127 of file CSCMonitorModule.h.

Referenced by analyze(), CSCMonitorModule(), and setup().

Bitset32 CSCMonitorModule::fractUpdateKey [private]

Fractional histograms update stuff.

Definition at line 126 of file CSCMonitorModule.h.

Referenced by analyze(), beginLuminosityBlock(), CSCMonitorModule(), endRun(), and setup().

bool CSCMonitorModule::hitBookDDU [private]

List of loaded (preloaded) DDU's.

Definition at line 123 of file CSCMonitorModule.h.

Referenced by CSCMonitorModule(), and MEDDU().

bool CSCMonitorModule::init [private]

If histos have been initialized?

Definition at line 120 of file CSCMonitorModule.h.

Referenced by CSCMonitorModule(), and setup().

edm::InputTag CSCMonitorModule::inputObjectsTag [private]

Source related stuff.

Definition at line 130 of file CSCMonitorModule.h.

Referenced by CSCMonitorModule(), and monitorEvent().

uint32_t CSCMonitorModule::L1ANumber [private]

Definition at line 148 of file CSCMonitorModule.h.

Referenced by CSCMonitorModule(), monitorCSC(), and monitorDDU().

std::map<uint32_t,uint32_t> CSCMonitorModule::L1ANumbers [private]

Definition at line 149 of file CSCMonitorModule.h.

Referenced by monitorDDU().

std::string CSCMonitorModule::monitorName [private]

Definition at line 115 of file CSCMonitorModule.h.

Referenced by CSCMonitorModule().

uint32_t CSCMonitorModule::nCSCEvents [private]

Definition at line 146 of file CSCMonitorModule.h.

Referenced by analyze(), beginLuminosityBlock(), CSCMonitorModule(), endRun(), and monitorEvent().

uint32_t CSCMonitorModule::nEvents [private]

Histogram mapping, increments, etc.

Definition at line 145 of file CSCMonitorModule.h.

Referenced by analyze(), CSCMonitorModule(), monitorDDU(), and monitorEvent().

edm::ParameterSet CSCMonitorModule::parameters [private]

Global Module-wide parameters.

Definition at line 112 of file CSCMonitorModule.h.

Referenced by CSCMonitorModule().

const CSCCrateMap* CSCMonitorModule::pcrate [private]

Pointer to crate mapping from database.

Definition at line 139 of file CSCMonitorModule.h.

Referenced by analyze(), and getCSCFromMap().

std::string CSCMonitorModule::rootDir [private]

Definition at line 116 of file CSCMonitorModule.h.

Referenced by CSCMonitorModule(), MEDDU(), MEEMU(), MEEventInfo(), MEReportSummaryContents(), and setup().

cscdqm::Summary CSCMonitorModule::summary [private]

CSC summary map.

Definition at line 158 of file CSCMonitorModule.h.

Referenced by CSCMonitorModule(), setup(), and updateFracHistos().


The documentation for this class was generated from the following files:
Generated on Tue Jun 9 18:17:22 2009 for CMSSW by  doxygen 1.5.4