Inheritance diagram for ExampleMuonAnalyzer:

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

void	beginJob () override

void	endJob () override

	ExampleMuonAnalyzer (const edm::ParameterSet &pset)
	Constructor. More...

	~ExampleMuonAnalyzer () override
	Destructor. More...

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

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

	~EDAnalyzer () override

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

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 &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const * > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, 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	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Attributes
TH1F *	h4MuInvMass

TH1I *	hChamberMatched

TH1F *	hEHcal

TH1F *	hMuCaloCompatibility

TH1I *	hMuIdAlgo

TH1F *	hMuIso03CaloComb

TH1F *	hMuIso03SumPt

TH1I *	hMuonType

TH1F *	hMuSegCompatibility

TH1I *	hNMuons

TH1F *	hPtRec

TH2F *	hPtReso

TH1F *	hPtSTATKDiff

edm::EDGetTokenT < pat::MuonCollection >	theMuonToken

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsInputProcessBlocks ()

static bool	wantsProcessBlocks ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

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

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Analyzer of the muon objects

Author: R. Bellan - CERN ricca.nosp@m.rdo..nosp@m.bella.nosp@m.n@ce.nosp@m.rn.ch

Definition at line 21 of file MuonAnalyzer.cc.

Constructor & Destructor Documentation

ExampleMuonAnalyzer::ExampleMuonAnalyzer ( const edm::ParameterSet & pset )

Constructor.

Definition at line 66 of file MuonAnalyzer.cc.

References edm::ParameterSet::getParameter().

                                                                  {
   theMuonToken = consumes<pat::MuonCollection>(pset.getParameter<InputTag>("MuonCollection"));
 }

ExampleMuonAnalyzer::~ExampleMuonAnalyzer ( )

override

Destructor.

Definition at line 71 of file MuonAnalyzer.cc.

71 {}

Member Function Documentation

void ExampleMuonAnalyzer::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	eventSetup
	)

overridevirtual

simple selection... Do not want to write here my super-secret Higgs analysis ;-)

Implements edm::EDAnalyzer.

Definition at line 101 of file MuonAnalyzer.cc.

References muon::All, muon::AllArbitrated, muon::AllStandAloneMuons, muon::AllTrackerMuons, change_name::diff, muon::GlobalMuonPromptTight, muon::isGoodMuon(), HLT_FULL_cff::muon, patZpeak::muons, muon::segmentCompatibility(), WZElectronSkims53X_cff::selectedMuons, muon::TM2DCompatibilityLoose, muon::TM2DCompatibilityTight, muon::TMLastStationLoose, muon::TMLastStationOptimizedLowPtLoose, muon::TMLastStationOptimizedLowPtTight, muon::TMLastStationTight, muon::TMOneStationLoose, muon::TMOneStationTight, and muon::TrackerMuonArbitrated.

                                                                                   {
   // Get the Muon collection
   Handle<pat::MuonCollection> muons;
   event.getByToken(theMuonToken, muons);
 
   // How many muons in the event?
   hNMuons->Fill(muons->size());
 
   pat::MuonCollection selectedMuons;
 
   // Let's look inside the muon collection.
   for (pat::MuonCollection::const_iterator muon = muons->begin(); muon != muons->end(); ++muon) {
     // pT spectra of muons
     hPtRec->Fill(muon->pt());
 
     // what is the resolution in pt? Easy! We have the association with generated information
     //    cout<<muon->pt()<<" "<<muon->genParticle()->pt()<<endl;
     if (muon->genLepton() != nullptr) {
       double reso = (muon->pt() - muon->genLepton()->pt()) / muon->genLepton()->pt();
       hPtReso->Fill(muon->genLepton()->pt(), reso);
     }
 
     // What is the energy deposit in HCal?
     if (muon->isEnergyValid())
       hEHcal->Fill(muon->calEnergy().had);
 
     // Which type of muons in the collection?
     if (muon->isStandAloneMuon())
       if (muon->isGlobalMuon())
         if (muon->isTrackerMuon())
           hMuonType->Fill(1);  // STA + GLB + TM
         else
           hMuonType->Fill(2);  // STA + GLB
       else if (muon->isTrackerMuon())
         hMuonType->Fill(3);  // STA + TM
       else
         hMuonType->Fill(5);  // STA
     else if (muon->isTrackerMuon())
       hMuonType->Fill(4);  // TM
 
     // ...mmm I want to study the relative resolution of the STA track with respect to the Tracker track.
     // or I want to look at a track stab
     if (muon->isGlobalMuon()) {
       double diff = muon->innerTrack()->pt() - muon->standAloneMuon()->pt();
       hPtSTATKDiff->Fill(diff);
     }
 
     // Muon ID quantities
 
     // Muon in CMS are usually MIP. What is the compatibility of a muon HP using only claorimeters?
     if (muon->isCaloCompatibilityValid())
       hMuCaloCompatibility->Fill(muon->caloCompatibility());
 
     // The muon system can also be used just as only for ID. What is the compatibility of a muon HP using only calorimeters?
     hMuSegCompatibility->Fill(muon::segmentCompatibility(*muon));
 
     // How many chambers have been associated to a muon track?
     hChamberMatched->Fill(muon->numberOfChambers());
     // If you look at MuonSegmentMatcher class you will see a lot of interesting quantities to look at!
     // you can get the list of matched info using matches()
 
     // Muon ID selection. As described in AN-2008/098
     if (muon::isGoodMuon(*muon, muon::All))  // dummy options - always true
       hMuIdAlgo->Fill(0);
     if (muon::isGoodMuon(*muon, muon::AllStandAloneMuons))  // checks isStandAloneMuon flag
       hMuIdAlgo->Fill(1);
     if (muon::isGoodMuon(*muon, muon::AllTrackerMuons))  // checks isTrackerMuon flag
       hMuIdAlgo->Fill(2);
     if (muon::isGoodMuon(*muon, muon::TrackerMuonArbitrated))  // resolve ambiguity of sharing segments
       hMuIdAlgo->Fill(3);
     if (muon::isGoodMuon(*muon, muon::AllArbitrated))  // all muons with the tracker muon arbitrated
       hMuIdAlgo->Fill(4);
     if (muon::isGoodMuon(*muon, muon::GlobalMuonPromptTight))  // global muons with tighter fit requirements
       hMuIdAlgo->Fill(5);
     if (muon::isGoodMuon(*muon, muon::TMLastStationLoose))  // penetration depth loose selector
       hMuIdAlgo->Fill(6);
     if (muon::isGoodMuon(*muon, muon::TMLastStationTight))  // penetration depth tight selector
       hMuIdAlgo->Fill(7);
     if (muon::isGoodMuon(*muon, muon::TM2DCompatibilityLoose))  // likelihood based loose selector
       hMuIdAlgo->Fill(8);
     if (muon::isGoodMuon(*muon, muon::TM2DCompatibilityTight))  // likelihood based tight selector
       hMuIdAlgo->Fill(9);
     if (muon::isGoodMuon(*muon, muon::TMOneStationLoose))  // require one well matched segment
       hMuIdAlgo->Fill(10);
     if (muon::isGoodMuon(*muon, muon::TMOneStationTight))  // require one well matched segment
       hMuIdAlgo->Fill(11);
     if (muon::isGoodMuon(*muon,
                          muon::TMLastStationOptimizedLowPtLoose))  // combination of TMLastStation and TMOneStation
       hMuIdAlgo->Fill(12);
     if (muon::isGoodMuon(*muon,
                          muon::TMLastStationOptimizedLowPtTight))  // combination of TMLastStation and TMOneStation
       hMuIdAlgo->Fill(13);
 
     // Isolation variables. There are many type of isolation. You can even build your own combining the output of
     // muon->isolationR03(). E.g.: 1.2*muon->isolationR03().emEt + 0.8*muon->isolationR03().hadEt
     // *** WARNING *** it is just an EXAMPLE!
     if (muon->isIsolationValid()) {
       hMuIso03CaloComb->Fill(1.2 * muon->isolationR03().emEt + 0.8 * muon->isolationR03().hadEt);
       hMuIso03SumPt->Fill(muon->isolationR03().sumPt);
     }
 
     // OK, let see if we understood everything.
     // Suppose we are searching for H->ZZ->4mu.
     // In mean the 4 muons have/are:
     // high pt (but 1 out of 4 can be at quite low pt)
     // isolated
     // so, we can make some requirements
     if (muon->isolationR03().sumPt < 0.2) {
       if (muon->isGlobalMuon() || muon::isGoodMuon(*muon, muon::TM2DCompatibilityLoose) ||
           muon::isGoodMuon(*muon, muon::TMLastStationLoose))
         selectedMuons.push_back(*muon);
     }
   }
 
   if (selectedMuons.size() == 4) {
     reco::Candidate::LorentzVector p4CM;
     for (pat::MuonCollection::const_iterator muon = selectedMuons.begin(); muon != selectedMuons.end(); ++muon) {
       p4CM = p4CM + muon->p4();
     }
     h4MuInvMass->Fill(p4CM.mass());
   }
 }

void ExampleMuonAnalyzer::beginJob ( void )

overridevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 73 of file MuonAnalyzer.cc.

References TFileService::make().

                                    {
   // Book histograms
   edm::Service<TFileService> fileService;
   hPtRec = fileService->make<TH1F>("pT", "p_{T}^{rec}", 250, 0, 120);
   hPtReso = fileService->make<TH2F>("pT_Reso", "(p_{T}^{rec}-p_{T}^{sim})/p_{T}^{sim}", 250, 0, 120, 100, -0.2, 0.2);
   hNMuons = fileService->make<TH1I>("NMuons", "Number of muons per event", 20, 0, 20);
 
   hEHcal = fileService->make<TH1F>("EHCal", "Energy deposit in HCAL", 100, 0, 10);
 
   // ID
   hMuonType = fileService->make<TH1I>("MuonType", "Type of Muons", 5, 1, 6);
   hPtSTATKDiff = fileService->make<TH1F>("DiffPt_STA_TK", "p^{TK}_{T}-p^{STA}_T", 200, -50, 50);
   hMuCaloCompatibility = fileService->make<TH1F>("CaloCompatibility", "Muon HP using Calorimeters only", 100, 0, 1);
   hMuSegCompatibility = fileService->make<TH1F>("SegmentCompatibility", "Muon HP using segments only", 100, 0, 1);
   hChamberMatched = fileService->make<TH1I>("NumMatchedChamber", "Number of matched chambers", 7, 0, 7);
   hMuIdAlgo = fileService->make<TH1I>("MuonIDSelectors", "Results of muon id selectors", 13, 0, 13);
 
   // Isolation
   hMuIso03SumPt = fileService->make<TH1F>("MuIso03SumPt", "Isolation #Delta(R)=0.3: SumPt", 200, 0, 10);
   hMuIso03CaloComb =
       fileService->make<TH1F>("MuIso03CaloComb", "Isolation #Delta(R)=0.3: 1.2*ECAL+0.8HCAL", 200, 0, 10);
 
   // 4Mu invariant mass
   h4MuInvMass = fileService->make<TH1F>("InvMass4MuSystem", "Invariant mass of the 4 muons system", 200, 0, 500);
 }

void ExampleMuonAnalyzer::endJob ( void )

overridevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 99 of file MuonAnalyzer.cc.

99 {}

Member Data Documentation

TH1F* ExampleMuonAnalyzer::h4MuInvMass

private

Definition at line 59 of file MuonAnalyzer.cc.

TH1I* ExampleMuonAnalyzer::hChamberMatched

private

Definition at line 52 of file MuonAnalyzer.cc.

TH1F* ExampleMuonAnalyzer::hEHcal

private

Definition at line 44 of file MuonAnalyzer.cc.

TH1F* ExampleMuonAnalyzer::hMuCaloCompatibility

private

Definition at line 50 of file MuonAnalyzer.cc.

TH1I* ExampleMuonAnalyzer::hMuIdAlgo

private

Definition at line 53 of file MuonAnalyzer.cc.

TH1F* ExampleMuonAnalyzer::hMuIso03CaloComb

private

Definition at line 57 of file MuonAnalyzer.cc.

TH1F* ExampleMuonAnalyzer::hMuIso03SumPt

private

Definition at line 56 of file MuonAnalyzer.cc.

TH1I* ExampleMuonAnalyzer::hMuonType

private

Definition at line 46 of file MuonAnalyzer.cc.

TH1F* ExampleMuonAnalyzer::hMuSegCompatibility

private

Definition at line 51 of file MuonAnalyzer.cc.

TH1I* ExampleMuonAnalyzer::hNMuons

private

Definition at line 41 of file MuonAnalyzer.cc.

TH1F* ExampleMuonAnalyzer::hPtRec

private

Definition at line 42 of file MuonAnalyzer.cc.

TH2F* ExampleMuonAnalyzer::hPtReso

private

Definition at line 43 of file MuonAnalyzer.cc.

TH1F* ExampleMuonAnalyzer::hPtSTATKDiff

private

Definition at line 47 of file MuonAnalyzer.cc.

edm::EDGetTokenT<pat::MuonCollection> ExampleMuonAnalyzer::theMuonToken

private

Definition at line 38 of file MuonAnalyzer.cc.

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation