Reference Manual

Go to the documentation of this file.
00001 #include <DQM/RPCMonitorClient/interface/RPCClusterSizeTest.h>
00002 #include "DQM/RPCMonitorDigi/interface/utils.h"
00003 
00004 // Framework
00005 #include "FWCore/MessageLogger/interface/MessageLogger.h"
00006 
00007 // //Geometry
00008 #include "Geometry/RPCGeometry/interface/RPCGeomServ.h"
00009 
00010 RPCClusterSizeTest::RPCClusterSizeTest(const edm::ParameterSet& ps ){
00011   edm::LogVerbatim ("rpceventsummary") << "[RPCClusterSizeTest]: Constructor";
00012   
00013   prescaleFactor_ =  ps.getUntrackedParameter<int>("DiagnosticPrescale", 1);
00014   
00015   numberOfDisks_ = ps.getUntrackedParameter<int>("NumberOfEndcapDisks", 3);
00016   numberOfRings_ = ps.getUntrackedParameter<int>("NumberOfEndcapRings", 2);
00017   testMode_ = ps.getUntrackedParameter<bool>("testMode", false);
00018   useRollInfo_ = ps.getUntrackedParameter<bool>("useRollInfo", false);
00019 
00020   resetMEArrays();
00021 }
00022 
00023 RPCClusterSizeTest::~RPCClusterSizeTest(){ dbe_=0;}
00024 
00025 void RPCClusterSizeTest::beginJob(DQMStore *  dbe, std::string workingFolder){
00026   edm::LogVerbatim ("rpceventsummary") << "[RPCClusterSizeTest]: Begin job ";
00027 
00028   globalFolder_  = workingFolder;
00029   dbe_ = dbe;
00030 }
00031 
00032 void RPCClusterSizeTest::endRun(const edm::Run& r, const edm::EventSetup& c){
00033   edm::LogVerbatim ("rpceventsummary") << "[RPCClusterSizeTest]: End run";
00034 }
00035 
00036 void RPCClusterSizeTest::getMonitorElements(std::vector<MonitorElement *> & meVector, std::vector<RPCDetId> & detIdVector){
00037     
00038  
00039  //Get  ME for each roll
00040  for (unsigned int i = 0 ; i<meVector.size(); i++){
00041 
00042    bool flag= false;
00043    
00044    DQMNet::TagList tagList;
00045    tagList = meVector[i]->getTags();
00046    DQMNet::TagList::iterator tagItr = tagList.begin();
00047 
00048    while (tagItr != tagList.end() && !flag ) {
00049      if((*tagItr) ==  rpcdqm::CLUSTERSIZE)
00050        flag= true;
00051    
00052      tagItr++;
00053    }
00054    
00055    if(flag){
00056      myClusterMe_.push_back(meVector[i]);
00057      myDetIds_.push_back(detIdVector[i]);
00058    }
00059  }
00060 
00061 }
00062 
00063 void RPCClusterSizeTest::beginLuminosityBlock(edm::LuminosityBlock const& lumiSeg, edm::EventSetup const& context){} 
00064 
00065 void RPCClusterSizeTest::analyze(const edm::Event& iEvent, const edm::EventSetup& c) {}
00066 
00067 void RPCClusterSizeTest::endLuminosityBlock(edm::LuminosityBlock const& lumiSeg, edm::EventSetup const& iSetup) {} 
00068 
00069 void RPCClusterSizeTest::clientOperation(edm::EventSetup const& iSetup) {
00070   
00071   edm::LogVerbatim ("rpceventsummary") <<"[RPCClusterSizeTest]:Client Operation";
00072   
00073   //check some statements and prescale Factor
00074   if(myClusterMe_.size()==0 || myDetIds_.size()==0)return;
00075         
00076   MonitorElement * CLS   = NULL;  // ClusterSize in 1 bin, Roll vs Sector
00077   MonitorElement * CLSD  = NULL;  // ClusterSize in 1 bin, Distribution
00078   MonitorElement * MEAN  = NULL;  // Mean ClusterSize, Roll vs Sector
00079   MonitorElement * MEAND = NULL;  // Mean ClusterSize, Distribution
00080   
00081   
00082   std::stringstream meName;
00083   RPCDetId detId;
00084   MonitorElement * myMe;
00085 
00086   
00087   //Loop on chambers
00088   for (unsigned int  i = 0 ; i<myClusterMe_.size();i++){
00089     
00090     myMe = myClusterMe_[i];
00091     if (!myMe || myMe->getEntries()==0 )continue;
00092 
00093     
00094     detId=myDetIds_[i];
00095     
00096     
00097     if (detId.region()==0){
00098 
00099       CLS = CLSWheel[detId.ring()+2];
00100       MEAN = MEANWheel[detId.ring()+2];
00101       if(testMode_){
00102         CLSD = CLSDWheel[detId.ring()+2];
00103         MEAND = MEANDWheel[detId.ring()+2];
00104       }
00105     }else {
00106       
00107       if(((detId.station() * detId.region() ) + numberOfDisks_) >= 0 ){
00108         
00109         if(detId.region()<0){
00110           CLS=CLSDisk[(detId.station() * detId.region() ) + numberOfDisks_];
00111           MEAN=  MEANDisk[(detId.station() * detId.region() ) + numberOfDisks_];
00112           if(testMode_){
00113             CLSD = CLSDDisk[(detId.station() * detId.region() ) + numberOfDisks_];
00114             MEAND= MEANDDisk[(detId.station() * detId.region() ) + numberOfDisks_];
00115           }
00116         }else{
00117           CLS=CLSDisk[(detId.station() * detId.region() ) + numberOfDisks_ -1];
00118           MEAN= MEANDisk[(detId.station() * detId.region() ) + numberOfDisks_-1];
00119           if(testMode_){
00120             CLSD = CLSDDisk[(detId.station() * detId.region() ) + numberOfDisks_-1];
00121             MEAND= MEANDDisk[(detId.station() * detId.region() ) + numberOfDisks_-1];
00122           }
00123         }
00124       }
00125       
00126     }
00127 
00128   
00129     int xBin,yBin;
00130     
00131     if (detId.region()==0){//Barrel
00132       
00133       rpcdqm::utils rollNumber;
00134       yBin = rollNumber.detId2RollNr(detId);
00135       xBin = detId.sector();
00136     }else {//Endcap
00137       
00138       //get segment number
00139       RPCGeomServ RPCServ(detId);
00140       xBin = RPCServ.segment();
00141       (numberOfRings_ == 3 ? yBin= detId.ring()*3-detId.roll()+1 : yBin= (detId.ring()-1)*3-detId.roll()+1);
00142     }
00143     
00144     // Normalization -> # of Entries in first Bin normalaized by total Entries
00145     
00146     float NormCLS = myMe->getBinContent(1)/myMe->getEntries();
00147     float meanCLS = myMe->getMean();
00148     
00149     if (CLS)  CLS -> setBinContent(xBin,yBin, NormCLS);
00150     if(MEAN)   MEAN -> setBinContent(xBin, yBin, meanCLS);
00151  
00152     if(testMode_){
00153       if(MEAND) MEAND->Fill(meanCLS);
00154       if(CLSD)   CLSD->Fill(NormCLS);
00155     }
00156     
00157   }//End loop on chambers
00158 } 
00159 
00160 void  RPCClusterSizeTest::endJob(void) {}
00161 
00162 void RPCClusterSizeTest::resetMEArrays(void) {
00163   memset((void*) CLSWheel, 0, sizeof(MonitorElement*)*kWheels);
00164   memset((void*) CLSDWheel, 0, sizeof(MonitorElement*)*kWheels);
00165   memset((void*) MEANWheel, 0, sizeof(MonitorElement*)*kWheels);
00166   memset((void*) MEANDWheel, 0, sizeof(MonitorElement*)*kWheels);
00167 
00168   memset((void*) CLSDisk, 0, sizeof(MonitorElement*)*kDisks);
00169   memset((void*) CLSDDisk, 0, sizeof(MonitorElement*)*kDisks);
00170   memset((void*) MEANDisk, 0, sizeof(MonitorElement*)*kDisks);
00171   memset((void*) MEANDDisk, 0, sizeof(MonitorElement*)*kDisks);
00172 }
00173 
00174 
00175 void  RPCClusterSizeTest::beginRun(const edm::Run& r, const edm::EventSetup& c) {
00176 
00177   resetMEArrays();
00178   
00179   MonitorElement* me;
00180   dbe_->setCurrentFolder(globalFolder_);
00181 
00182   std::stringstream histoName;
00183 
00184   rpcdqm::utils rpcUtils;
00185 
00186   // Loop over wheels
00187   for (int w = -2; w <= 2; w++) {
00188     histoName.str("");   
00189     histoName<<"ClusterSizeIn1Bin_Roll_vs_Sector_Wheel"<<w;       // ClusterSize in first bin norm. by Entries (2D Roll vs Sector)       
00190     me = 0;
00191     me = dbe_->get(globalFolder_ + histoName.str()) ;
00192     if ( 0!=me ) {
00193       dbe_->removeElement(me->getName());
00194     }
00195     
00196     CLSWheel[w+2] = dbe_->book2D(histoName.str().c_str(), histoName.str().c_str(),  12, 0.5, 12.5, 21, 0.5, 21.5);
00197     rpcUtils.labelXAxisSector(  CLSWheel[w+2]);
00198     rpcUtils.labelYAxisRoll(   CLSWheel[w+2], 0, w ,useRollInfo_);
00199     
00200     
00201     histoName.str("");
00202     histoName<<"ClusterSizeMean_Roll_vs_Sector_Wheel"<<w;       // Avarage ClusterSize (2D Roll vs Sector)   
00203     me = 0;
00204     me = dbe_->get(globalFolder_ + histoName.str()) ;
00205     if ( 0!=me) {
00206       dbe_->removeElement(me->getName());
00207     }
00208     
00209     MEANWheel[w+2] = dbe_->book2D(histoName.str().c_str(), histoName.str().c_str(),  12, 0.5, 12.5, 21, 0.5, 21.5);
00210     
00211     rpcUtils.labelXAxisSector(  MEANWheel[w+2]);
00212     rpcUtils.labelYAxisRoll(MEANWheel[w+2], 0, w,useRollInfo_ );
00213     
00214     if(testMode_){
00215       histoName.str("");
00216       histoName<<"ClusterSizeIn1Bin_Distribution_Wheel"<<w;       //  ClusterSize in first bin, distribution
00217       me = 0;
00218       me = dbe_->get(globalFolder_ + histoName.str()) ;
00219       if ( 0!=me ) {
00220         dbe_->removeElement(me->getName());
00221       }
00222       CLSDWheel[w+2] = dbe_->book1D(histoName.str().c_str(), histoName.str().c_str(),  20, 0.0, 1.0);
00223       
00224       
00225       histoName.str("");
00226       histoName<<"ClusterSizeMean_Distribution_Wheel"<<w;       //  Avarage ClusterSize Distribution
00227       me = 0;
00228       me = dbe_->get(globalFolder_ + histoName.str()) ;
00229       if ( 0!=me){
00230         dbe_->removeElement(me->getName());
00231       }
00232       MEANDWheel[w+2] = dbe_->book1D(histoName.str().c_str(), histoName.str().c_str(),  100, 0.5, 10.5);
00233     }
00234   }//end loop on wheels
00235 
00236 
00237   for (int d = -numberOfDisks_;  d <= numberOfDisks_; d++) {
00238     if (d == 0)
00239       continue;
00240   //Endcap
00241     int offset = numberOfDisks_;
00242     if (d>0) offset--;
00243 
00244     histoName.str("");   
00245     histoName<<"ClusterSizeIn1Bin_Ring_vs_Segment_Disk"<<d;       // ClusterSize in first bin norm. by Entries (2D Roll vs Sector)   
00246     me = 0;
00247     me = dbe_->get(globalFolder_ + histoName.str()) ;
00248     if ( 0!=me){
00249       dbe_->removeElement(me->getName());
00250     }
00251     
00252     CLSDisk[d+offset] = dbe_->book2D(histoName.str().c_str(), histoName.str().c_str(),36, 0.5, 36.5, 3*numberOfRings_, 0.5,3*numberOfRings_+ 0.5); 
00253     rpcUtils.labelXAxisSegment(CLSDisk[d+offset]);
00254     rpcUtils.labelYAxisRing(CLSDisk[d+offset], numberOfRings_,useRollInfo_ );
00255    
00256     if(testMode_){
00257       histoName.str("");
00258       histoName<<"ClusterSizeIn1Bin_Distribution_Disk"<<d;       //  ClusterSize in first bin, distribution
00259       me = 0;
00260       me = dbe_->get(globalFolder_ + histoName.str()) ;
00261       if ( 0!=me){
00262         dbe_->removeElement(me->getName());
00263       }
00264       CLSDDisk[d+offset] = dbe_->book1D(histoName.str().c_str(), histoName.str().c_str(),  20, 0.0, 1.0);
00265       
00266       histoName.str("");
00267       histoName<<"ClusterSizeMean_Distribution_Disk"<<d;       //  Avarage ClusterSize Distribution
00268       me = 0;
00269       me = dbe_->get(globalFolder_ + histoName.str()) ;
00270       if ( 0!=me){
00271         dbe_->removeElement(me->getName());
00272       }
00273       MEANDDisk[d+offset] = dbe_->book1D(histoName.str().c_str(), histoName.str().c_str(),  100, 0.5, 10.5);
00274       
00275     }
00276     
00277     histoName.str("");
00278     histoName<<"ClusterSizeMean_Ring_vs_Segment_Disk"<<d;       // Avarage ClusterSize (2D Roll vs Sector)   
00279     me = 0;
00280     me = dbe_->get(globalFolder_ + histoName.str()) ;
00281     if ( 0!=me){
00282       dbe_->removeElement(me->getName());
00283     }
00284     
00285     MEANDisk[d+offset] = dbe_->book2D(histoName.str().c_str(), histoName.str().c_str(), 36, 0.5, 36.5, 3*numberOfRings_, 0.5,3*numberOfRings_+ 0.5);
00286     rpcUtils.labelXAxisSegment(MEANDisk[d+offset]);
00287     rpcUtils.labelYAxisRing(MEANDisk[d+offset], numberOfRings_ ,useRollInfo_);
00288  }
00289 }
/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_6_2_7/src/DQM/RPCMonitorClient/src/RPCClusterSizeTest.cc
