#include <MuonEnergyDepositAnalyzer.h>

Inheritance diagram for MuonEnergyDepositAnalyzer:

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

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

	MuonEnergyDepositAnalyzer (const edm::ParameterSet &)
	Constructor. More...

virtual	~MuonEnergyDepositAnalyzer ()
	Destructor. More...

Public Member Functions inherited from DQMEDAnalyzer
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) final

virtual void	beginStream (edm::StreamID id) final

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

	DQMEDAnalyzer (void)

virtual void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

virtual void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

uint32_t	streamId () const

Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default

Public Member Functions inherited from edm::stream::EDAnalyzerBase
	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 (const std::string &iProcessName, std::vector< const char * > &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 ()

Private Attributes
std::string	AlgoName

MonitorElement *	ecalDepEnergyBarrel

MonitorElement *	ecalDepEnergyEndcap

MonitorElement *	ecalS9DepEnergyBarrel

MonitorElement *	ecalS9DepEnergyEndcap

MonitorElement *	ecalS9PointingMuDepEnergy_Glb

MonitorElement *	ecalS9PointingMuDepEnergy_Sta

MonitorElement *	ecalS9PointingMuDepEnergy_Tk

int	emNoBin

double	emNoMax

double	emNoMin

int	emS9NoBin

double	emS9NoMax

double	emS9NoMin

int	hadNoBin

double	hadNoMax

double	hadNoMin

int	hadS9NoBin

double	hadS9NoMax

double	hadS9NoMin

MonitorElement *	hcalDepEnergyBarrel

MonitorElement *	hcalDepEnergyEndcap

MonitorElement *	hcalS9DepEnergyBarrel

MonitorElement *	hcalS9DepEnergyEndcap

MonitorElement *	hcalS9PointingMuDepEnergy_Glb

MonitorElement *	hcalS9PointingMuDepEnergy_Sta

MonitorElement *	hcalS9PointingMuDepEnergy_Tk

MonitorElement *	hoDepEnergy

int	hoNoBin

double	hoNoMax

double	hoNoMin

MonitorElement *	hoS9DepEnergy

int	hoS9NoBin

double	hoS9NoMax

double	hoS9NoMin

MonitorElement *	hoS9PointingMuDepEnergy_Glb

MonitorElement *	hoS9PointingMuDepEnergy_Sta

MonitorElement *	hoS9PointingMuDepEnergy_Tk

std::string	metname

edm::ParameterSet	parameters

edm::EDGetTokenT < reco::MuonCollection >	theMuonCollectionLabel_

MuonServiceProxy *	theService

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T...>	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType

Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr < dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)

static std::shared_ptr < dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)

static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const , dqmDetails::NoCache )

static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const , dqmDetails::NoCache )

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

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)

Detailed Description

Definition at line 32 of file MuonEnergyDepositAnalyzer.h.

Constructor & Destructor Documentation

MuonEnergyDepositAnalyzer::MuonEnergyDepositAnalyzer ( const edm::ParameterSet & pSet )

Constructor.

Definition at line 24 of file MuonEnergyDepositAnalyzer.cc.

References HLT_25ns14e33_v1_cff::AlgoName, MuonServiceProxy_cff::MuonServiceProxy, Parameters::parameters, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                {
   parameters = pSet;
   
   // the services
   theService = new MuonServiceProxy(parameters.getParameter<ParameterSet>("ServiceParameters"));
 
   theMuonCollectionLabel_ = consumes<reco::MuonCollection>(parameters.getParameter<InputTag>("MuonCollection"));
 
   AlgoName = parameters.getParameter<std::string>("AlgoName");
   emNoBin = parameters.getParameter<int>("emSizeBin");
   emNoMin = parameters.getParameter<double>("emSizeMin");
   emNoMax = parameters.getParameter<double>("emSizeMax");
 
   hadNoBin = parameters.getParameter<int>("hadSizeBin");
   hadNoMin = parameters.getParameter<double>("hadSizeMin");
   hadNoMax = parameters.getParameter<double>("hadSizeMax");
   
   emS9NoBin = parameters.getParameter<int>("emS9SizeBin");
   emS9NoMin = parameters.getParameter<double>("emS9SizeMin");
   emS9NoMax = parameters.getParameter<double>("emS9SizeMax");
   
   hadS9NoBin = parameters.getParameter<int>("hadS9SizeBin");
   hadS9NoMin = parameters.getParameter<double>("hadS9SizeMin");
   hadS9NoMax = parameters.getParameter<double>("hadS9SizeMax");
 
   hoNoBin = parameters.getParameter<int>("hoSizeBin");
   hoNoMin = parameters.getParameter<double>("hoSizeMin");
   hoNoMax = parameters.getParameter<double>("hoSizeMax");
   
   hoS9NoBin = parameters.getParameter<int>("hoS9SizeBin");
   hoS9NoMin = parameters.getParameter<double>("hoS9SizeMin");
   hoS9NoMax = parameters.getParameter<double>("hoS9SizeMax");
 }

MuonEnergyDepositAnalyzer::~MuonEnergyDepositAnalyzer ( )

virtual

Destructor.

Definition at line 57 of file MuonEnergyDepositAnalyzer.cc.

                                                       {   
   delete theService;  
 }

Member Function Documentation

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

virtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 130 of file MuonEnergyDepositAnalyzer.cc.

References funct::abs(), reco::MuonEnergy::em, reco::MuonEnergy::emS9, edm::EventSetup::get(), edm::Event::getByToken(), TrajectoryStateOnSurface::globalPosition(), reco::MuonEnergy::had, reco::MuonEnergy::hadS9, reco::MuonEnergy::ho, reco::MuonEnergy::hoS9, reco::TransientTrack::impactPointState(), edm::HandleBase::isValid(), LogTrace, metname, patZpeak::muons, PV3DBase< T, PVType, FrameType >::perp(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                           {
   LogTrace(metname)<<"[MuonEnergyDepositAnalyzer] Filling the histos";
   theService->update(iSetup);
   
   // Take the muon container
   edm::Handle<reco::MuonCollection> muons;
   iEvent.getByToken(theMuonCollectionLabel_,muons);
   
   if (!muons.isValid()) return;
   
   for (reco::MuonCollection::const_iterator recoMu = muons->begin(); recoMu!=muons->end(); ++recoMu){
     // get all the mu energy deposits
     reco::MuonEnergy muEnergy = recoMu->calEnergy();
   
     // energy deposited in ECAL
     LogTrace(metname) << "Energy deposited in ECAL: "<<muEnergy.em;
     if (fabs(recoMu->eta()) > 1.479) 
       ecalDepEnergyEndcap->Fill(muEnergy.em);
     else
       ecalDepEnergyBarrel->Fill(muEnergy.em);
 
     // energy deposited in HCAL
     LogTrace(metname) << "Energy deposited in HCAL: "<<muEnergy.had;
     if (fabs(recoMu->eta()) > 1.4)
       hcalDepEnergyEndcap->Fill(muEnergy.had);
     else
       hcalDepEnergyBarrel->Fill(muEnergy.had);
   
     // energy deposited in HO
     LogTrace(metname) << "Energy deposited in HO: "<<muEnergy.ho;
     if (fabs(recoMu->eta()) < 1.26)
       hoDepEnergy->Fill(muEnergy.ho);
   
     // energy deposited in ECAL in 3*3 towers
     LogTrace(metname) << "Energy deposited in ECAL: "<<muEnergy.emS9;
     if (fabs(recoMu->eta()) > 1.479) 
       ecalS9DepEnergyEndcap->Fill(muEnergy.emS9);
     else
       ecalS9DepEnergyBarrel->Fill(muEnergy.emS9);
      
     // energy deposited in HCAL in 3*3 crystals
     LogTrace(metname) << "Energy deposited in HCAL: "<<muEnergy.hadS9;
     if (fabs(recoMu->eta()) > 1.4)
       hcalS9DepEnergyEndcap->Fill(muEnergy.hadS9);
     else
       hcalS9DepEnergyBarrel->Fill(muEnergy.hadS9);
   
     // energy deposited in HO in 3*3 crystals
     LogTrace(metname) << "Energy deposited in HO: "<<muEnergy.hoS9;
     if (fabs(recoMu->eta()) < 1.26)
       hoS9DepEnergy->Fill(muEnergy.hoS9);
   
     // plot for energy tests
     edm::ESHandle<TransientTrackBuilder> theB;
     iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder",theB);
     reco::TransientTrack TransTrack;
   
     if(recoMu->isGlobalMuon())
       TransTrack = theB->build(recoMu->globalTrack());
     if((recoMu->isTrackerMuon() || recoMu->isRPCMuon()) && !(recoMu->isGlobalMuon()))
       TransTrack = theB->build(recoMu->innerTrack());
     if(recoMu->isStandAloneMuon() && !(recoMu->isGlobalMuon()))
       TransTrack = theB->build(recoMu->outerTrack());
 
     TrajectoryStateOnSurface TSOS;
     TSOS = TransTrack.impactPointState();
     // section for vertex pointing muon
     if((abs(TSOS.globalPosition().z())<30) && (abs(TSOS.globalPosition().perp())<20)){
       // GLB muon
       if(recoMu->isGlobalMuon()){
     ecalS9PointingMuDepEnergy_Glb->Fill(muEnergy.emS9);
     hcalS9PointingMuDepEnergy_Glb->Fill(muEnergy.hadS9);
     hoS9PointingMuDepEnergy_Glb->Fill(muEnergy.hoS9);
       }
       // TK muon
       if(recoMu->isTrackerMuon() && !(recoMu->isGlobalMuon())){
     ecalS9PointingMuDepEnergy_Tk->Fill(muEnergy.emS9);
     hcalS9PointingMuDepEnergy_Tk->Fill(muEnergy.hadS9);
     hoS9PointingMuDepEnergy_Tk->Fill(muEnergy.hoS9);
       }
       // STA muon
       if(recoMu->isStandAloneMuon() && !(recoMu->isGlobalMuon())){
     ecalS9PointingMuDepEnergy_Sta->Fill(muEnergy.emS9);
     hcalS9PointingMuDepEnergy_Sta->Fill(muEnergy.hadS9);
     hoS9PointingMuDepEnergy_Sta->Fill(muEnergy.hoS9);
       } 
     }
   }
 
 }

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

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 60 of file MuonEnergyDepositAnalyzer.cc.

References HLT_25ns14e33_v1_cff::AlgoName, DQMStore::IBooker::book1D(), DQMStore::IBooker::cd(), MonitorElement::setAxisTitle(), DQMStore::IBooker::setCurrentFolder(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                    {
   ibooker.cd();
   ibooker.setCurrentFolder("Muons/MuonEnergyDepositAnalyzer");
 
   std::string histname = "ecalDepositedEnergyBarrel_";
   ecalDepEnergyBarrel = ibooker.book1D(histname+AlgoName, "Energy deposited in the ECAL barrel cells", emNoBin, emNoMin, emNoMax);
   ecalDepEnergyBarrel->setAxisTitle("GeV");
   
   histname = "ecalDepositedEnergyEndcap_";
   ecalDepEnergyEndcap = ibooker.book1D(histname+AlgoName, "Energy deposited in the ECAL endcap cells", emNoBin, emNoMin, emNoMax);
   ecalDepEnergyEndcap->setAxisTitle("GeV");
 
   histname = "ecalS9DepositedEnergyBarrel_";
   ecalS9DepEnergyBarrel = ibooker.book1D(histname+AlgoName, "Energy deposited in the ECAL barrel 3*3 towers", emS9NoBin, emS9NoMin, emS9NoMax);
   ecalS9DepEnergyBarrel->setAxisTitle("GeV");
   histname = "ecalS9DepositedEnergyEndcap_";
   ecalS9DepEnergyEndcap = ibooker.book1D(histname+AlgoName, "Energy deposited in the ECAL endcap 3*3 towers", emS9NoBin, emS9NoMin, emS9NoMax);
   ecalS9DepEnergyEndcap->setAxisTitle("GeV");
   histname = "ecalS9PointingMuDepositedEnergy_Glb_";
   ecalS9PointingMuDepEnergy_Glb = ibooker.book1D(histname+AlgoName, "Pointing glb muons energy deposited in the ECAL 3*3 towers", emS9NoBin, emS9NoMin, emS9NoMax);
   ecalS9PointingMuDepEnergy_Glb->setAxisTitle("GeV"); 
   histname = "ecalS9PointingMuDepositedEnergy_Tk_";
   ecalS9PointingMuDepEnergy_Tk = ibooker.book1D(histname+AlgoName, "Pointing tk muons energy deposited in the ECAL 3*3 towers", emS9NoBin, emS9NoMin, emS9NoMax);
   ecalS9PointingMuDepEnergy_Tk->setAxisTitle("GeV"); 
   histname = "ecalS9PointingMuDepositedEnergy_Sta_";
   ecalS9PointingMuDepEnergy_Sta = ibooker.book1D(histname+AlgoName, "Pointing sta muons energy deposited in the ECAL 3*3 towers", emS9NoBin, emS9NoMin, emS9NoMax);
   ecalS9PointingMuDepEnergy_Sta->setAxisTitle("GeV"); 
   
   histname = "hadDepositedEnergyBarrel_";
   hcalDepEnergyBarrel = ibooker.book1D(histname+AlgoName, "Energy deposited in the HCAL barrel cells", hadNoBin, hadNoMin, hadNoMax);
   hcalDepEnergyBarrel->setAxisTitle("GeV");
   histname = "hadDepositedEnergyEndcap_";
   hcalDepEnergyEndcap = ibooker.book1D(histname+AlgoName, "Energy deposited in the HCAL endcap cells", hadNoBin, hadNoMin, hadNoMax);
   hcalDepEnergyEndcap->setAxisTitle("GeV");
   
   histname = "hadS9DepositedEnergyBarrel_";
   hcalS9DepEnergyBarrel = ibooker.book1D(histname+AlgoName, "Energy deposited in the HCAL barrel 3*3 towers", hadS9NoBin, hadS9NoMin, hadS9NoMax);
   hcalS9DepEnergyBarrel->setAxisTitle("GeV");
   histname = "hadS9DepositedEnergyEndcap_";
   hcalS9DepEnergyEndcap = ibooker.book1D(histname+AlgoName, "Energy deposited in the HCAL endcap 3*3 towers", hadS9NoBin, hadS9NoMin, hadS9NoMax);
   hcalS9DepEnergyEndcap->setAxisTitle("GeV");
   histname = "hadS9PointingMuDepositedEnergy_Glb_";
   hcalS9PointingMuDepEnergy_Glb = ibooker.book1D(histname+AlgoName, "Pointing glb muons energy deposited in the HCAL endcap 3*3 towers", hadS9NoBin, hadS9NoMin, hadS9NoMax);
   hcalS9PointingMuDepEnergy_Glb->setAxisTitle("GeV");
   histname = "hadS9PointingMuDepositedEnergy_Tk_";
   hcalS9PointingMuDepEnergy_Tk = ibooker.book1D(histname+AlgoName, "Pointing tk muons energy deposited in the HCAL endcap 3*3 towers", hadS9NoBin, hadS9NoMin, hadS9NoMax);
   hcalS9PointingMuDepEnergy_Tk->setAxisTitle("GeV");
   histname = "hadS9PointingMuDepositedEnergy_Sta_";
   hcalS9PointingMuDepEnergy_Sta = ibooker.book1D(histname+AlgoName, "Pointing sta muons energy deposited in the HCAL endcap 3*3 towers", hadS9NoBin, hadS9NoMin, hadS9NoMax);
   hcalS9PointingMuDepEnergy_Sta->setAxisTitle("GeV");
 
   histname = "hoDepositedEnergy_";
   hoDepEnergy = ibooker.book1D(histname+AlgoName, "Energy deposited in the HO cells", hoNoBin, hoNoMin, hoNoMax);
   hoDepEnergy->setAxisTitle("GeV");
 
   histname = "hoS9DepositedEnergy_";
   hoS9DepEnergy = ibooker.book1D(histname+AlgoName, "Energy deposited in the HO 3*3 towers", hoS9NoBin, hoS9NoMin, hoS9NoMax);
   hoS9DepEnergy->setAxisTitle("GeV");
   histname = "hoS9PointingMuDepositedEnergy_Glb_";
   hoS9PointingMuDepEnergy_Glb = ibooker.book1D(histname+AlgoName, "Pointing glb muons energy deposited in the HO 3*3 towers", hoS9NoBin, hoS9NoMin, hoS9NoMax);
   hoS9PointingMuDepEnergy_Glb->setAxisTitle("GeV");
   histname = "hoS9PointingMuDepositedEnergy_Tk_";
   hoS9PointingMuDepEnergy_Tk = ibooker.book1D(histname+AlgoName, "Pointing tk muons energy deposited in the HO 3*3 towers", hoS9NoBin, hoS9NoMin, hoS9NoMax);
   hoS9PointingMuDepEnergy_Tk->setAxisTitle("GeV");
   histname = "hoS9PointingMuDepositedEnergy_Sta_";
   hoS9PointingMuDepEnergy_Sta = ibooker.book1D(histname+AlgoName, "Pointing sta muons energy deposited in the HO 3*3 towers", hoS9NoBin, hoS9NoMin, hoS9NoMax);
   hoS9PointingMuDepEnergy_Sta->setAxisTitle("GeV");
 }