#include <GlobalRecHitsHistogrammer.h>

Inheritance diagram for GlobalRecHitsHistogrammer:

Public Types
typedef std::map< uint32_t, float, std::less< uint32_t > >	MapType

Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override

	GlobalRecHitsHistogrammer (const edm::ParameterSet &)

	~GlobalRecHitsHistogrammer () override

Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final

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

void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final

void	beginStream (edm::StreamID id) final

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

	DQMEDAnalyzer ()

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

void	endRun (edm::Run const &run, edm::EventSetup const &setup) final

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Attributes
unsigned int	count

bool	doOutput

std::string	fName

int	frequency

bool	getAllProvenances

edm::InputTag	GlobalRecHitSrc_

edm::EDGetTokenT< PGlobalRecHit >	GlobalRecHitSrc_Token_

std::string	label

MonitorElement *	mehCSCn

MonitorElement *	mehCSCResRDPhi

MonitorElement *	mehDtMuonn

MonitorElement *	mehDtMuonRes

MonitorElement *	mehEcaln [3]

MonitorElement *	mehEcalRes [3]

MonitorElement *	mehHcaln [4]

MonitorElement *	mehHcalRes [4]

MonitorElement *	mehRPCn

MonitorElement *	mehRPCResX

MonitorElement *	mehSiPixeln [7]

MonitorElement *	mehSiPixelResX [7]

MonitorElement *	mehSiPixelResY [7]

MonitorElement *	mehSiStripn [19]

MonitorElement *	mehSiStripResX [19]

MonitorElement *	mehSiStripResY [19]

std::string	outputfile

bool	printProvenanceInfo

int	verbosity

Additional Inherited Members
Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)

static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)

static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)

static std::unique_ptr < DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

Definition at line 49 of file GlobalRecHitsHistogrammer.h.

Member Typedef Documentation

typedef std::map<uint32_t, float, std::less<uint32_t> > GlobalRecHitsHistogrammer::MapType

Definition at line 54 of file GlobalRecHitsHistogrammer.h.

Constructor & Destructor Documentation

GlobalRecHitsHistogrammer::GlobalRecHitsHistogrammer ( const edm::ParameterSet & iPSet )

explicit

Definition at line 12 of file GlobalRecHitsHistogrammer.cc.

References doOutput, fName, frequency, getAllProvenances, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), GlobalRecHitSrc_, GlobalRecHitSrc_Token_, outputfile, printProvenanceInfo, AlCaHLTBitMon_QueryRunRegistry::string, and verbosity.

     : fName(""), verbosity(0), frequency(0), label(""), getAllProvenances(false), printProvenanceInfo(false), count(0) {
   std::string MsgLoggerCat = "GlobalRecHitsAnalyzer_GlobalRecHitsAnalyzer";
 
   // get information from parameter set
   fName = iPSet.getUntrackedParameter<std::string>("Name");
   verbosity = iPSet.getUntrackedParameter<int>("Verbosity");
   frequency = iPSet.getUntrackedParameter<int>("Frequency");
   outputfile = iPSet.getParameter<std::string>("outputFile");
   doOutput = iPSet.getParameter<bool>("DoOutput");
   edm::ParameterSet m_Prov = iPSet.getParameter<edm::ParameterSet>("ProvenanceLookup");
   getAllProvenances = m_Prov.getUntrackedParameter<bool>("GetAllProvenances");
   printProvenanceInfo = m_Prov.getUntrackedParameter<bool>("PrintProvenanceInfo");
 
   //get Labels to use to extract information
   GlobalRecHitSrc_ = iPSet.getParameter<edm::InputTag>("GlobalRecHitSrc");
   GlobalRecHitSrc_Token_ = consumes<PGlobalRecHit>(iPSet.getParameter<edm::InputTag>("GlobalRecHitSrc"));
   // ECalEBSrc_ = iPSet.getParameter<edm::InputTag>("ECalEBSrc");
   //ECalUncalEBSrc_ = iPSet.getParameter<edm::InputTag>("ECalUncalEBSrc");
   //ECalEESrc_ = iPSet.getParameter<edm::InputTag>("ECalEESrc");
   //ECalUncalEESrc_ = iPSet.getParameter<edm::InputTag>("ECalUncalEESrc");
   //ECalESSrc_ = iPSet.getParameter<edm::InputTag>("ECalESSrc");
   //HCalSrc_ = iPSet.getParameter<edm::InputTag>("HCalSrc");
   //SiStripSrc_ = iPSet.getParameter<edm::InputTag>("SiStripSrc");
   //SiPxlSrc_ = iPSet.getParameter<edm::InputTag>("SiPxlSrc");
   //MuDTSrc_ = iPSet.getParameter<edm::InputTag>("MuDTSrc");
   //MuDTSimSrc_ = iPSet.getParameter<edm::InputTag>("MuDTSimSrc");
   //MuCSCSrc_ = iPSet.getParameter<edm::InputTag>("MuCSCSrc");
   //MuRPCSrc_ = iPSet.getParameter<edm::InputTag>("MuRPCSrc");
   //MuRPCSimSrc_ = iPSet.getParameter<edm::InputTag>("MuRPCSimSrc");
 
   //conf_ = iPSet;
 
   // use value of first digit to determine default output level (inclusive)
   // 0 is none, 1 is basic, 2 is fill output, 3 is gather output
   verbosity %= 10;
 
   // create persistent object
   // produces<PGlobalRecHit>(label);
 
   // print out Parameter Set information being used
   if (verbosity >= 0) {
     edm::LogInfo(MsgLoggerCat) << "\n===============================\n"
                                << "Initialized as EDProducer with parameter values:\n"
                                << "    Name           = " << fName << "\n"
                                << "    Verbosity      = " << verbosity << "\n"
                                << "    Frequency      = " << frequency << "\n"
                                << "    OutputFile     = " << outputfile << "\n"
                                << "    DoOutput      = " << doOutput << "\n"
                                << "    GetProv        = " << getAllProvenances << "\n"
                                << "    PrintProv      = " << printProvenanceInfo << "\n"
                                << "    Global Src     = " << GlobalRecHitSrc_ << "\n"
                                << "===============================\n";
   }
 }

GlobalRecHitsHistogrammer::~GlobalRecHitsHistogrammer ( )

override

Definition at line 68 of file GlobalRecHitsHistogrammer.cc.

68 {}

Member Function Documentation

void GlobalRecHitsHistogrammer::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 255 of file GlobalRecHitsHistogrammer.cc.

References count, edm::EventID::event(), dqm::impl::MonitorElement::Fill(), frequency, getAllProvenances, edm::Event::getAllStableProvenance(), edm::Event::getByToken(), GlobalRecHitSrc_Token_, mps_fire::i, edm::EventBase::id(), edm::HandleBase::isValid(), mehCSCn, mehCSCResRDPhi, mehDtMuonn, mehDtMuonRes, mehEcaln, mehEcalRes, mehHcaln, mehHcalRes, mehRPCn, mehRPCResX, mehSiPixeln, mehSiPixelResX, mehSiPixelResY, mehSiStripn, mehSiStripResX, mehSiStripResY, nevt, printProvenanceInfo, submitPVResolutionJobs::REC, edm::EventID::run(), AlCaHLTBitMon_QueryRunRegistry::string, and verbosity.

                                                                                            {
   std::string MsgLoggerCat = "GlobalRecHitsHistogrammer_analyze";
 
   // keep track of number of events processed
   ++count;
 
   // get event id information
   edm::RunNumber_t nrun = iEvent.id().run();
   edm::EventNumber_t nevt = iEvent.id().event();
 
   if (verbosity > 0) {
     edm::LogInfo(MsgLoggerCat) << "Processing run " << nrun << ", event " << nevt << " (" << count << " events total)";
   } else if (verbosity == 0) {
     if (nevt % frequency == 0 || nevt == 1) {
       edm::LogInfo(MsgLoggerCat) << "Processing run " << nrun << ", event " << nevt << " (" << count
                                  << " events total)";
     }
   }
 
   // clear event holders
   //clear();  Not in example I'm using, thus I comment it out.
 
   // look at information available in the event
   if (getAllProvenances) {
     std::vector<const edm::StableProvenance*> AllProv;
     iEvent.getAllStableProvenance(AllProv);
 
     if (verbosity >= 0)
       edm::LogInfo(MsgLoggerCat) << "Number of Provenances = " << AllProv.size();
 
     if (printProvenanceInfo && (verbosity >= 0)) {
       TString eventout("\nProvenance info:\n");
 
       for (unsigned int i = 0; i < AllProv.size(); ++i) {
         eventout += "\n       ******************************";
         eventout += "\n       Module       : ";
         //eventout += (AllProv[i]->product).moduleLabel();
         eventout += AllProv[i]->moduleLabel();
         eventout += "\n       ProductID    : ";
         //eventout += (AllProv[i]->product).productID_.id_;
         eventout += AllProv[i]->productID().id();
         eventout += "\n       ClassName    : ";
         //eventout += (AllProv[i]->product).fullClassName_;
         eventout += AllProv[i]->className();
         eventout += "\n       InstanceName : ";
         //eventout += (AllProv[i]->product).productInstanceName_;
         eventout += AllProv[i]->productInstanceName();
         eventout += "\n       BranchName   : ";
         //eventout += (AllProv[i]->product).branchName_;
         eventout += AllProv[i]->branchName();
       }
       eventout += "\n       ******************************\n";
       edm::LogInfo(MsgLoggerCat) << eventout << "\n";
       printProvenanceInfo = false;
     }
     getAllProvenances = false;
   }
 
   edm::Handle<PGlobalRecHit> srcGlobalRecHits;
   iEvent.getByToken(GlobalRecHitSrc_Token_, srcGlobalRecHits);
   if (!srcGlobalRecHits.isValid()) {
     edm::LogWarning(MsgLoggerCat) << "Unable to find PGlobalRecHit in event!";
     return;
   }
 
   int nEBCalRecHits = srcGlobalRecHits->getnEBCalRecHits();
   int nEECalRecHits = srcGlobalRecHits->getnEECalRecHits();
   int nESCalRecHits = srcGlobalRecHits->getnESCalRecHits();
 
   int nHBCalRecHits = srcGlobalRecHits->getnHBCalRecHits();
   int nHECalRecHits = srcGlobalRecHits->getnHECalRecHits();
   int nHOCalRecHits = srcGlobalRecHits->getnHOCalRecHits();
   int nHFCalRecHits = srcGlobalRecHits->getnHFCalRecHits();
 
   int nTIBL1RecHits = srcGlobalRecHits->getnTIBL1RecHits();
   int nTIBL2RecHits = srcGlobalRecHits->getnTIBL2RecHits();
   int nTIBL3RecHits = srcGlobalRecHits->getnTIBL3RecHits();
   int nTIBL4RecHits = srcGlobalRecHits->getnTIBL4RecHits();
   int nTOBL1RecHits = srcGlobalRecHits->getnTOBL1RecHits();
   int nTOBL2RecHits = srcGlobalRecHits->getnTOBL2RecHits();
   int nTOBL3RecHits = srcGlobalRecHits->getnTOBL3RecHits();
   int nTOBL4RecHits = srcGlobalRecHits->getnTOBL4RecHits();
   int nTIDW1RecHits = srcGlobalRecHits->getnTIDW1RecHits();
   int nTIDW2RecHits = srcGlobalRecHits->getnTIDW2RecHits();
   int nTIDW3RecHits = srcGlobalRecHits->getnTIDW3RecHits();
   int nTECW1RecHits = srcGlobalRecHits->getnTECW1RecHits();
   int nTECW2RecHits = srcGlobalRecHits->getnTECW2RecHits();
   int nTECW3RecHits = srcGlobalRecHits->getnTECW3RecHits();
   int nTECW4RecHits = srcGlobalRecHits->getnTECW4RecHits();
   int nTECW5RecHits = srcGlobalRecHits->getnTECW5RecHits();
   int nTECW6RecHits = srcGlobalRecHits->getnTECW6RecHits();
   int nTECW7RecHits = srcGlobalRecHits->getnTECW7RecHits();
   int nTECW8RecHits = srcGlobalRecHits->getnTECW8RecHits();
 
   int nBRL1RecHits = srcGlobalRecHits->getnBRL1RecHits();
   int nBRL2RecHits = srcGlobalRecHits->getnBRL2RecHits();
   int nBRL3RecHits = srcGlobalRecHits->getnBRL3RecHits();
   int nFWD1nRecHits = srcGlobalRecHits->getnFWD1nRecHits();
   int nFWD1pRecHits = srcGlobalRecHits->getnFWD1pRecHits();
   int nFWD2nRecHits = srcGlobalRecHits->getnFWD2nRecHits();
   int nFWD2pRecHits = srcGlobalRecHits->getnFWD2pRecHits();
 
   int nDTRecHits = srcGlobalRecHits->getnDTRecHits();
 
   int nCSCRecHits = srcGlobalRecHits->getnCSCRecHits();
 
   int nRPCRecHits = srcGlobalRecHits->getnRPCRecHits();
 
   // get Ecal info
   std::vector<PGlobalRecHit::ECalRecHit> EECalRecHits = srcGlobalRecHits->getEECalRecHits();
   mehEcaln[0]->Fill((float)nEECalRecHits);
   for (unsigned int i = 0; i < EECalRecHits.size(); ++i) {
     mehEcalRes[0]->Fill(EECalRecHits[i].RE - EECalRecHits[i].SHE);
   }
 
   std::vector<PGlobalRecHit::ECalRecHit> EBCalRecHits = srcGlobalRecHits->getEBCalRecHits();
   mehEcaln[1]->Fill((float)nEBCalRecHits);
   for (unsigned int i = 0; i < EBCalRecHits.size(); ++i) {
     mehEcalRes[1]->Fill(EBCalRecHits[i].RE - EBCalRecHits[i].SHE);
   }
 
   std::vector<PGlobalRecHit::ECalRecHit> ESCalRecHits = srcGlobalRecHits->getESCalRecHits();
   mehEcaln[2]->Fill((float)nESCalRecHits);
   for (unsigned int i = 0; i < ESCalRecHits.size(); ++i) {
     mehEcalRes[2]->Fill(ESCalRecHits[i].RE - ESCalRecHits[i].SHE);
   }
 
   // Get HCal info
   std::vector<PGlobalRecHit::HCalRecHit> HBCalRecHits = srcGlobalRecHits->getHBCalRecHits();
   mehHcaln[0]->Fill((float)nHBCalRecHits);
   for (unsigned int i = 0; i < HBCalRecHits.size(); ++i) {
     mehHcalRes[0]->Fill(HBCalRecHits[i].REC - HBCalRecHits[i].SHE);
   }
 
   std::vector<PGlobalRecHit::HCalRecHit> HECalRecHits = srcGlobalRecHits->getHECalRecHits();
   mehHcaln[1]->Fill((float)nHECalRecHits);
   for (unsigned int i = 0; i < HECalRecHits.size(); ++i) {
     mehHcalRes[1]->Fill(HECalRecHits[i].REC - HECalRecHits[i].SHE);
   }
 
   std::vector<PGlobalRecHit::HCalRecHit> HOCalRecHits = srcGlobalRecHits->getHOCalRecHits();
   mehHcaln[2]->Fill((float)nHOCalRecHits);
   for (unsigned int i = 0; i < HOCalRecHits.size(); ++i) {
     mehHcalRes[2]->Fill(HOCalRecHits[i].REC - HOCalRecHits[i].SHE);
   }
 
   std::vector<PGlobalRecHit::HCalRecHit> HFCalRecHits = srcGlobalRecHits->getHFCalRecHits();
   mehHcaln[3]->Fill((float)nHFCalRecHits);
   for (unsigned int i = 0; i < HFCalRecHits.size(); ++i) {
     mehHcalRes[3]->Fill(HFCalRecHits[i].REC - HFCalRecHits[i].SHE);
   }
 
   // get SiStrip info
   std::vector<PGlobalRecHit::SiStripRecHit> TIBL1RecHits = srcGlobalRecHits->getTIBL1RecHits();
   mehSiStripn[0]->Fill((float)nTIBL1RecHits);
   for (unsigned int i = 0; i < TIBL1RecHits.size(); ++i) {
     mehSiStripResX[0]->Fill(TIBL1RecHits[i].RX - TIBL1RecHits[i].SX);
     mehSiStripResY[0]->Fill(TIBL1RecHits[i].RY - TIBL1RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiStripRecHit> TIBL2RecHits = srcGlobalRecHits->getTIBL2RecHits();
   mehSiStripn[1]->Fill((float)nTIBL2RecHits);
   for (unsigned int i = 0; i < TIBL2RecHits.size(); ++i) {
     mehSiStripResX[1]->Fill(TIBL2RecHits[i].RX - TIBL2RecHits[i].SX);
     mehSiStripResY[1]->Fill(TIBL2RecHits[i].RY - TIBL2RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiStripRecHit> TIBL3RecHits = srcGlobalRecHits->getTIBL3RecHits();
   mehSiStripn[2]->Fill((float)nTIBL3RecHits);
   for (unsigned int i = 0; i < TIBL3RecHits.size(); ++i) {
     mehSiStripResX[2]->Fill(TIBL3RecHits[i].RX - TIBL3RecHits[i].SX);
     mehSiStripResY[2]->Fill(TIBL3RecHits[i].RY - TIBL3RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiStripRecHit> TIBL4RecHits = srcGlobalRecHits->getTIBL4RecHits();
   mehSiStripn[3]->Fill((float)nTIBL4RecHits);
   for (unsigned int i = 0; i < TIBL4RecHits.size(); ++i) {
     mehSiStripResX[3]->Fill(TIBL4RecHits[i].RX - TIBL4RecHits[i].SX);
     mehSiStripResY[3]->Fill(TIBL4RecHits[i].RY - TIBL4RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiStripRecHit> TOBL1RecHits = srcGlobalRecHits->getTOBL1RecHits();
   mehSiStripn[4]->Fill((float)nTOBL1RecHits);
   for (unsigned int i = 0; i < TOBL1RecHits.size(); ++i) {
     mehSiStripResX[4]->Fill(TOBL1RecHits[i].RX - TOBL1RecHits[i].SX);
     mehSiStripResY[4]->Fill(TOBL1RecHits[i].RY - TOBL1RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiStripRecHit> TOBL2RecHits = srcGlobalRecHits->getTOBL2RecHits();
   mehSiStripn[5]->Fill((float)nTOBL2RecHits);
   for (unsigned int i = 0; i < TOBL2RecHits.size(); ++i) {
     mehSiStripResX[5]->Fill(TOBL2RecHits[i].RX - TOBL2RecHits[i].SX);
     mehSiStripResY[5]->Fill(TOBL2RecHits[i].RY - TOBL2RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiStripRecHit> TOBL3RecHits = srcGlobalRecHits->getTOBL3RecHits();
   mehSiStripn[6]->Fill((float)nTOBL3RecHits);
   for (unsigned int i = 0; i < TOBL3RecHits.size(); ++i) {
     mehSiStripResX[6]->Fill(TOBL3RecHits[i].RX - TOBL3RecHits[i].SX);
     mehSiStripResY[6]->Fill(TOBL3RecHits[i].RY - TOBL3RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiStripRecHit> TOBL4RecHits = srcGlobalRecHits->getTOBL4RecHits();
   mehSiStripn[7]->Fill((float)nTOBL4RecHits);
   for (unsigned int i = 0; i < TOBL4RecHits.size(); ++i) {
     mehSiStripResX[7]->Fill(TOBL4RecHits[i].RX - TOBL4RecHits[i].SX);
     mehSiStripResY[7]->Fill(TOBL4RecHits[i].RY - TOBL4RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiStripRecHit> TIDW1RecHits = srcGlobalRecHits->getTIDW1RecHits();
   mehSiStripn[8]->Fill((float)nTIDW1RecHits);
   for (unsigned int i = 0; i < TIDW1RecHits.size(); ++i) {
     mehSiStripResX[8]->Fill(TIDW1RecHits[i].RX - TIDW1RecHits[i].SX);
     mehSiStripResY[8]->Fill(TIDW1RecHits[i].RY - TIDW1RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiStripRecHit> TIDW2RecHits = srcGlobalRecHits->getTIDW2RecHits();
   mehSiStripn[9]->Fill((float)nTIDW2RecHits);
   for (unsigned int i = 0; i < TIDW2RecHits.size(); ++i) {
     mehSiStripResX[9]->Fill(TIDW2RecHits[i].RX - TIDW2RecHits[i].SX);
     mehSiStripResY[9]->Fill(TIDW2RecHits[i].RY - TIDW2RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiStripRecHit> TIDW3RecHits = srcGlobalRecHits->getTIDW3RecHits();
   mehSiStripn[10]->Fill((float)nTIDW3RecHits);
   for (unsigned int i = 0; i < TIDW3RecHits.size(); ++i) {
     mehSiStripResX[10]->Fill(TIDW3RecHits[i].RX - TIDW3RecHits[i].SX);
     mehSiStripResY[10]->Fill(TIDW3RecHits[i].RY - TIDW3RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiStripRecHit> TECW1RecHits = srcGlobalRecHits->getTECW1RecHits();
   mehSiStripn[11]->Fill((float)nTECW1RecHits);
   for (unsigned int i = 0; i < TECW1RecHits.size(); ++i) {
     mehSiStripResX[11]->Fill(TECW1RecHits[i].RX - TECW1RecHits[i].SX);
     mehSiStripResY[11]->Fill(TECW1RecHits[i].RY - TECW1RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiStripRecHit> TECW2RecHits = srcGlobalRecHits->getTECW2RecHits();
   mehSiStripn[12]->Fill((float)nTECW2RecHits);
   for (unsigned int i = 0; i < TECW2RecHits.size(); ++i) {
     mehSiStripResX[12]->Fill(TECW2RecHits[i].RX - TECW2RecHits[i].SX);
     mehSiStripResY[12]->Fill(TECW2RecHits[i].RY - TECW2RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiStripRecHit> TECW3RecHits = srcGlobalRecHits->getTECW3RecHits();
   mehSiStripn[13]->Fill((float)nTECW3RecHits);
   for (unsigned int i = 0; i < TECW3RecHits.size(); ++i) {
     mehSiStripResX[13]->Fill(TECW3RecHits[i].RX - TECW3RecHits[i].SX);
     mehSiStripResY[13]->Fill(TECW3RecHits[i].RY - TECW3RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiStripRecHit> TECW4RecHits = srcGlobalRecHits->getTECW4RecHits();
   mehSiStripn[14]->Fill((float)nTECW4RecHits);
   for (unsigned int i = 0; i < TECW4RecHits.size(); ++i) {
     mehSiStripResX[14]->Fill(TECW4RecHits[i].RX - TECW4RecHits[i].SX);
     mehSiStripResY[14]->Fill(TECW4RecHits[i].RY - TECW4RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiStripRecHit> TECW5RecHits = srcGlobalRecHits->getTECW5RecHits();
   mehSiStripn[15]->Fill((float)nTECW5RecHits);
   for (unsigned int i = 0; i < TECW5RecHits.size(); ++i) {
     mehSiStripResX[15]->Fill(TECW5RecHits[i].RX - TECW5RecHits[i].SX);
     mehSiStripResY[15]->Fill(TECW5RecHits[i].RY - TECW5RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiStripRecHit> TECW6RecHits = srcGlobalRecHits->getTECW6RecHits();
   mehSiStripn[16]->Fill((float)nTECW6RecHits);
   for (unsigned int i = 0; i < TECW6RecHits.size(); ++i) {
     mehSiStripResX[16]->Fill(TECW6RecHits[i].RX - TECW6RecHits[i].SX);
     mehSiStripResY[16]->Fill(TECW6RecHits[i].RY - TECW6RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiStripRecHit> TECW7RecHits = srcGlobalRecHits->getTECW7RecHits();
   mehSiStripn[17]->Fill((float)nTECW7RecHits);
   for (unsigned int i = 0; i < TECW7RecHits.size(); ++i) {
     mehSiStripResX[17]->Fill(TECW7RecHits[i].RX - TECW7RecHits[i].SX);
     mehSiStripResY[17]->Fill(TECW7RecHits[i].RY - TECW7RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiStripRecHit> TECW8RecHits = srcGlobalRecHits->getTECW8RecHits();
   mehSiStripn[18]->Fill((float)nTECW8RecHits);
   for (unsigned int i = 0; i < TECW8RecHits.size(); ++i) {
     mehSiStripResX[18]->Fill(TECW8RecHits[i].RX - TECW8RecHits[i].SX);
     mehSiStripResY[18]->Fill(TECW8RecHits[i].RY - TECW8RecHits[i].SY);
   }
 
   // get SiPixel info
   std::vector<PGlobalRecHit::SiPixelRecHit> BRL1RecHits = srcGlobalRecHits->getBRL1RecHits();
   mehSiPixeln[0]->Fill((float)nBRL1RecHits);
   for (unsigned int i = 0; i < BRL1RecHits.size(); ++i) {
     mehSiPixelResX[0]->Fill(BRL1RecHits[i].RX - BRL1RecHits[i].SX);
     mehSiPixelResY[0]->Fill(BRL1RecHits[i].RY - BRL1RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiPixelRecHit> BRL2RecHits = srcGlobalRecHits->getBRL2RecHits();
   mehSiPixeln[1]->Fill((float)nBRL2RecHits);
   for (unsigned int i = 0; i < BRL2RecHits.size(); ++i) {
     mehSiPixelResX[1]->Fill(BRL2RecHits[i].RX - BRL2RecHits[i].SX);
     mehSiPixelResY[1]->Fill(BRL2RecHits[i].RY - BRL2RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiPixelRecHit> BRL3RecHits = srcGlobalRecHits->getBRL3RecHits();
   mehSiPixeln[2]->Fill((float)nBRL3RecHits);
   for (unsigned int i = 0; i < BRL3RecHits.size(); ++i) {
     mehSiPixelResX[2]->Fill(BRL3RecHits[i].RX - BRL3RecHits[i].SX);
     mehSiPixelResY[2]->Fill(BRL3RecHits[i].RY - BRL3RecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiPixelRecHit> FWD1pRecHits = srcGlobalRecHits->getFWD1pRecHits();
   mehSiPixeln[3]->Fill((float)nFWD1pRecHits);
   for (unsigned int i = 0; i < FWD1pRecHits.size(); ++i) {
     mehSiPixelResX[3]->Fill(FWD1pRecHits[i].RX - FWD1pRecHits[i].SX);
     mehSiPixelResY[3]->Fill(FWD1pRecHits[i].RY - FWD1pRecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiPixelRecHit> FWD1nRecHits = srcGlobalRecHits->getFWD1nRecHits();
   mehSiPixeln[4]->Fill((float)nFWD1nRecHits);
   for (unsigned int i = 0; i < FWD1nRecHits.size(); ++i) {
     mehSiPixelResX[4]->Fill(FWD1nRecHits[i].RX - FWD1nRecHits[i].SX);
     mehSiPixelResY[4]->Fill(FWD1nRecHits[i].RY - FWD1nRecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiPixelRecHit> FWD2pRecHits = srcGlobalRecHits->getFWD2pRecHits();
   mehSiPixeln[5]->Fill((float)nFWD2pRecHits);
   for (unsigned int i = 0; i < FWD2pRecHits.size(); ++i) {
     mehSiPixelResX[5]->Fill(FWD2pRecHits[i].RX - FWD2pRecHits[i].SX);
     mehSiPixelResY[5]->Fill(FWD2pRecHits[i].RY - FWD2pRecHits[i].SY);
   }
 
   std::vector<PGlobalRecHit::SiPixelRecHit> FWD2nRecHits = srcGlobalRecHits->getFWD2nRecHits();
   mehSiPixeln[6]->Fill((float)nFWD2nRecHits);
   for (unsigned int i = 0; i < FWD2nRecHits.size(); ++i) {
     mehSiPixelResX[6]->Fill(FWD2nRecHits[i].RX - FWD2nRecHits[i].SX);
     mehSiPixelResY[6]->Fill(FWD2nRecHits[i].RY - FWD2nRecHits[i].SY);
   }
 
   // get DtMuon info
   std::vector<PGlobalRecHit::DTRecHit> DTRecHits = srcGlobalRecHits->getDTRecHits();
   mehDtMuonn->Fill((float)nDTRecHits);
   for (unsigned int i = 0; i < DTRecHits.size(); ++i) {
     mehDtMuonRes->Fill(DTRecHits[i].RHD - DTRecHits[i].SHD);
   }
 
   // get CSC info
   std::vector<PGlobalRecHit::CSCRecHit> CSCRecHits = srcGlobalRecHits->getCSCRecHits();
   mehCSCn->Fill((float)nCSCRecHits);
   for (unsigned int i = 0; i < CSCRecHits.size(); ++i) {
     mehCSCResRDPhi->Fill(CSCRecHits[i].RHPERP * (CSCRecHits[i].RHPHI - CSCRecHits[i].SHPHI));
   }
 
   // get RPC info
   std::vector<PGlobalRecHit::RPCRecHit> RPCRecHits = srcGlobalRecHits->getRPCRecHits();
   mehRPCn->Fill((float)nRPCRecHits);
   for (unsigned int i = 0; i < RPCRecHits.size(); ++i) {
     mehRPCResX->Fill(RPCRecHits[i].RHX - RPCRecHits[i].SHX);
   }
 
   if (verbosity > 0)
     edm::LogInfo(MsgLoggerCat) << "Done gathering data from event.";
 }

void GlobalRecHitsHistogrammer::bookHistograms	(	DQMStore::IBooker &	ibooker,
		edm::Run const &	,
		edm::EventSetup const &
	)

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 70 of file GlobalRecHitsHistogrammer.cc.

References dqm::implementation::IBooker::book1D(), mps_fire::i, dqmiolumiharvest::j, mehCSCn, mehCSCResRDPhi, mehDtMuonn, mehDtMuonRes, mehEcaln, mehEcalRes, mehHcaln, mehHcalRes, mehRPCn, mehRPCResX, mehSiPixeln, mehSiPixelResX, mehSiPixelResY, mehSiStripn, mehSiStripResX, mehSiStripResY, dqm::impl::MonitorElement::setAxisTitle(), and dqm::implementation::NavigatorBase::setCurrentFolder().

                                                                                                             {
   //monitor elements
 
   //Si Strip
   string SiStripString[19] = {"TECW1",
                               "TECW2",
                               "TECW3",
                               "TECW4",
                               "TECW5",
                               "TECW6",
                               "TECW7",
                               "TECW8",
                               "TIBL1",
                               "TIBL2",
                               "TIBL3",
                               "TIBL4",
                               "TIDW1",
                               "TIDW2",
                               "TIDW3",
                               "TOBL1",
                               "TOBL2",
                               "TOBL3",
                               "TOBL4"};
 
   for (int i = 0; i < 19; ++i) {
     mehSiStripn[i] = nullptr;
     mehSiStripResX[i] = nullptr;
     mehSiStripResY[i] = nullptr;
   }
 
   string hcharname, hchartitle;
   ibooker.setCurrentFolder("GlobalRecHitsV/SiStrips");
   for (int amend = 0; amend < 19; ++amend) {
     hcharname = "hSiStripn_" + SiStripString[amend];
     hchartitle = SiStripString[amend] + "  rechits";
     mehSiStripn[amend] = ibooker.book1D(hcharname, hchartitle, 20, 0., 20.);
     mehSiStripn[amend]->setAxisTitle("Number of hits in " + SiStripString[amend], 1);
     mehSiStripn[amend]->setAxisTitle("Count", 2);
 
     hcharname = "hSiStripResX_" + SiStripString[amend];
     hchartitle = SiStripString[amend] + " rechit x resolution";
     mehSiStripResX[amend] = ibooker.book1D(hcharname, hchartitle, 200, -0.02, .02);
     mehSiStripResX[amend]->setAxisTitle("X-resolution in " + SiStripString[amend], 1);
     mehSiStripResX[amend]->setAxisTitle("Count", 2);
 
     hcharname = "hSiStripResY_" + SiStripString[amend];
     hchartitle = SiStripString[amend] + " rechit y resolution";
     mehSiStripResY[amend] = ibooker.book1D(hcharname, hchartitle, 200, -0.02, .02);
     mehSiStripResY[amend]->setAxisTitle("Y-resolution in " + SiStripString[amend], 1);
     mehSiStripResY[amend]->setAxisTitle("Count", 2);
   }
 
   //HCal
   //string hcharname, hchartitle;
   string HCalString[4] = {"HB", "HE", "HF", "HO"};
   float HCalnUpper[4] = {3000., 3000., 3000., 2000.};
   float HCalnLower[4] = {2000., 2000., 2000., 1000.};
   for (int j = 0; j < 4; ++j) {
     mehHcaln[j] = nullptr;
     mehHcalRes[j] = nullptr;
   }
 
   ibooker.setCurrentFolder("GlobalRecHitsV/HCals");
   for (int amend = 0; amend < 4; ++amend) {
     hcharname = "hHcaln_" + HCalString[amend];
     hchartitle = HCalString[amend] + "  rechits";
     mehHcaln[amend] = ibooker.book1D(hcharname, hchartitle, 500, HCalnLower[amend], HCalnUpper[amend]);
 
     mehHcaln[amend]->setAxisTitle("Number of RecHits", 1);
     mehHcaln[amend]->setAxisTitle("Count", 2);
 
     hcharname = "hHcalRes_" + HCalString[amend];
     hchartitle = HCalString[amend] + "  rechit resolution";
     mehHcalRes[amend] = ibooker.book1D(hcharname, hchartitle, 25, -2., 2.);
     mehHcalRes[amend]->setAxisTitle("RecHit E - SimHit E", 1);
     mehHcalRes[amend]->setAxisTitle("Count", 2);
   }
 
   //Ecal
   string ECalString[3] = {"EB", "EE", "ES"};
   int ECalnBins[3] = {700, 100, 50};
   float ECalnUpper[3] = {20000., 62000., 300.};
   float ECalnLower[3] = {6000., 60000., 100.};
   int ECalResBins[3] = {200, 200, 200};
   float ECalResUpper[3] = {1., 0.3, .0002};
   float ECalResLower[3] = {-1., -0.3, -.0002};
   for (int i = 0; i < 3; ++i) {
     mehEcaln[i] = nullptr;
     mehEcalRes[i] = nullptr;
   }
 
   ibooker.setCurrentFolder("GlobalRecHitsV/ECals");
   for (int amend = 0; amend < 3; ++amend) {
     hcharname = "hEcaln_" + ECalString[amend];
     hchartitle = ECalString[amend] + "  rechits";
     mehEcaln[amend] = ibooker.book1D(hcharname, hchartitle, ECalnBins[amend], ECalnLower[amend], ECalnUpper[amend]);
 
     mehEcaln[amend]->setAxisTitle("Number of RecHits", 1);
     mehEcaln[amend]->setAxisTitle("Count", 2);
 
     hcharname = "hEcalRes_" + ECalString[amend];
     hchartitle = ECalString[amend] + "  rechit resolution";
     mehEcalRes[amend] =
         ibooker.book1D(hcharname, hchartitle, ECalResBins[amend], ECalResLower[amend], ECalResUpper[amend]);
 
     mehEcalRes[amend]->setAxisTitle("RecHit E - SimHit E", 1);
     mehEcalRes[amend]->setAxisTitle("Count", 2);
   }
 
   //Si Pixels
   string SiPixelString[7] = {"BRL1", "BRL2", "BRL3", "FWD1n", "FWD1p", "FWD2n", "FWD2p"};
   for (int j = 0; j < 7; ++j) {
     mehSiPixeln[j] = nullptr;
     mehSiPixelResX[j] = nullptr;
     mehSiPixelResY[j] = nullptr;
   }
 
   ibooker.setCurrentFolder("GlobalRecHitsV/SiPixels");
   for (int amend = 0; amend < 7; ++amend) {
     hcharname = "hSiPixeln_" + SiPixelString[amend];
     hchartitle = SiPixelString[amend] + " rechits";
     mehSiPixeln[amend] = ibooker.book1D(hcharname, hchartitle, 20, 0., 20.);
     mehSiPixeln[amend]->setAxisTitle("Number of hits in " + SiPixelString[amend], 1);
     mehSiPixeln[amend]->setAxisTitle("Count", 2);
 
     hcharname = "hSiPixelResX_" + SiPixelString[amend];
     hchartitle = SiPixelString[amend] + " rechit x resolution";
     mehSiPixelResX[amend] = ibooker.book1D(hcharname, hchartitle, 200, -0.02, .02);
     mehSiPixelResX[amend]->setAxisTitle("X-resolution in " + SiPixelString[amend], 1);
     mehSiPixelResX[amend]->setAxisTitle("Count", 2);
 
     hcharname = "hSiPixelResY_" + SiPixelString[amend];
     hchartitle = SiPixelString[amend] + " rechit y resolution";
     mehSiPixelResY[amend] = ibooker.book1D(hcharname, hchartitle, 200, -0.02, .02);
     mehSiPixelResY[amend]->setAxisTitle("Y-resolution in " + SiPixelString[amend], 1);
     mehSiPixelResY[amend]->setAxisTitle("Count", 2);
   }
 
   //Muons
   ibooker.setCurrentFolder("GlobalRecHitsV/Muons");
   mehDtMuonn = nullptr;
   mehCSCn = nullptr;
   mehRPCn = nullptr;
 
   //std::vector<MonitorElement *> me_List = {mehDtMuonn, mehCSCn, mehRPCn};
   string n_List[3] = {"hDtMuonn", "hCSCn", "hRPCn"};
   //float hist_prop[3] = [25., 0., 50.];
   string hist_string[3] = {"Dt", "CSC", "RPC"};
 
   for (int amend = 0; amend < 3; ++amend) {
     hchartitle = hist_string[amend] + " rechits";
     if (amend == 0) {
       mehDtMuonn = ibooker.book1D(n_List[amend], hchartitle, 25, 0., 50.);
       mehDtMuonn->setAxisTitle("Number of Rechits", 1);
       mehDtMuonn->setAxisTitle("Count", 2);
     }
     if (amend == 1) {
       mehCSCn = ibooker.book1D(n_List[amend], hchartitle, 25, 0., 50.);
       mehCSCn->setAxisTitle("Number of Rechits", 1);
       mehCSCn->setAxisTitle("Count", 2);
     }
     if (amend == 2) {
       mehRPCn = ibooker.book1D(n_List[amend], hchartitle, 25, 0., 50.);
       mehRPCn->setAxisTitle("Number of Rechits", 1);
       mehRPCn->setAxisTitle("Count", 2);
     }
   }
 
   mehDtMuonRes = nullptr;
   mehCSCResRDPhi = nullptr;
   mehRPCResX = nullptr;
 
   hcharname = "hDtMuonRes";
   hchartitle = "DT wire distance resolution";
   mehDtMuonRes = ibooker.book1D(hcharname, hchartitle, 200, -0.2, 0.2);
 
   hcharname = "CSCResRDPhi";
   hchartitle = "CSC perp*dphi resolution";
   mehCSCResRDPhi = ibooker.book1D(hcharname, hchartitle, 200, -0.2, 0.2);
 
   hcharname = "hRPCResX";
   hchartitle = "RPC rechits x resolution";
   mehRPCResX = ibooker.book1D(hcharname, hchartitle, 50, -5., 5.);
 }