#include <RPCClusterSizeTest.h>

Inheritance diagram for RPCClusterSizeTest:

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

void	clientOperation ()

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

void	myBooker (DQMStore::IBooker &)

	RPCClusterSizeTest (const edm::ParameterSet &ps)
	Constructor. More...

virtual	~RPCClusterSizeTest ()
	Destructor. More...

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

Private Types
enum	MEArraySizes { kWheels = 5, kDisks = 10 }

Private Member Functions
void	resetMEArrays (void)

Private Attributes
MonitorElement *	CLSDDisk [kDisks]

MonitorElement *	CLSDisk [kDisks]

MonitorElement *	CLSDWheel [kWheels]

MonitorElement *	CLSWheel [kWheels]

std::string	globalFolder_

MonitorElement *	MEANDDisk [kDisks]

MonitorElement *	MEANDisk [kDisks]

MonitorElement *	MEANDWheel [kWheels]

MonitorElement *	MEANWheel [kWheels]

std::vector< MonitorElement * >	myClusterMe_

std::vector< RPCDetId >	myDetIds_

int	numberOfDisks_

int	numberOfRings_

int	prescaleFactor_

bool	testMode_

bool	useRollInfo_

Detailed Description

Definition at line 8 of file RPCClusterSizeTest.h.

Member Enumeration Documentation

enum RPCClusterSizeTest::MEArraySizes

private

Enumerator
kWheels
kDisks

Definition at line 32 of file RPCClusterSizeTest.h.

                     {
     kWheels = 5,
     kDisks = 10
   };

Constructor & Destructor Documentation

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

Constructor.

Definition at line 10 of file RPCClusterSizeTest.cc.

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

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

RPCClusterSizeTest::~RPCClusterSizeTest ( )

virtual

Destructor.

Definition at line 23 of file RPCClusterSizeTest.cc.

23 { }

Member Function Documentation

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

virtual

Implements RPCClient.

Definition at line 25 of file RPCClusterSizeTest.cc.

References globalFolder_.

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

void RPCClusterSizeTest::clientOperation ( )

virtual

Implements RPCClient.

Definition at line 48 of file RPCClusterSizeTest.cc.

References CLSDDisk, CLSDisk, CLSDWheel, CLSWheel, rpcdqm::utils::detId2RollNr(), MonitorElement::Fill(), MonitorElement::getBinContent(), MonitorElement::getEntries(), MonitorElement::getMean(), i, MEANDDisk, MEANDisk, MEANDWheel, MEANWheel, myClusterMe_, myDetIds_, NULL, numberOfDisks_, numberOfRings_, RPCDetId::region(), RPCDetId::ring(), RPCDetId::roll(), RPCDetId::sector(), RPCGeomServ::segment(), RPCDetId::station(), testMode_, and cuy::yBin.

                                          {
   
   edm::LogVerbatim ("rpceventsummary") <<"[RPCClusterSizeTest]:Client Operation";
   
   //check some statements and prescale Factor
   if(myClusterMe_.size()==0 || myDetIds_.size()==0)return;
         
   MonitorElement * CLS   = NULL;  // ClusterSize in 1 bin, Roll vs Sector
   MonitorElement * CLSD  = NULL;  // ClusterSize in 1 bin, Distribution
   MonitorElement * MEAN  = NULL;  // Mean ClusterSize, Roll vs Sector
   MonitorElement * MEAND = NULL;  // Mean ClusterSize, Distribution
   
   
   std::stringstream meName;
   RPCDetId detId;
   MonitorElement * myMe;
 
   
   //Loop on chambers
   for (unsigned int  i = 0 ; i<myClusterMe_.size();i++){
     
     myMe = myClusterMe_[i];
     if (!myMe || myMe->getEntries()==0 )continue;
 
     
     detId=myDetIds_[i];
     
     
     if (detId.region()==0){
 
       CLS = CLSWheel[detId.ring()+2];
       MEAN = MEANWheel[detId.ring()+2];
       if(testMode_){
     CLSD = CLSDWheel[detId.ring()+2];
         MEAND = MEANDWheel[detId.ring()+2];
       }
     }else {
       
       if(((detId.station() * detId.region() ) + numberOfDisks_) >= 0 ){
     
     if(detId.region()<0){
       CLS=CLSDisk[(detId.station() * detId.region() ) + numberOfDisks_];
       MEAN=  MEANDisk[(detId.station() * detId.region() ) + numberOfDisks_];
       if(testMode_){
         CLSD = CLSDDisk[(detId.station() * detId.region() ) + numberOfDisks_];
         MEAND= MEANDDisk[(detId.station() * detId.region() ) + numberOfDisks_];
       }
     }else{
       CLS=CLSDisk[(detId.station() * detId.region() ) + numberOfDisks_ -1];
       MEAN= MEANDisk[(detId.station() * detId.region() ) + numberOfDisks_-1];
       if(testMode_){
         CLSD = CLSDDisk[(detId.station() * detId.region() ) + numberOfDisks_-1];
         MEAND= MEANDDisk[(detId.station() * detId.region() ) + numberOfDisks_-1];
       }
     }
       }
       
     }
 
   
     int xBin,yBin;
     
     if (detId.region()==0){//Barrel
       
       rpcdqm::utils rollNumber;
       yBin = rollNumber.detId2RollNr(detId);
       xBin = detId.sector();
     }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);
     }
     
     // Normalization -> # of Entries in first Bin normalaized by total Entries
     
     float NormCLS = myMe->getBinContent(1)/myMe->getEntries();
     float meanCLS = myMe->getMean();
     
     if (CLS)  CLS -> setBinContent(xBin,yBin, NormCLS);
     if(MEAN)   MEAN -> setBinContent(xBin, yBin, meanCLS);
  
     if(testMode_){
       if(MEAND) MEAND->Fill(meanCLS);
       if(CLSD)   CLSD->Fill(NormCLS);
     }
     
   }//End loop on chambers
 } 

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

virtual

Implements RPCClient.

Definition at line 32 of file RPCClusterSizeTest.cc.

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

                                                                                                                                                  {
     
  
  //Get  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){
      myClusterMe_.push_back(meVector[i]);
      myDetIds_.push_back(detIdVector[i]);
    }
  }
 }

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

virtual

Implements RPCClient.

Definition at line 153 of file RPCClusterSizeTest.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), CLSDDisk, CLSDisk, CLSDWheel, CLSWheel, ztail::d, globalFolder_, rpcdqm::utils::labelXAxisSector(), rpcdqm::utils::labelXAxisSegment(), rpcdqm::utils::labelYAxisRing(), rpcdqm::utils::labelYAxisRoll(), MEANDDisk, MEANDisk, MEANDWheel, MEANWheel, numberOfDisks_, numberOfRings_, hltrates_dqm_sourceclient-live_cfg::offset, resetMEArrays(), DQMStore::IBooker::setCurrentFolder(), testMode_, useRollInfo_, and w.

                                                             {
 
   resetMEArrays();
   
   ibooker.setCurrentFolder(globalFolder_);
 
   std::stringstream histoName;
 
   rpcdqm::utils rpcUtils;
 
   // Loop over wheels
   for (int w = -2; w <= 2; w++) {
     histoName.str("");   
     histoName<<"ClusterSizeIn1Bin_Roll_vs_Sector_Wheel"<<w;       // ClusterSize in first bin norm. by Entries (2D Roll vs Sector)       
     CLSWheel[w+2] = ibooker.book2D(histoName.str().c_str(), histoName.str().c_str(),  12, 0.5, 12.5, 21, 0.5, 21.5);
     rpcUtils.labelXAxisSector(  CLSWheel[w+2]);
     rpcUtils.labelYAxisRoll(   CLSWheel[w+2], 0, w ,useRollInfo_);
     
     
     histoName.str("");
     histoName<<"ClusterSizeMean_Roll_vs_Sector_Wheel"<<w;       // Avarage ClusterSize (2D Roll vs Sector)   
     MEANWheel[w+2] = ibooker.book2D(histoName.str().c_str(), histoName.str().c_str(),  12, 0.5, 12.5, 21, 0.5, 21.5);
     
     rpcUtils.labelXAxisSector(  MEANWheel[w+2]);
     rpcUtils.labelYAxisRoll(MEANWheel[w+2], 0, w,useRollInfo_ );
     
     if(testMode_){
       histoName.str("");
       histoName<<"ClusterSizeIn1Bin_Distribution_Wheel"<<w;       //  ClusterSize in first bin, distribution
       CLSDWheel[w+2] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(),  20, 0.0, 1.0);
       
       
       histoName.str("");
       histoName<<"ClusterSizeMean_Distribution_Wheel"<<w;       //  Avarage ClusterSize Distribution
       MEANDWheel[w+2] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(),  100, 0.5, 10.5);
     }
   }//end loop on wheels
 
 
   for (int d = -numberOfDisks_;  d <= numberOfDisks_; d++) {
     if (d == 0)
       continue;
   //Endcap
     int offset = numberOfDisks_;
     if (d>0) offset--;
 
     histoName.str("");   
     histoName<<"ClusterSizeIn1Bin_Ring_vs_Segment_Disk"<<d;       // ClusterSize in first bin norm. by Entries (2D Roll vs Sector)   
     CLSDisk[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(CLSDisk[d+offset]);
     rpcUtils.labelYAxisRing(CLSDisk[d+offset], numberOfRings_,useRollInfo_ );
    
     if(testMode_){
       histoName.str("");
       histoName<<"ClusterSizeIn1Bin_Distribution_Disk"<<d;       //  ClusterSize in first bin, distribution
       CLSDDisk[d+offset] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(),  20, 0.0, 1.0);
       
       histoName.str("");
       histoName<<"ClusterSizeMean_Distribution_Disk"<<d;       //  Avarage ClusterSize Distribution
       MEANDDisk[d+offset] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(),  100, 0.5, 10.5);
       
     }
     
     histoName.str("");
     histoName<<"ClusterSizeMean_Ring_vs_Segment_Disk"<<d;       // Avarage ClusterSize (2D Roll vs Sector)   
     MEANDisk[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(MEANDisk[d+offset]);
     rpcUtils.labelYAxisRing(MEANDisk[d+offset], numberOfRings_ ,useRollInfo_);
  }
 }

void RPCClusterSizeTest::resetMEArrays ( void )

private

Definition at line 140 of file RPCClusterSizeTest.cc.

References CLSDDisk, CLSDisk, CLSDWheel, CLSWheel, kDisks, kWheels, MEANDDisk, MEANDisk, MEANDWheel, and MEANWheel.

Referenced by myBooker(), and RPCClusterSizeTest().

                                            {
   memset((void*) CLSWheel, 0, sizeof(MonitorElement*)*kWheels);
   memset((void*) CLSDWheel, 0, sizeof(MonitorElement*)*kWheels);
   memset((void*) MEANWheel, 0, sizeof(MonitorElement*)*kWheels);
   memset((void*) MEANDWheel, 0, sizeof(MonitorElement*)*kWheels);
 
   memset((void*) CLSDisk, 0, sizeof(MonitorElement*)*kDisks);
   memset((void*) CLSDDisk, 0, sizeof(MonitorElement*)*kDisks);
   memset((void*) MEANDisk, 0, sizeof(MonitorElement*)*kDisks);
   memset((void*) MEANDDisk, 0, sizeof(MonitorElement*)*kDisks);
 }