#include <DTNoiseAnalysisTest.h>

Inheritance diagram for DTNoiseAnalysisTest:

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

virtual	~DTNoiseAnalysisTest ()
	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

	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 ()

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

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Protected Member Functions
void	beginRun (edm::Run const &run, edm::EventSetup const &context)
	BeginRun. More...

void	bookHistos (DQMStore::IBooker &)
	book the summary histograms More...

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

void	dqmEndLuminosityBlock (DQMStore::IBooker &, DQMStore::IGetter &, edm::LuminosityBlock const &, edm::EventSetup const &)
	DQM Client Diagnostic. More...

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 Member Functions
std::string	getMEName (const DTChamberId &chID)
	Get the ME name. More...

std::string	getSynchNoiseMEName (int wheelId) const

Private Attributes
bool	bookingdone

bool	detailedAnalysis

bool	doSynchNoise

MonitorElement *	glbSummarySynchNoiseHisto

double	maxSynchNoiseRate

edm::ESHandle< DTGeometry >	muonGeom

int	nevents

int	nMinEvts

std::map< int, MonitorElement * >	noiseHistos

int	noisyCellDef

std::map< int, MonitorElement * >	noisyCellHistos

MonitorElement *	summaryNoiseHisto

MonitorElement *	summarySynchNoiseHisto

MonitorElement *	threshChannelsHisto

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

DQM Test Client

Author
G. Mila - INFN Torino

threadsafe version (//-) oct/nov 2014 - WATWanAbdullah -ncpp-um-my

Definition at line 37 of file DTNoiseAnalysisTest.h.

Constructor & Destructor Documentation

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

Constructor.

Definition at line 39 of file DTNoiseAnalysisTest.cc.

References edm::ParameterSet::getUntrackedParameter(), LogTrace, and cmsHarvester::nevents.

                                                                  {
   LogTrace("DTDQM|DTMonitorClient|DTNoiseAnalysisTest") << "[DTNoiseAnalysisTest]: Constructor";
 
   // get the cfi parameters
   noisyCellDef = ps.getUntrackedParameter<int>("noisyCellDef",500);
 
   // switch on/off the summaries for the Synchronous noise
   doSynchNoise = ps.getUntrackedParameter<bool>("doSynchNoise", false);
   detailedAnalysis = ps.getUntrackedParameter<bool>("detailedAnalysis",false);
   maxSynchNoiseRate =  ps.getUntrackedParameter<double>("maxSynchNoiseRate", 0.001);
   nMinEvts  = ps.getUntrackedParameter<int>("nEventsCert", 5000);
 
   nevents = 0;
 
   bookingdone = 0;
 
 }

DTNoiseAnalysisTest::~DTNoiseAnalysisTest ( )

virtual

Destructor.

Definition at line 58 of file DTNoiseAnalysisTest.cc.

References LogTrace, and cmsHarvester::nevents.

                                          {
   LogTrace("DTDQM|DTMonitorClient|DTNoiseAnalysisTest") << "DTNoiseAnalysisTest: analyzed " << nevents << " events";
 }

Member Function Documentation

void DTNoiseAnalysisTest::beginRun	(	edm::Run const &	run,
		edm::EventSetup const &	context
	)

protectedvirtual

BeginRun.

Reimplemented from DQMEDHarvester.

Definition at line 63 of file DTNoiseAnalysisTest.cc.

References edm::EventSetup::get().

                                                                             {
 
   // Get the geometry
   context.get<MuonGeometryRecord>().get(muonGeom);
 
 }

void DTNoiseAnalysisTest::bookHistos ( DQMStore::IBooker & ibooker )

protected

book the summary histograms

Definition at line 244 of file DTNoiseAnalysisTest.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), MonitorElement::setAxisTitle(), MonitorElement::setBinLabel(), and DQMStore::IBooker::setCurrentFolder().

                                                               {
 
   ibooker.setCurrentFolder("DT/05-Noise");
   string histoName;
 
   for(int wh=-2; wh<=2; wh++){
     stringstream wheel; wheel << wh;
     histoName =  "NoiseRateSummary_W" + wheel.str();
 
     noiseHistos[wh] = ibooker.book1D(histoName.c_str(),histoName.c_str(),100,0,2000);
     noiseHistos[wh]->setAxisTitle("rate (Hz)",1);
     noiseHistos[wh]->setAxisTitle("entries",2);
   }
   histoName =  "NoiseRateSummary";
 
   noiseHistos[3] = ibooker.book1D(histoName.c_str(),histoName.c_str(),100,0,2000);
   noiseHistos[3]->setAxisTitle("rate (Hz)",1);
   noiseHistos[3]->setAxisTitle("entries",2);
 
 
   for(int wh=-2; wh<=2; wh++){
     stringstream wheel; wheel << wh;
     histoName =  "NoiseSummary_W" + wheel.str();
 
     noisyCellHistos[wh] = ibooker.book2D(histoName.c_str(),"# of noisy channels",12,1,13,4,1,5);
     noisyCellHistos[wh]->setBinLabel(1,"MB1",2);
     noisyCellHistos[wh]->setBinLabel(2,"MB2",2);
     noisyCellHistos[wh]->setBinLabel(3,"MB3",2);
     noisyCellHistos[wh]->setBinLabel(4,"MB4",2);  
     noisyCellHistos[wh]->setAxisTitle("Sector",1);
   }
 
   histoName =  "NoiseSummary";
 
   summaryNoiseHisto =  ibooker.book2D(histoName.c_str(),"# of noisy channels",12,1,13,5,-2,3);
   summaryNoiseHisto->setAxisTitle("Sector",1);
   summaryNoiseHisto->setAxisTitle("Wheel",2);
 
   if(detailedAnalysis) {
     histoName = "NoisyChannels";
 
     threshChannelsHisto = ibooker.book1D(histoName.c_str(),"# of noisy channels vs threshold",15,500,2000);
     threshChannelsHisto->setAxisTitle("threshold",1);
     threshChannelsHisto->setAxisTitle("# noisy channels",2);
   }
 
   if(doSynchNoise) {
     ibooker.setCurrentFolder("DT/05-Noise/SynchNoise/");
     histoName =  "SynchNoiseSummary";
 
     summarySynchNoiseHisto = ibooker.book2D(histoName.c_str(),"Summary Synch. Noise",12,1,13,5,-2,3);
     summarySynchNoiseHisto->setAxisTitle("Sector",1);
     summarySynchNoiseHisto->setAxisTitle("Wheel",2);
     histoName =  "SynchNoiseGlbSummary";
 
     glbSummarySynchNoiseHisto = ibooker.book2D(histoName.c_str(),"Summary Synch. Noise",12,1,13,5,-2,3);
     glbSummarySynchNoiseHisto->setAxisTitle("Sector",1);
     glbSummarySynchNoiseHisto->setAxisTitle("Wheel",2);
   }
 
 }

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

protectedvirtual

Implements DQMEDHarvester.

Definition at line 321 of file DTNoiseAnalysisTest.cc.

321 {}

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

protectedvirtual

DQM Client Diagnostic.

Reimplemented from DQMEDHarvester.

Definition at line 71 of file DTNoiseAnalysisTest.cc.

References bookHistos(), DQMStore::IGetter::get(), MonitorElement::getFloatValue(), MonitorElement::getTH2F(), timingPdfMaker::histo, LogTrace, cmsHarvester::nevents, HLT_25ns10e33_v2_cff::noise, plotResiduals::plot(), DTChamberId::sector(), DTChamberId::station(), relval_parameters_module::step, and DTChamberId::wheel().

                                                                                                      {
 
   float chRate;
 
   if (!bookingdone) {
     // book the histos
   bookHistos(ibooker);
   }
   bookingdone = 1; 
 
 
   LogVerbatim ("DTDQM|DTMonitorClient|DTNoiseAnalysisTest")
     <<"[DTNoiseAnalysisTest]: End of LS transition, performing the DQM client operation";
 
   // Reset the summary plots
   for(map<int, MonitorElement* >::iterator plot =  noiseHistos.begin();
       plot != noiseHistos.end(); ++plot) {
     (*plot).second->Reset();
   }
 
   for(map<int,  MonitorElement* >::iterator plot = noisyCellHistos.begin();
       plot != noisyCellHistos.end(); ++plot) {
     (*plot).second->Reset();
   }
 
   summaryNoiseHisto->Reset();
 
 
 
   vector<const DTChamber*>::const_iterator ch_it = muonGeom->chambers().begin();
   vector<const DTChamber*>::const_iterator ch_end = muonGeom->chambers().end();
 
   LogTrace ("DTDQM|DTMonitorClient|DTNoiseAnalysisTest")
     <<"[DTNoiseAnalysisTest]: Fill the summary histos";
 
   for (; ch_it != ch_end; ++ch_it) { // loop over chambers
     DTChamberId chID = (*ch_it)->id();
 
     MonitorElement * histo = igetter.get(getMEName(chID));
 
     if(histo) { // check the pointer
 
       TH2F * histo_root = histo->getTH2F();
 
       for(int sl = 1; sl != 4; ++sl) { // loop over SLs
         // skip theta SL in MB4 chambers
         if(chID.station() == 4 && sl == 2) continue;
 
         int binYlow = ((sl-1)*4)+1;
 
         for(int layer = 1; layer <= 4; ++layer) { // loop over layers
 
           // Get the layer ID
           DTLayerId layID(chID,sl,layer);
 
           int nWires = muonGeom->layer(layID)->specificTopology().channels();
           int firstWire = muonGeom->layer(layID)->specificTopology().firstChannel();
 
           int binY = binYlow+(layer-1);
 
           for(int wire = firstWire; wire != (nWires+firstWire); wire++){ // loop over wires
 
             double noise = histo_root->GetBinContent(wire, binY);
             // fill the histos
             noiseHistos[chID.wheel()]->Fill(noise);
             noiseHistos[3]->Fill(noise);
             int sector = chID.sector();
             if(noise>noisyCellDef) {
               if(sector == 13) {
                 sector = 4;
               } else if(sector == 14) {
                 sector = 10;
               }
               noisyCellHistos[chID.wheel()]->Fill(sector,chID.station());
               summaryNoiseHisto->Fill(sector,chID.wheel());
             }
           }
         }
       }
     }
   }
 
   if(detailedAnalysis) {
     threshChannelsHisto->Reset();
     TH1F * histo = noiseHistos[3]->getTH1F();
     for(int step = 0; step != 15; step++) {
       int threshBin = step + 1;
       int minBin = 26 + step*5;
       int nNoisyCh = histo->Integral(minBin,101);
       threshChannelsHisto->setBinContent(threshBin,nNoisyCh);
     }
   }
 
   // build the summary of synch noise
 
 
   if(doSynchNoise) {
     LogTrace("DTDQM|DTMonitorClient|DTNoiseAnalysisTest")
       << "[DTNoiseAnalysisTest]: fill summaries for synch noise" << endl;
     summarySynchNoiseHisto->Reset();
     glbSummarySynchNoiseHisto->Reset();
     for(int wheel = -2; wheel != 3; ++wheel) {
       // Get the histo produced by DTDigiTask
 
       MonitorElement * histoNoiseSynch = igetter.get(getSynchNoiseMEName(wheel));
       if(histoNoiseSynch != 0) {
         for(int sect = 1; sect != 13; ++sect) { // loop over sectors
           TH2F * histo = histoNoiseSynch->getTH2F();
           float maxSectRate = 0;
           for(int sta = 1; sta != 5; ++sta) {
             if (nevents>0) chRate = histo->GetBinContent(sect, sta)/(float)nevents;
             else chRate = -1.0;
                       // in case nevents 0 e.g. counting not done
             LogTrace("DTDQM|DTMonitorClient|DTNoiseAnalysisTest")
               << "   Wheel: " << wheel << " sect: " << sect
               << " station: " << sta
               << " rate is: " << chRate << endl;
             if (chRate > maxSectRate)
               maxSectRate = chRate;
           }
           summarySynchNoiseHisto->Fill(sect,wheel,
               maxSectRate > maxSynchNoiseRate ? 1 : 0);
           float glbBinValue = 1 - 0.15*maxSectRate/maxSynchNoiseRate;
           glbSummarySynchNoiseHisto->Fill(sect,wheel,glbBinValue>0 ? glbBinValue : 0);
 
         }
       } else {
         LogWarning("DTDQM|DTMonitorClient|DTNoiseAnalysisTest")
           << "   Histo: " << getSynchNoiseMEName(wheel) << " not found!" << endl;
       }
     }
 
   }
 
   string nEvtsName = "DT/EventInfo/Counters/nProcessedEventsNoise";
 
   MonitorElement * meProcEvts = igetter.get(nEvtsName);
 
   if (meProcEvts) {
     int nProcEvts = meProcEvts->getFloatValue();
     glbSummarySynchNoiseHisto->setEntries(nProcEvts < nMinEvts ? 10. : nProcEvts);
     summarySynchNoiseHisto->setEntries(nProcEvts < nMinEvts ? 10. : nProcEvts);
   } else {
     glbSummarySynchNoiseHisto->setEntries(nMinEvts +1);
     summarySynchNoiseHisto->setEntries(nMinEvts + 1);
     LogVerbatim ("DTDQM|DTMonitorClient|DTnoiseAnalysisTest") << "[DTNoiseAnalysisTest] ME: "
       <<  nEvtsName << " not found!" << endl;
   }
 
 
 }          

string DTNoiseAnalysisTest::getMEName ( const DTChamberId & chID )

private

Get the ME name.

Definition at line 225 of file DTNoiseAnalysisTest.cc.

References DTChamberId::sector(), DTChamberId::station(), relativeConstraints::station, AlCaHLTBitMon_QueryRunRegistry::string, and DTChamberId::wheel().

                                                               {
 
   stringstream wheel; wheel << chID.wheel();    
   stringstream station; station << chID.station();  
   stringstream sector; sector << chID.sector(); 
 
   string folderName = 
     "DT/05-Noise/Wheel" +  wheel.str() +
     "/Sector" + sector.str() + "/";
 
   string histoname = folderName + string("NoiseRate")  
     + "_W" + wheel.str() 
     + "_St" + station.str() 
     + "_Sec" + sector.str();
 
   return histoname;
 
 }

string DTNoiseAnalysisTest::getSynchNoiseMEName ( int wheelId ) const

private

Definition at line 308 of file DTNoiseAnalysisTest.cc.

References AlCaHLTBitMon_QueryRunRegistry::string.

                                                                  {
 
   stringstream wheel; wheel << wheelId; 
   string folderName = 
     "DT/05-Noise/SynchNoise/";
   string histoname = folderName + string("SyncNoiseEvents")  
     + "_W" + wheel.str();
 
   return histoname;
 
 }

Member Data Documentation

bool DTNoiseAnalysisTest::bookingdone

private

Definition at line 71 of file DTNoiseAnalysisTest.h.

bool DTNoiseAnalysisTest::detailedAnalysis

private

Definition at line 88 of file DTNoiseAnalysisTest.h.

bool DTNoiseAnalysisTest::doSynchNoise

private

Definition at line 87 of file DTNoiseAnalysisTest.h.

MonitorElement* DTNoiseAnalysisTest::glbSummarySynchNoiseHisto

private

Definition at line 85 of file DTNoiseAnalysisTest.h.

double DTNoiseAnalysisTest::maxSynchNoiseRate

private

Definition at line 89 of file DTNoiseAnalysisTest.h.

edm::ESHandle<DTGeometry> DTNoiseAnalysisTest::muonGeom

private

Definition at line 74 of file DTNoiseAnalysisTest.h.

int DTNoiseAnalysisTest::nevents

private

Definition at line 68 of file DTNoiseAnalysisTest.h.

int DTNoiseAnalysisTest::nMinEvts

private

Definition at line 69 of file DTNoiseAnalysisTest.h.

std::map< int, MonitorElement* > DTNoiseAnalysisTest::noiseHistos

private

Definition at line 80 of file DTNoiseAnalysisTest.h.

int DTNoiseAnalysisTest::noisyCellDef

private

Definition at line 77 of file DTNoiseAnalysisTest.h.

std::map< int, MonitorElement* > DTNoiseAnalysisTest::noisyCellHistos

private

Definition at line 81 of file DTNoiseAnalysisTest.h.

MonitorElement* DTNoiseAnalysisTest::summaryNoiseHisto

private

Definition at line 82 of file DTNoiseAnalysisTest.h.

MonitorElement* DTNoiseAnalysisTest::summarySynchNoiseHisto

private

Definition at line 84 of file DTNoiseAnalysisTest.h.

MonitorElement* DTNoiseAnalysisTest::threshChannelsHisto

private

Definition at line 83 of file DTNoiseAnalysisTest.h.

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation