Inheritance diagram for gamma_radiative_analyzer:

Public Member Functions
	gamma_radiative_analyzer (const edm::ParameterSet &pset)

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 &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

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::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	analyze (const edm::Event &event, const edm::EventSetup &setup) override

void	endJob () override

Private Attributes
double	dRTrk_

double	dRVeto_

bool	FSR_mu

bool	FSR_mu0

bool	FSR_mu1

bool	FSR_tk

TH2D *	h_gamma_pt_eta_

TH2D *	h_mu_pt_eta_FSR_

TH2D *	h_mu_pt_eta_no_FSR_

int	numOfEvent

int	numofGamma

double	ptThreshold_

int	zmmcounter

int	zmscounter

int	zmtcounter

EDGetTokenT< GenParticleMatch >	zMuMuMatchMapToken_

EDGetTokenT< CandidateView >	zMuMuToken_

EDGetTokenT< GenParticleMatch >	zMuSaMatchMapToken_

EDGetTokenT< CandidateView >	zMuSaToken_

EDGetTokenT< GenParticleMatch >	zMuTkMatchMapToken_

EDGetTokenT< CandidateView >	zMuTkToken_

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
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

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

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

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<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

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

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...

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

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

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

Detailed Description

Definition at line 52 of file gamma_radiative_analysis.cc.

Constructor & Destructor Documentation

◆ gamma_radiative_analyzer()

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

Definition at line 77 of file gamma_radiative_analysis.cc.

     : zMuMuToken_(consumes<CandidateView>(pset.getParameter<InputTag>("zMuMu"))),
       zMuMuMatchMapToken_(mayConsume<GenParticleMatch>(pset.getParameter<InputTag>("zMuMuMatchMap"))),
       zMuTkToken_(consumes<CandidateView>(pset.getParameter<InputTag>("zMuTk"))),
       zMuTkMatchMapToken_(mayConsume<GenParticleMatch>(pset.getParameter<InputTag>("zMuTkMatchMap"))),
       zMuSaToken_(consumes<CandidateView>(pset.getParameter<InputTag>("zMuSa"))),
       zMuSaMatchMapToken_(mayConsume<GenParticleMatch>(pset.getParameter<InputTag>("zMuSaMatchMap"))) {
   zmmcounter = 0;
   zmscounter = 0;
   zmtcounter = 0;
   numOfEvent = 0;
   numofGamma = 0;
   Service<TFileService> fs;
  
   // general histograms
   h_gamma_pt_eta_ = fs->make<TH2D>("h_gamma_pt_eta", "pt vs eta of gamma", 100, 20, 100, 100, -2.0, 2.0);
   h_mu_pt_eta_FSR_ = fs->make<TH2D>("h_mu_pt_eta_FSR", "pt vs eta of muon with FSR", 100, 20, 100, 100, -2.0, 2.0);
   h_mu_pt_eta_no_FSR_ =
       fs->make<TH2D>("h_mu_pt_eta_no_FSR", "pt vs eta of of muon withot FSR", 100, 20, 100, 100, -2.0, 2.0);
 }

References h_gamma_pt_eta_, h_mu_pt_eta_FSR_, h_mu_pt_eta_no_FSR_, TFileService::make(), numOfEvent, numofGamma, zmmcounter, zmscounter, and zmtcounter.

Member Function Documentation

◆ analyze()

void gamma_radiative_analyzer::analyze	(	const edm::Event &	event,
		const edm::EventSetup &	setup
	)

overrideprivatevirtual

Implements edm::EDAnalyzer.

Definition at line 98 of file gamma_radiative_analysis.cc.

                                                                                   {
   Handle<CandidateView> zMuMu;             //Collection of Z made by  Mu global + Mu global
   Handle<GenParticleMatch> zMuMuMatchMap;  //Map of Z made by Mu global + Mu global with MC
   event.getByToken(zMuMuToken_, zMuMu);
   Handle<CandidateView> zMuTk;  //Collection of Z made by  Mu global + Track
   Handle<GenParticleMatch> zMuTkMatchMap;
   event.getByToken(zMuTkToken_, zMuTk);
   Handle<CandidateView> zMuSa;  //Collection of Z made by  Mu global + Sa
   Handle<GenParticleMatch> zMuSaMatchMap;
   event.getByToken(zMuSaToken_, zMuSa);
   numOfEvent++;
   // ZMuMu
   if (!zMuMu->empty()) {
     event.getByToken(zMuMuMatchMapToken_, zMuMuMatchMap);
     for (unsigned int i = 0; i < zMuMu->size(); ++i) {  //loop on candidates
  
       const Candidate& zMuMuCand = (*zMuMu)[i];  //the candidate
       CandidateBaseRef zMuMuCandRef = zMuMu->refAt(i);
  
       CandidateBaseRef dau0 = zMuMuCand.daughter(0)->masterClone();
       CandidateBaseRef dau1 = zMuMuCand.daughter(1)->masterClone();
       const pat::Muon& mu0 = dynamic_cast<const pat::Muon&>(*dau0);  //cast in patMuon
       const pat::Muon& mu1 = dynamic_cast<const pat::Muon&>(*dau1);
  
       double zmass = zMuMuCand.mass();
       double pt0 = mu0.pt();
       double pt1 = mu1.pt();
       double eta0 = mu0.eta();
       double eta1 = mu1.eta();
       if (pt0 > 20 && pt1 > 20 && abs(eta0) < 2 && abs(eta1) < 2 && zmass > 20 && zmass < 200) {
         GenParticleRef zMuMuMatch = (*zMuMuMatchMap)[zMuMuCandRef];
         if (zMuMuMatch.isNonnull()) {  // ZMuMu matched
           zmmcounter++;
           FSR_mu0 = false;
           FSR_mu1 = false;
  
           //MonteCarlo Study
           const reco::GenParticle* muMc0 = mu0.genLepton();
           const reco::GenParticle* muMc1 = mu1.genLepton();
           const Candidate* motherMu0 = muMc0->mother();
           const Candidate* motherMu1 = muMc1->mother();
           int num_dau_muon0 = motherMu0->numberOfDaughters();
           int num_dau_muon1 = motherMu1->numberOfDaughters();
           if (num_dau_muon0 > 1) {
             for (int j = 0; j < num_dau_muon0; ++j) {
               int id = motherMu0->daughter(j)->pdgId();
               if (id == 22) {
                 double etaG = motherMu0->daughter(j)->eta();
                 double ptG = motherMu0->daughter(j)->pt();
                 h_gamma_pt_eta_->Fill(ptG, etaG);
                 h_mu_pt_eta_FSR_->Fill(pt0, eta0);
                 FSR_mu0 = true;
                 numofGamma++;
               }
             }
           }  //end check of gamma
           if (!FSR_mu0)
             h_mu_pt_eta_no_FSR_->Fill(pt0, eta0);
           if (num_dau_muon1 > 1) {
             for (int j = 0; j < num_dau_muon1; ++j) {
               int id = motherMu1->daughter(j)->pdgId();
               if (id == 22) {
                 double etaG = motherMu1->daughter(j)->eta();
                 double ptG = motherMu1->daughter(j)->pt();
                 h_gamma_pt_eta_->Fill(ptG, etaG);
                 h_mu_pt_eta_FSR_->Fill(pt1, eta1);
                 FSR_mu1 = true;
                 numofGamma++;
               }
             }
           }  //end check of gamma
           if (!FSR_mu1)
             h_mu_pt_eta_no_FSR_->Fill(pt1, eta1);
         }  // end MC match
       }    //end of cuts
     }      // end loop on ZMuMu cand
   }        // end if ZMuMu size > 0
  
   // ZMuSa
   if (!zMuSa->empty()) {
     event.getByToken(zMuSaMatchMapToken_, zMuSaMatchMap);
     for (unsigned int i = 0; i < zMuSa->size(); ++i) {  //loop on candidates
  
       const Candidate& zMuSaCand = (*zMuSa)[i];  //the candidate
       CandidateBaseRef zMuSaCandRef = zMuSa->refAt(i);
  
       CandidateBaseRef dau0 = zMuSaCand.daughter(0)->masterClone();
       CandidateBaseRef dau1 = zMuSaCand.daughter(1)->masterClone();
       const pat::Muon& mu0 = dynamic_cast<const pat::Muon&>(*dau0);  //cast in patMuon
       const pat::Muon& mu1 = dynamic_cast<const pat::Muon&>(*dau1);
  
       double zmass = zMuSaCand.mass();
       double pt0 = mu0.pt();
       double pt1 = mu1.pt();
       double eta0 = mu0.eta();
       double eta1 = mu1.eta();
       if (pt0 > 20 && pt1 > 20 && abs(eta0) < 2 && abs(eta1) < 2 && zmass > 20 && zmass < 200) {
         GenParticleRef zMuSaMatch = (*zMuSaMatchMap)[zMuSaCandRef];
         if (zMuSaMatch.isNonnull()) {  // ZMuSa matched
           FSR_mu0 = false;
           FSR_mu1 = false;
           zmscounter++;
           //MonteCarlo Study
           const reco::GenParticle* muMc0 = mu0.genLepton();
           const reco::GenParticle* muMc1 = mu1.genLepton();
           const Candidate* motherMu0 = muMc0->mother();
           const Candidate* motherMu1 = muMc1->mother();
           int num_dau_muon0 = motherMu0->numberOfDaughters();
           int num_dau_muon1 = motherMu1->numberOfDaughters();
           if (num_dau_muon0 > 1) {
             for (int j = 0; j < num_dau_muon0; ++j) {
               int id = motherMu0->daughter(j)->pdgId();
               if (id == 22) {
                 double etaG = motherMu0->daughter(j)->eta();
                 double ptG = motherMu0->daughter(j)->pt();
                 h_gamma_pt_eta_->Fill(ptG, etaG);
                 h_mu_pt_eta_FSR_->Fill(pt0, eta0);
                 numofGamma++;
                 FSR_mu0 = true;
               }
             }
           }  //end check of gamma
           if (!FSR_mu0)
             h_mu_pt_eta_no_FSR_->Fill(pt0, eta0);
           if (num_dau_muon1 > 1) {
             for (int j = 0; j < num_dau_muon1; ++j) {
               int id = motherMu1->daughter(j)->pdgId();
               if (id == 22) {
                 double etaG = motherMu1->daughter(j)->eta();
                 double ptG = motherMu1->daughter(j)->pt();
                 h_gamma_pt_eta_->Fill(ptG, etaG);
                 h_mu_pt_eta_FSR_->Fill(pt1, eta1);
                 numofGamma++;
                 FSR_mu1 = true;
               }
             }
           }  //end check of gamma
           if (!FSR_mu1)
             h_mu_pt_eta_no_FSR_->Fill(pt1, eta1);
         }  // end MC match
       }    //end of cuts
     }      // end loop on ZMuSa cand
   }        // end if ZMuSa size > 0
  
   //ZMuTk
   if (!zMuTk->empty()) {
     event.getByToken(zMuTkMatchMapToken_, zMuTkMatchMap);
     for (unsigned int i = 0; i < zMuTk->size(); ++i) {  //loop on candidates
       const Candidate& zMuTkCand = (*zMuTk)[i];         //the candidate
       CandidateBaseRef zMuTkCandRef = zMuTk->refAt(i);
  
       CandidateBaseRef dau0 = zMuTkCand.daughter(0)->masterClone();
       CandidateBaseRef dau1 = zMuTkCand.daughter(1)->masterClone();
       const pat::Muon& mu0 = dynamic_cast<const pat::Muon&>(*dau0);  //cast in patMuon
       const pat::GenericParticle& mu1 = dynamic_cast<const pat::GenericParticle&>(*dau1);
  
       double zmass = zMuTkCand.mass();
       double pt0 = mu0.pt();
       double pt1 = mu1.pt();
       double eta0 = mu0.eta();
       double eta1 = mu1.eta();
       if (pt0 > 20 && pt1 > 20 && abs(eta0) < 2 && abs(eta1) < 2 && zmass > 20 && zmass < 200) {  //kinematical cuts
         GenParticleRef zMuTkMatch = (*zMuTkMatchMap)[zMuTkCandRef];
         if (zMuTkMatch.isNonnull()) {  // ZMuTk matched
           FSR_mu = false;
           FSR_tk = false;
           zmtcounter++;
           //MonteCarlo Study
           const reco::GenParticle* muMc0 = mu0.genLepton();
           const reco::GenParticle* muMc1 = mu1.genParticle();
           const Candidate* motherMu0 = muMc0->mother();
           const Candidate* motherMu1 = muMc1->mother();
           int num_dau_muon0 = motherMu0->numberOfDaughters();
           int num_dau_muon1 = motherMu1->numberOfDaughters();
           if (num_dau_muon0 > 1) {
             for (int j = 0; j < num_dau_muon0; ++j) {
               int id = motherMu0->daughter(j)->pdgId();
               if (id == 22) {
                 double etaG = motherMu0->daughter(j)->eta();
                 double ptG = motherMu0->daughter(j)->pt();
                 h_gamma_pt_eta_->Fill(ptG, etaG);
                 h_mu_pt_eta_FSR_->Fill(pt0, eta0);
                 numofGamma++;
                 FSR_mu0 = true;
               }
             }
           }  //end check of gamma
           if (!FSR_mu0)
             h_mu_pt_eta_no_FSR_->Fill(pt0, eta0);
           if (num_dau_muon1 > 1) {
             for (int j = 0; j < num_dau_muon1; ++j) {
               int id = motherMu1->daughter(j)->pdgId();
               if (id == 22) {
                 double etaG = motherMu1->daughter(j)->eta();
                 double ptG = motherMu1->daughter(j)->pt();
                 h_gamma_pt_eta_->Fill(ptG, etaG);
                 h_mu_pt_eta_FSR_->Fill(pt1, eta1);
                 numofGamma++;
                 FSR_mu1 = true;
               }
             }
           }  //end check of gamma
           if (!FSR_mu1)
             h_mu_pt_eta_no_FSR_->Fill(pt1, eta1);
         }  // end MC match
       }    //end Kine-cuts
     }      // end loop on ZMuTk cand
   }        // end if ZMuTk size > 0
 }  // end analyze

References funct::abs(), reco::Candidate::daughter(), edm::View< T >::empty(), reco::Candidate::eta(), reco::LeafCandidate::eta(), HLT_FULL_cff::eta1, FSR_mu, FSR_mu0, FSR_mu1, FSR_tk, pat::Lepton< LeptonType >::genLepton(), pat::PATObject< ObjectType >::genParticle(), h_gamma_pt_eta_, h_mu_pt_eta_FSR_, h_mu_pt_eta_no_FSR_, mps_fire::i, edm::Ref< C, T, F >::isNonnull(), dqmiolumiharvest::j, reco::Candidate::mass(), reco::Candidate::masterClone(), reco::CompositeRefCandidateT< D >::mother(), reco::Candidate::numberOfDaughters(), numOfEvent, numofGamma, reco::Candidate::pdgId(), reco::Candidate::pt(), reco::LeafCandidate::pt(), HLT_FULL_cff::pt1, edm::View< T >::refAt(), edm::View< T >::size(), zmmcounter, zmscounter, zmtcounter, ZMuMuAnalysisNtupler_cff::zMuMu, zMuMuMatchMapToken_, zMuMuToken_, ZMuMuAnalysisNtupler_cff::zMuSa, zMuSaMatchMapToken_, zMuSaToken_, zMuTkMatchMapToken_, and zMuTkToken_.

◆ endJob()

void gamma_radiative_analyzer::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 308 of file gamma_radiative_analysis.cc.

                                       {
   cout << " ============= Summary ==========" << endl;
   cout << " Numero di eventi = " << numOfEvent << endl;
   cout << " 1)Numero di ZMuMu matched dopo i tagli cinematici = " << zmmcounter << endl;
   cout << " 2)Numero di ZMuSa matched dopo i tagli cinematici = " << zmscounter << endl;
   cout << " 3)Numero di ZMuTk matched dopo i tagli cinematici = " << zmtcounter << endl;
   cout << " 4)Number of gamma = " << numofGamma << endl;
 }