#include <RPCNoisyStripTest.h>

Inheritance diagram for RPCNoisyStripTest:

Public Member Functions
void	beginJob (std::string &)

void	clientOperation ()

void	getMonitorElements (std::vector< MonitorElement * > &, std::vector< RPCDetId > &, std::string &)

void	myBooker (DQMStore::IBooker &)

	RPCNoisyStripTest (const edm::ParameterSet &ps)

virtual	~RPCNoisyStripTest ()

Public Member Functions inherited from RPCClient
virtual	~RPCClient (void)

Protected Member Functions
void	fillGlobalME (RPCDetId &, MonitorElement *)

Private Attributes
MonitorElement *	DEVDDisk [10]

MonitorElement *	DEVDWheel [5]

std::string	globalFolder_

std::vector< RPCDetId >	myDetIds_

std::vector< MonitorElement * >	myOccupancyMe_

MonitorElement *	NOISEDDisk [10]

MonitorElement *	NOISEDisk [10]

MonitorElement *	NOISEDWheel [5]

MonitorElement *	NOISEWheel [5]

int	numberOfDisks_

int	numberOfRings_

int	prescaleFactor_

bool	testMode_

bool	useRollInfo_

Detailed Description

Definition at line 10 of file RPCNoisyStripTest.h.

Constructor & Destructor Documentation

RPCNoisyStripTest::RPCNoisyStripTest ( const edm::ParameterSet & ps )

Definition at line 15 of file RPCNoisyStripTest.cc.

References edm::ParameterSet::getUntrackedParameter(), numberOfDisks_, numberOfRings_, prescaleFactor_, testMode_, and useRollInfo_.

                                                               {
   edm::LogVerbatim ("rpcnoisetest") << "[RPCNoisyStripTest]: Constructor";
  
   prescaleFactor_ = ps.getUntrackedParameter<int>("DiagnosticPrescale", 1);
   numberOfDisks_ = ps.getUntrackedParameter<int>("NumberOfEndcapDisks", 4);
   numberOfRings_ = ps.getUntrackedParameter<int>("NumberOfEndcapRings", 2);
   useRollInfo_ = ps.getUntrackedParameter<bool>("UseRollInfo", false);
   testMode_ = ps.getUntrackedParameter<bool>("testMode", false);
 
 }

RPCNoisyStripTest::~RPCNoisyStripTest ( )

virtual

Definition at line 26 of file RPCNoisyStripTest.cc.

26 {}

Member Function Documentation

void RPCNoisyStripTest::beginJob ( std::string & workingFolder )

virtual

Implements RPCClient.

Definition at line 28 of file RPCNoisyStripTest.cc.

References globalFolder_.

                                                           {
  edm::LogVerbatim ("rpcnoisetest") << "[RPCNoisyStripTest]: Begin job ";
   globalFolder_ = workingFolder;
 }

void RPCNoisyStripTest::clientOperation ( )

virtual

Implements RPCClient.

Definition at line 34 of file RPCNoisyStripTest.cc.

References fillGlobalME(), i, myDetIds_, and myOccupancyMe_.

                                         {  
 
   edm::LogVerbatim ("rpcnoisetest") <<"[RPCNoisyStripTest]: Client Operation";
     
  //Loop on MEs
   for (unsigned int  i = 0 ; i<myOccupancyMe_.size();i++){
     this->fillGlobalME(myDetIds_[i],myOccupancyMe_[i]);
   }//End loop on MEs
 
 }

void RPCNoisyStripTest::fillGlobalME	(	RPCDetId &	detId,
		MonitorElement *	myMe
	)

protected

Definition at line 121 of file RPCNoisyStripTest.cc.

References rpcdqm::utils::detId2RollNr(), DEVDDisk, DEVDWheel, python.tagInventory::entries, MonitorElement::Fill(), HcalObjRepresent::Fill(), MonitorElement::getBinContent(), i, sistrip::NOISE, NOISEDDisk, NOISEDisk, NOISEDWheel, NOISEWheel, NULL, numberOfDisks_, numberOfRings_, RPCDetId::region(), RPCDetId::ring(), RPCDetId::roll(), RPCDetId::sector(), RPCGeomServ::segment(), MonitorElement::setBinContent(), RPCDetId::station(), testMode_, and cuy::yBin.

Referenced by clientOperation().

                                                                             {
 
     std::stringstream meName;
     
     MonitorElement *  NOISE=NULL;
     MonitorElement * DEVD=NULL;
     MonitorElement * NOISED=NULL;
 
     if (detId.region()==0) { //BARREL
       NOISE = NOISEWheel[detId.ring()+2];
       if(testMode_) {
     DEVD = DEVDWheel[detId.ring()+2];
     NOISED= NOISEDWheel[detId.ring()+2];
       }
     }else if(detId.region()<0 && (-detId.station() + numberOfDisks_) >= 0 ){//ENDCAP-
       NOISE = NOISEDisk[ -detId.station() + numberOfDisks_];
       if(testMode_) {
     DEVD = DEVDDisk[ -detId.station()  + numberOfDisks_];
     NOISED= NOISEDDisk[-detId.station() + numberOfDisks_];
       }
     }else if((-detId.station() + numberOfDisks_)>= 0 ){//ENDCAP +
       NOISE = NOISEDisk[detId.station() + numberOfDisks_-1];
       if(testMode_) {
     DEVD = DEVDDisk[detId.station()  + numberOfDisks_-1];
     NOISED= NOISEDDisk[detId.station() + numberOfDisks_-1];
       }
     }
     
     
     int entries = (int) myMe -> getEntries();
     int bins = (int) myMe ->getNbinsX();
       
     std::vector<float> myvector;
     
     // count alive strips and alive strip values put in the vector
     for(int xbin =1 ; xbin <= bins ; xbin++) {    
       float binContent = myMe->getBinContent(xbin);  
       if (binContent > 0) myvector.push_back(binContent);
     }
         
     
     int noisyStrips=0;
     // calculate mean on YAxis and check diff between bins and mean
     if (myvector.size()>0) {
       float ymean = entries/myvector.size(); //mean on Yaxis
       for(unsigned int i=0; i<myvector.size(); i++) {
     float deviation = myvector[i]/ymean;
     if(deviation > 3.5)  noisyStrips++;
     if(deviation > 5) deviation = 5; //overflow 
     if(DEVD) DEVD-> Fill(deviation);
       }
     
       
       int xBin,yBin;
       if(detId.region()==0){//Barrel
     xBin= detId.sector();
     rpcdqm::utils rollNumber;
     yBin = rollNumber.detId2RollNr(detId);
       }else{//Endcap
     //get segment number
     RPCGeomServ RPCServ(detId);
     xBin = RPCServ.segment();
     (numberOfRings_ == 3 ? yBin= detId.ring()*3-detId.roll()+1 : yBin= (detId.ring()-1)*3-detId.roll()+1);
       }
       
       if(NOISE)  NOISE->setBinContent(xBin,yBin,noisyStrips); 
       if(NOISED) NOISED ->Fill(noisyStrips);
       
     }
 
 }

void RPCNoisyStripTest::getMonitorElements	(	std::vector< MonitorElement * > &	meVector,
		std::vector< RPCDetId > &	detIdVector,
		std::string &	clientHistoName
	)

virtual

Implements RPCClient.

Definition at line 105 of file RPCNoisyStripTest.cc.

References i, myDetIds_, myOccupancyMe_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                                                                  {
 
  //Get NumberOfDigi ME for each roll
  for (unsigned int i = 0 ; i<meVector.size(); i++){
       
     std::string meName =  meVector[i]->getName();
 
     if(meName.find(clientHistoName) != std::string::npos){
 
      myOccupancyMe_.push_back(meVector[i]);
      myDetIds_.push_back(detIdVector[i]);
    }
  }
 
 }

void RPCNoisyStripTest::myBooker ( DQMStore::IBooker & ibooker )

virtual

Implements RPCClient.

Definition at line 45 of file RPCNoisyStripTest.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DEVDDisk, DEVDWheel, globalFolder_, hltbtagharvestinganalyzer_cfi::histoName, rpcdqm::utils::labelXAxisSector(), rpcdqm::utils::labelXAxisSegment(), rpcdqm::utils::labelYAxisRing(), rpcdqm::utils::labelYAxisRoll(), NOISEDDisk, NOISEDisk, NOISEDWheel, NOISEWheel, numberOfDisks_, numberOfRings_, evf::evtn::offset(), DQMStore::IBooker::setCurrentFolder(), testMode_, useRollInfo_, and w.

                                                           {
 
 
  ibooker.setCurrentFolder( globalFolder_);
 
  std::stringstream histoName;
 
  rpcdqm::utils rpcUtils;
 
  for (int w = -2; w<= 2;w++ ){//loop on wheels and disks
   
    if(testMode_){
      histoName.str("");
      histoName<<"RPCNoisyStrips_Distribution_Wheel"<<w;     
      NOISEDWheel[w+2] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(),  6, -0.5, 5.5);
      
      
      histoName.str("");
      histoName<<"RPCStripsDeviation_Distribution_Wheel"<<w; 
      DEVDWheel[w+2] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(),  101, -0.01, 10.01);
    }
 
    histoName.str("");
    histoName<<"RPCNoisyStrips_Roll_vs_Sector_Wheel"<<w;
    NOISEWheel[w+2] = ibooker.book2D(histoName.str().c_str(), histoName.str().c_str() , 12, 0.5, 12.5, 21, 0.5, 21.5);
    rpcUtils.labelXAxisSector(NOISEWheel[w+2]);
    rpcUtils.labelYAxisRoll(NOISEWheel[w+2], 0, w, useRollInfo_);
  }
 
  
  
  for(int d = -numberOfDisks_; d<=numberOfDisks_; d++ ){//ENDCAP
 
    if (d == 0) continue; 
 
    int offset = numberOfDisks_;
    if (d>0) offset --;
 
    if (testMode_){
      histoName.str("");
      histoName<<"RPCNoisyStrips_Distribution_Disk"<<d;      
      NOISEDDisk[d+offset] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(),  6, -0.5, 5.5);
      
      
      histoName.str("");
      histoName<<"RPCStripsDeviation_Distribution_Disk"<<d;  
      DEVDDisk[d+offset] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(),  101, -0.01, 10.01);
    }
 
    histoName.str("");
    histoName<<"RPCNoisyStrips_Ring_vs_Segment_Disk"<<d;
    NOISEDisk[d+offset] = ibooker.book2D(histoName.str().c_str(), histoName.str().c_str() , 36, 0.5, 36.5, 3*numberOfRings_, 0.5,3*numberOfRings_+ 0.5);
    rpcUtils.labelXAxisSegment(NOISEDisk[d+offset]);
    rpcUtils.labelYAxisRing(NOISEDisk[d+offset], numberOfRings_, useRollInfo_);
 
  }
    
 }