#include <RPCDqmClient.h>

Inheritance diagram for RPCDqmClient:

Public Member Functions
	RPCDqmClient (const edm::ParameterSet &ps)
	Constructor. More...

virtual	~RPCDqmClient ()
	Destructor. More...

Public Member Functions inherited from DQMEDHarvester
virtual void	analyze (edm::Event const &, edm::EventSetup const &) final

virtual void	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) final

virtual void	beginRun (edm::Run const &, edm::EventSetup const &)

	DQMEDHarvester (void)

virtual void	endJob () final

virtual void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) final

virtual void	endRun (edm::Run const &, edm::EventSetup const &)

Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::WatchRuns, edm::one::WatchLuminosityBlocks, edm::one::SharedResources >
	EDAnalyzer ()=default

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDAnalyzerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector < ProductResolverIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Protected Member Functions
void	beginJob () override

void	dqmEndJob (DQMStore::IBooker &, DQMStore::IGetter &) override

void	dqmEndLuminosityBlock (DQMStore::IBooker &, DQMStore::IGetter &, edm::LuminosityBlock const &, edm::EventSetup const &) override

void	getMonitorElements (DQMStore::IGetter &)

void	getRPCdetId (const edm::EventSetup &)

void	makeClientMap (const edm::ParameterSet &parameters_)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Private Attributes
std::vector< std::string >	clientHisto_

std::vector< std::string >	clientList_

std::vector< RPCClient * >	clientModules_

std::vector< std::string >	clientNames_

std::vector< int >	clientTag_

bool	enableDQMClients_

std::string	globalFolder_

int	lumiCounter_

int	minimumEvents_

std::vector< RPCDetId >	myDetIds_

int	numLumBlock_

bool	offlineDQM_

std::string	prefixDir_

int	prescaleGlobalFactor_

MonitorElement *	RPCEvents_

bool	useRollInfo_

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Detailed Description

Definition at line 13 of file RPCDqmClient.h.

Constructor & Destructor Documentation

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

Constructor.

Definition at line 22 of file RPCDqmClient.cc.

References clientList_, enableDQMClients_, edm::ParameterSet::getUntrackedParameter(), globalFolder_, lumiCounter_, makeClientMap(), minimumEvents_, offlineDQM_, prefixDir_, prescaleGlobalFactor_, AlCaHLTBitMon_QueryRunRegistry::string, and useRollInfo_.

                                                             {
 
   edm::LogVerbatim ("rpcdqmclient") << "[RPCDqmClient]: Constructor";
 
   offlineDQM_ = parameters_.getUntrackedParameter<bool> ("OfflineDQM",true); 
   useRollInfo_=  parameters_.getUntrackedParameter<bool>("UseRollInfo", false);
   //check enabling
   enableDQMClients_ = parameters_.getUntrackedParameter<bool> ("EnableRPCDqmClient",true); 
   minimumEvents_= parameters_.getUntrackedParameter<int>("MinimumRPCEvents", 10000);
 
   std::string subsystemFolder = parameters_.getUntrackedParameter<std::string>("RPCFolder", "RPC");
   std::string recHitTypeFolder= parameters_.getUntrackedParameter<std::string>("RecHitTypeFolder", "AllHits");
   std::string summaryFolder = parameters_.getUntrackedParameter<std::string>("SummaryFolder", "SummaryHistograms");
   
   prefixDir_ =   subsystemFolder+ "/"+ recHitTypeFolder;
   globalFolder_ = subsystemFolder + "/"+ recHitTypeFolder + "/"+ summaryFolder;
 
   //get prescale factor
   prescaleGlobalFactor_ = parameters_.getUntrackedParameter<int>("DiagnosticGlobalPrescale", 5);
 
   //make default client list  
   clientList_.push_back("RPCMultiplicityTest");
   clientList_.push_back("RPCDeadChannelTest");
   clientList_.push_back("RPCClusterSizeTest");
   clientList_= parameters_.getUntrackedParameter<std::vector<std::string> >("RPCDqmClientList",clientList_);
 
   //get all the possible RPC DQM clients 
   this->makeClientMap(parameters_);
 
   //clear counters
   lumiCounter_ = 0;
 }

RPCDqmClient::~RPCDqmClient ( )

virtual

Destructor.

Definition at line 55 of file RPCDqmClient.cc.

55 {}

Member Function Documentation

void RPCDqmClient::beginJob ( void )

overrideprotectedvirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 57 of file RPCDqmClient.cc.

References clientModules_, enableDQMClients_, and globalFolder_.

                            {
 
   if (!enableDQMClients_) {return;}                 ;
   edm::LogVerbatim ("rpcdqmclient") << "[RPCDqmClient]: Begin Job";
 
     //Do whatever the begin jobs of all client modules do
   for(std::vector<RPCClient*>::iterator it = clientModules_.begin(); it!=clientModules_.end(); it++ ){
     (*it)->beginJob( globalFolder_ );
   }
 
 }

void RPCDqmClient::dqmEndJob	(	DQMStore::IBooker &	ibooker,
		DQMStore::IGetter &	igetter
	)

overrideprotectedvirtual

Implements DQMEDHarvester.

Definition at line 115 of file RPCDqmClient.cc.

References clientModules_, enableDQMClients_, MonitorElement::getBinContent(), getMonitorElements(), minimumEvents_, offlineDQM_, and RPCEvents_.

                                                                                  {
 
   if (!enableDQMClients_) {return;}
 
   edm::LogVerbatim ("rpcdqmclient") << "[RPCDqmClient]: End DQM Job";
   
   if(offlineDQM_){  // ...get chamber based histograms and pass them to the client modules
      this->getMonitorElements( igetter);
   }
 
   float   rpcevents = minimumEvents_;
   if(RPCEvents_) {
       rpcevents = RPCEvents_ ->getBinContent(1);}
   if(rpcevents < minimumEvents_) {return;}
 
   edm::LogVerbatim ("rpcdqmclient") <<"[RPCDqmClient]: Client operations";
   for (std::vector<RPCClient*>::iterator it = clientModules_.begin(); it!=clientModules_.end(); it++ ){
     (*it)->clientOperation();
   }
   
 }

void RPCDqmClient::dqmEndLuminosityBlock	(	DQMStore::IBooker &	ibooker,
		DQMStore::IGetter &	igetter,
		edm::LuminosityBlock const &	lumiSeg,
		edm::EventSetup const &	c
	)

overrideprotectedvirtual

Reimplemented from DQMEDHarvester.

Definition at line 71 of file RPCDqmClient.cc.

References clientModules_, enableDQMClients_, MonitorElement::getBinContent(), getMonitorElements(), getRPCdetId(), lumiCounter_, minimumEvents_, myDetIds_, offlineDQM_, prescaleGlobalFactor_, and RPCEvents_.

                                                                                                                                                          {
  
   if (!enableDQMClients_ ) {return;}
   edm::LogVerbatim ("rpcdqmclient") << "[RPCDqmClient]: End DQM LB";
   
   if( myDetIds_.empty() ) {  
     //Get RPCdetId...
 
    
     this->getRPCdetId( c);
    
     //...book summary histograms
     for (std::vector<RPCClient*>::iterator it = clientModules_.begin(); it!=clientModules_.end(); it++ ){
       (*it)->myBooker( ibooker);
     }
   }
   
   if (!offlineDQM_){ //Do this only for the online
    
     if (lumiCounter_ == 0){ //only for the first lumi section do this...
       // ...get chamber based histograms and pass them to the client modules
       this->getMonitorElements(igetter);
     }
     
     //Do not perform client oparations every lumi block       
     lumiCounter_++;
     if (lumiCounter_%prescaleGlobalFactor_ != 0) {return;}
     
     //Check if there's enough statistics
     float   rpcevents = minimumEvents_;
     if(RPCEvents_) {rpcevents = RPCEvents_->getBinContent(1);}
     if( rpcevents < minimumEvents_) {return;}
     
     edm::LogVerbatim ("rpcdqmclient") <<"[RPCDqmClient]: Client operations";
     for (std::vector<RPCClient*>::iterator it = clientModules_.begin(); it!=clientModules_.end(); it++ ){
       (*it)->clientOperation();
     }
   }//end of online operations
 
   
 }

void RPCDqmClient::getMonitorElements ( DQMStore::IGetter & igetter )

protected

Definition at line 139 of file RPCDqmClient.cc.

References RPCGeomServ::chambername(), GetRecoTauVFromDQM_MC_cff::cl, clientHisto_, clientModules_, RPCBookFolderStructure::folderStructure(), DQMStore::IGetter::get(), myDetIds_, RPCGeomServ::name(), NULL, prefixDir_, RPCEvents_, AlCaHLTBitMon_QueryRunRegistry::string, and useRollInfo_.

Referenced by dqmEndJob(), and dqmEndLuminosityBlock().

                                                                 {
   
   std::vector<MonitorElement *>  myMeVect;
   std::vector<RPCDetId>   myDetIds;
   
   //dbe_->setCurrentFolder(prefixDir_);
   RPCBookFolderStructure *  folderStr = new RPCBookFolderStructure();
   MonitorElement * myMe = NULL;
   std::string rollName= "";
   
   //loop on all geometry and get all histos
   for ( auto& detId :  myDetIds_ ) {
     //Get name
     RPCGeomServ RPCname(detId);
     rollName = useRollInfo_ ? RPCname.name() : RPCname.chambername();
     
     //loop on clients
     for( unsigned int cl = 0, nCL = clientModules_.size(); cl < nCL; ++cl ){
       myMe = igetter.get(prefixDir_ +"/"+ folderStr->folderStructure(detId)+"/"+clientHisto_[cl]+ "_"+rollName);
       if (!myMe){continue;}
       
       //       dbe_->tag(myMe, clientTag_[cl]);
       myMeVect.push_back(myMe);
       myDetIds.push_back(detId);
       
     }//end loop on clients
   }//end loop on all geometry and get all histos
   
   RPCEvents_ = igetter.get(prefixDir_ +"/RPCEvents");
   for ( unsigned int cl = 0; cl < clientModules_.size(); ++cl ) {
     clientModules_[cl]->getMonitorElements(myMeVect, myDetIds, clientHisto_[cl]);
   }
   
   delete folderStr;
 }

void RPCDqmClient::getRPCdetId ( const edm::EventSetup & eventSetup )

protected

Definition at line 177 of file RPCDqmClient.cc.

References edm::EventSetup::get(), myDetIds_, alignCSCRings::r, and RPCChamber::rolls().

Referenced by dqmEndLuminosityBlock().

                                                               {
   
   myDetIds_.clear();
 
   edm::ESHandle<RPCGeometry> rpcGeo;
   eventSetup.get<MuonGeometryRecord>().get(rpcGeo);
 
   for ( auto& det : rpcGeo->dets() ) {
     const RPCChamber* ch = dynamic_cast< const RPCChamber* >(det);
     if ( !ch ) continue;
 
     //Loop on rolls in given chamber
     for ( auto& r : ch->rolls() ) {
       RPCDetId detId = r->id();
       myDetIds_.push_back(detId);
     }
   }
 
 }

void RPCDqmClient::makeClientMap ( const edm::ParameterSet & parameters_ )

protected

Definition at line 199 of file RPCDqmClient.cc.

References clientHisto_, clientList_, clientModules_, and i.

Referenced by RPCDqmClient().

                                                                    {
 
   for(unsigned int i = 0; i<clientList_.size(); i++){
     
     if( clientList_[i] == "RPCMultiplicityTest" ) {
       clientHisto_.push_back("Multiplicity");
       // clientTag_.push_back(rpcdqm::MULTIPLICITY);
       clientModules_.push_back( new RPCMultiplicityTest(parameters_));
     } else if ( clientList_[i] == "RPCDeadChannelTest" ){
       clientHisto_.push_back("Occupancy");
       clientModules_.push_back( new RPCDeadChannelTest(parameters_));
       // clientTag_.push_back(rpcdqm::OCCUPANCY);
     } else if ( clientList_[i] == "RPCClusterSizeTest" ){
       clientHisto_.push_back("ClusterSize");
       clientModules_.push_back( new RPCClusterSizeTest(parameters_));
       // clientTag_.push_back(rpcdqm::CLUSTERSIZE);
     } else if ( clientList_[i] == "RPCOccupancyTest" ){
       clientHisto_.push_back("Occupancy");
       clientModules_.push_back( new RPCOccupancyTest(parameters_));
       // clientTag_.push_back(rpcdqm::OCCUPANCY);
     } else if ( clientList_[i] == "RPCNoisyStripTest" ){
       clientHisto_.push_back("Occupancy");
       clientModules_.push_back( new RPCNoisyStripTest(parameters_));
       //clientTag_.push_back(rpcdqm::OCCUPANCY);
     }
   }
 
   return;
 
 }