#include <RPCMultiplicityTest.h>

Inheritance diagram for RPCMultiplicityTest:

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

void	clientOperation () override

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

void	myBooker (DQMStore::IBooker &) override

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

	~RPCMultiplicityTest () override
	Destructor. More...

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

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

Private Attributes
std::string	globalFolder_

MonitorElement *	MULTDDisk [10]

MonitorElement *	MULTDisk [10]

MonitorElement *	MULTDWheel [5]

MonitorElement *	MULTWheel [5]

std::vector< RPCDetId >	myDetIds_

std::vector< MonitorElement * >	myNumDigiMe_

int	numberOfDisks_

int	numberOfRings_

int	prescaleFactor_

bool	testMode_

bool	useRollInfo_

Detailed Description

Definition at line 7 of file RPCMultiplicityTest.h.

Constructor & Destructor Documentation

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

Constructor.

Definition at line 16 of file RPCMultiplicityTest.cc.

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

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

RPCMultiplicityTest::~RPCMultiplicityTest ( )

override

Destructor.

Definition at line 27 of file RPCMultiplicityTest.cc.

27 {}

Member Function Documentation

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

overridevirtual

Implements RPCClient.

Definition at line 30 of file RPCMultiplicityTest.cc.

References globalFolder_.

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

void RPCMultiplicityTest::clientOperation ( )

overridevirtual

Implements RPCClient.

Definition at line 105 of file RPCMultiplicityTest.cc.

References fillGlobalME(), mps_fire::i, myDetIds_, and myNumDigiMe_.

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

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

protected

Definition at line 118 of file RPCMultiplicityTest.cc.

References rpcdqm::utils::detId2RollNr(), MonitorElement::Fill(), MonitorElement::getMean(), SiStripPI::mean, MULTDDisk, MULTDisk, MULTDWheel, MULTWheel, numberOfDisks_, numberOfRings_, RPCDetId::region(), RPCDetId::ring(), RPCDetId::roll(), RPCDetId::sector(), RPCGeomServ::segment(), MonitorElement::setBinContent(), RPCDetId::station(), testMode_, and cuy::yBin.

Referenced by clientOperation().

                                                                               {
 
   MonitorElement * MULT =nullptr;
   MonitorElement * MULTD = nullptr;
 
   if (detId.region()==0) {
     MULT = MULTWheel[detId.ring()+2];
     if(testMode_) {  MULTD = MULTDWheel[detId.ring()+2];}
   }else{
     if(-detId.station() + numberOfDisks_ >= 0 ){
     
       if(detId.region()<0){
       MULT = MULTDisk[-detId.station() + numberOfDisks_];
       if(testMode_)  {  MULTD = MULTDDisk[-detId.station()+ numberOfDisks_];}
       }else{
     MULT = MULTDisk[detId.station()+ numberOfDisks_ -1];
     if(testMode_) { MULTD = MULTDDisk[detId.station()+ numberOfDisks_-1];}
       }
     }
   }
 
     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);
     }
     
     float mean = myMe->getMean();
     
     if(MULT)  {MULT->setBinContent(xBin,yBin, mean );}
     if(testMode_ && MULTD) {MULTD->Fill(mean);}
 
 }

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

overridevirtual

Implements RPCClient.

Definition at line 89 of file RPCMultiplicityTest.cc.

References mps_fire::i, myDetIds_, myNumDigiMe_, 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){
       myNumDigiMe_.push_back(meVector[i]);
       myDetIds_.push_back(detIdVector[i]);
     }
   }
 }

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

overridevirtual

Implements RPCClient.

Definition at line 38 of file RPCMultiplicityTest.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), edmIntegrityCheck::d, globalFolder_, mps_fire::i, rpcdqm::utils::labelXAxisSector(), rpcdqm::utils::labelXAxisSegment(), rpcdqm::utils::labelYAxisRing(), rpcdqm::utils::labelYAxisRoll(), MULTDDisk, MULTDisk, MULTDWheel, MULTWheel, numberOfDisks_, numberOfRings_, PFRecoTauDiscriminationByIsolation_cfi::offset, DQMStore::IBooker::setCurrentFolder(), testMode_, and useRollInfo_.

                                                            {
 
 
   ibooker.setCurrentFolder(globalFolder_);
  
   std::stringstream histoName;  
   rpcdqm::utils rpcUtils;
   
   for (int i = -2; i<=2;i++ ){//loop on wheels and disks
  
     histoName.str("");
     histoName<<"NumberOfDigi_Mean_Roll_vs_Sector_Wheel"<<i;
     
     MULTWheel[i+2] = ibooker.book2D(histoName.str().c_str(), histoName.str().c_str(), 12, 0.5, 12.5, 21, 0.5, 21.5);
     
     rpcUtils.labelXAxisSector( MULTWheel[i+2]);
     rpcUtils.labelYAxisRoll( MULTWheel[i+2], 0, i,useRollInfo_ );
     
     if(testMode_){
       histoName.str("");
       histoName<<"NumberOfDigi_Mean_Distribution_Wheel"<<i;
       MULTDWheel[i+2] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(), 100, 0.5, 50.5);
     }
     
   }//end wheels
 
   for(int d = -numberOfDisks_; d<=numberOfDisks_; d++ ){  
     if (d == 0 )continue;
     
     int offset = numberOfDisks_;
     if (d>0) offset --; //used to skip case equale to zero
     
     histoName.str("");
     histoName<<"NumberOfDigi_Mean_Ring_vs_Segment_Disk"<<d;
     MULTDisk[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(MULTDisk[d+offset]);
     rpcUtils.labelYAxisRing(MULTDisk[d+offset], numberOfRings_,useRollInfo_ );
     
     if(testMode_){
       histoName.str("");
       histoName<<"NumberOfDigi_Mean_Distribution_Disk"<<d;
       MULTDDisk[d+offset] = ibooker.book1D(histoName.str().c_str(), histoName.str().c_str(), 100, 0.5, 50.5);
     }
   }//end loop on wheels and disks
 }