Inheritance diagram for ZMuMuIsolationAnalyzer:

Public Member Functions
	ZMuMuIsolationAnalyzer (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 const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (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 const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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 Types
enum	MuTag { muFromZ, muFromW, muFromOther }

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

void	Deposits (const pat::IsoDeposit isodep, double dR_max, TH1F hist)

void	endJob () override

void	histo (TH1F hist, const char cx, const char *cy) const

template<typename T >
MuTag	muTag (const T &mu) const

Private Attributes
double	alpha

double	beta

double	dREcal

double	dRHcal

double	dRTrk

double	dRVeto

TH1F *	EcalEt

TH1F *	EcalEtZ

double	eta

double	etEcalThreshold

double	etHcalThreshold

TH1F *	h_IsoOther_ecal

TH1F *	h_IsoOther_hcal

TH1F *	h_IsoOther_tk

TH1F *	h_IsoW_ecal

TH1F *	h_IsoW_hcal

TH1F *	h_IsoW_tk

TH1F *	h_IsoZ_ecal

TH1F *	h_IsoZ_hcal

TH1F *	h_IsoZ_tk

TH1F *	HcalEt

TH1F *	HcalEtZ

double	iso_cut

TH1F *	IsoOther

TH1F *	IsoW

TH1F *	IsoZ

TH1F *	Other_eta

TH1F *	Other_eta_postSelection

TH1F *	Other_pt

TH1F *	Other_pt_postSelection

double	pt

double	ptThreshold

EDGetTokenT< CandidateView >	srcToken

TH1F *	TkrPt

TH1F *	W_eta

TH1F *	W_eta_postSelection

TH1F *	W_pt

TH1F *	W_pt_postSelection

TH1F *	Z_eta

TH1F *	Z_eta_postSelection

TH1F *	Z_pt

TH1F *	Z_pt_postSelection

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

static bool	wantsStreamRuns ()

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

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

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 35 of file ZMuMuIsolationAnalyzer.cc.

Member Enumeration Documentation

enum ZMuMuIsolationAnalyzer::MuTag

private

Enumerator
muFromZ
muFromW
muFromOther

Definition at line 62 of file ZMuMuIsolationAnalyzer.cc.

62 { muFromZ, muFromW, muFromOther };

ZMuMuIsolationAnalyzer::muFromZ

Definition: ZMuMuIsolationAnalyzer.cc:62

ZMuMuIsolationAnalyzer::muFromOther

Definition: ZMuMuIsolationAnalyzer.cc:62

ZMuMuIsolationAnalyzer::muFromW

Definition: ZMuMuIsolationAnalyzer.cc:62

Constructor & Destructor Documentation

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

Definition at line 130 of file ZMuMuIsolationAnalyzer.cc.

References alpha, beta, dRTrk, EcalEt, EcalEtZ, eta, h_IsoOther_ecal, h_IsoOther_hcal, h_IsoOther_tk, h_IsoW_ecal, h_IsoW_hcal, h_IsoW_tk, h_IsoZ_ecal, h_IsoZ_hcal, h_IsoZ_tk, HcalEt, HcalEtZ, IsoOther, IsoW, IsoZ, TFileService::make(), Other_eta, Other_eta_postSelection, Other_pt, Other_pt_postSelection, pt, ptThreshold, TkrPt, W_eta, W_eta_postSelection, W_pt, W_pt_postSelection, Z_eta, Z_eta_postSelection, Z_pt, and Z_pt_postSelection.

     : srcToken(consumes<CandidateView>(pset.getParameter<InputTag>("src"))),
       dRVeto(pset.getUntrackedParameter<double>("veto")),
       dRTrk(pset.getUntrackedParameter<double>("deltaRTrk")),
       dREcal(pset.getUntrackedParameter<double>("deltaREcal")),
       dRHcal(pset.getUntrackedParameter<double>("deltaRHcal")),
       ptThreshold(pset.getUntrackedParameter<double>("ptThreshold")),
       etEcalThreshold(pset.getUntrackedParameter<double>("etEcalThreshold")),
       etHcalThreshold(pset.getUntrackedParameter<double>("etHcalThreshold")),
       alpha(pset.getUntrackedParameter<double>("alpha")),
       beta(pset.getUntrackedParameter<double>("beta")),
       pt(pset.getUntrackedParameter<double>("pt")),
       eta(pset.getUntrackedParameter<double>("eta")),
       iso_cut(pset.getUntrackedParameter<double>("isoCut")) {
   edm::Service<TFileService> fs;
   std::ostringstream str1, str2, str3, str4, str5, str6, str7, str8, str9, str10, n_tracks;
   str1 << "muons from Z with p_{t} > " << ptThreshold << " GeV/c"
        << " and #Delta R < " << dRTrk;
   str2 << "muons from W with p_{t} > " << ptThreshold << " GeV/c"
        << " and #Delta R < " << dRTrk;
   str3 << "muons from Others with p_{t} > " << ptThreshold << " GeV/c"
        << " and #Delta R < " << dRTrk;
   str4 << "muons from Z with p_{t} > " << ptThreshold << " GeV/c"
        << " and #Delta R < " << dRTrk << " (alpha = " << alpha << " , "
        << "beta = " << beta << " )";
   str5 << "muons from W with p_{t} > " << ptThreshold << " GeV/c"
        << " and #Delta R < " << dRTrk << " (alpha = " << alpha << " , "
        << "beta = " << beta << " )";
   str6 << "muons from Other with p_{t} > " << ptThreshold << " GeV/c"
        << " and #Delta R < " << dRTrk << " (alpha = " << alpha << " , "
        << "beta = " << beta << " )";
   n_tracks << "Number of tracks for muon with p_{t} > " << ptThreshold << " and #Delta R < " << dRTrk << " GeV/c";
   str7 << "Isolation Vs p_{t} with p_{t} > " << ptThreshold << " GeV/c"
        << " and #Delta R < " << dRTrk << "(Tracker)";
   str8 << "Isolation Vs p_{t} with p_{t} > " << ptThreshold << " GeV/c"
        << " and #Delta R < " << dRTrk << "(Ecal)";
   str9 << "Isolation Vs p_{t} with p_{t} > " << ptThreshold << " GeV/c"
        << " and #Delta R < " << dRTrk << "(Hcal)";
   str10 << "Isolation Vs p_{t} with p_{t} > " << ptThreshold << " GeV/c"
         << " and #Delta R < " << dRTrk << " (alpha = " << alpha << " , "
         << "beta = " << beta << " )";
   h_IsoZ_tk = fs->make<TH1F>("ZIso_Tk", str1.str().c_str(), 100, 0., 20.);
   h_IsoW_tk = fs->make<TH1F>("WIso_Tk", str2.str().c_str(), 100, 0., 20.);
   h_IsoOther_tk = fs->make<TH1F>("otherIso_Tk", str3.str().c_str(), 100, 0., 20.);
   h_IsoZ_ecal = fs->make<TH1F>("ZIso_ecal", str1.str().c_str(), 100, 0., 20.);
   h_IsoW_ecal = fs->make<TH1F>("WIso_ecal", str2.str().c_str(), 100, 0., 20.);
   h_IsoOther_ecal = fs->make<TH1F>("otherIso_ecal", str3.str().c_str(), 100, 0., 20.);
   h_IsoZ_hcal = fs->make<TH1F>("ZIso_hcal", str1.str().c_str(), 100, 0., 20.);
   h_IsoW_hcal = fs->make<TH1F>("WIso_hcal", str2.str().c_str(), 100, 0., 20.);
   h_IsoOther_hcal = fs->make<TH1F>("otherIso_hcal", str3.str().c_str(), 100, 0., 20.);
   IsoZ = fs->make<TH1F>("ZIso", str4.str().c_str(), 100, 0., 20.);
   IsoW = fs->make<TH1F>("WIso", str5.str().c_str(), 100, 0., 20.);
   IsoOther = fs->make<TH1F>("otherIso", str6.str().c_str(), 100, 0., 20.);
 
   Z_eta = fs->make<TH1F>("Z_eta", "#eta distribution for muons coming from Z", 40, -eta, eta);
   W_eta = fs->make<TH1F>("W_eta", "#eta distribution for muons coming from W", 40, -eta, eta);
   Other_eta = fs->make<TH1F>("Other_eta", "#eta distribution for muons coming from other", 40, -eta, eta);
   Z_eta_postSelection = fs->make<TH1F>(
       "Z_eta_postSelection", "#eta distribution for muons coming from Z after iso selection", 40, -eta, eta);
   W_eta_postSelection = fs->make<TH1F>(
       "W_eta_postSelection", "#eta distribution for muons coming from W after iso selection", 40, -eta, eta);
   Other_eta_postSelection = fs->make<TH1F>(
       "Other_eta_postSelection", "#eta distribution for muons coming from other after iso selection", 40, -eta, eta);
 
   Z_pt = fs->make<TH1F>("Z_pt", "p_{T} distribution for muons coming from Z", 40, pt, 150.);
   W_pt = fs->make<TH1F>("W_pt", "p_{T} distribution for muons coming from W", 40, pt, 150.);
   Other_pt = fs->make<TH1F>("Other_pt", "p_{T} distribution for muons coming from other", 40, pt, 150.);
   Z_pt_postSelection = fs->make<TH1F>(
       "Z_pt_postSelection", "p_{T} distribution for muons coming from Z after iso selection", 40, pt, 150.);
   W_pt_postSelection = fs->make<TH1F>(
       "W_pt_postSelection", "p_{t} distribution for muons coming from W after iso selection", 40, pt, 150.);
   Other_pt_postSelection = fs->make<TH1F>(
       "Other_pt_postSelection", "p_{t} distribution for muons coming from other after iso selection", 40, pt, 150.);
 
   TkrPt = fs->make<TH1F>("TkrPt", "IsoDeposit p distribution in the Tracker", 100, 0., 10.);
   EcalEt = fs->make<TH1F>("EcalEt", "IsoDeposit E distribution in the Ecal", 100, 0., 5.);
   HcalEt = fs->make<TH1F>("HcalEt", "IsoDeposit E distribution in the Hcal", 100, 0., 5.);
 
   EcalEtZ = fs->make<TH1F>("VetoEcalEt", " #Sigma E_{T} deposited in veto cone in the Ecal", 100, 0., 10.);
   HcalEtZ = fs->make<TH1F>("VetoHcalEt", " #Sigma E_{T} deposited in veto cone in the Hcal", 100, 0., 10.);
 }

Member Function Documentation

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

overrideprivate

Definition at line 212 of file ZMuMuIsolationAnalyzer.cc.

References funct::abs(), alpha, beta, reco::IsoDeposit::candEnergy(), reco::Candidate::daughter(), Deposits(), WZMuSkim_cff::dimuons, dREcal, dRHcal, dRTrk, dRVeto, EcalEt, EcalEtZ, pat::EcalIso, eta, reco::LeafCandidate::eta(), etEcalThreshold, etHcalThreshold, h_IsoOther_ecal, h_IsoOther_hcal, h_IsoOther_tk, h_IsoW_ecal, h_IsoW_hcal, h_IsoW_tk, h_IsoZ_ecal, h_IsoZ_hcal, h_IsoZ_tk, HcalEt, HcalEtZ, pat::HcalIso, histo(), mps_fire::i, iso_cut, pat::Lepton< LeptonType >::isoDeposit(), pat::GenericParticle::isoDeposit(), IsoOther, IsoW, IsoZ, reco::Candidate::masterClone(), Max(), muFromW, muFromZ, muTag(), Other_eta, Other_eta_postSelection, Other_pt, Other_pt_postSelection, reco::LeafCandidate::phi(), pt, reco::LeafCandidate::pt(), ptThreshold, edm::View< T >::size(), srcToken, reco::IsoDeposit::sumWithin(), TkrPt, pat::TrackIso, W_eta, W_eta_postSelection, W_pt, W_pt_postSelection, Z_eta, Z_eta_postSelection, Z_pt, and Z_pt_postSelection.

                                                                                       {
   Handle<CandidateView> dimuons;
   event.getByToken(srcToken, dimuons);
 
   for (unsigned int i = 0; i < dimuons->size(); ++i) {
     const Candidate& zmm = (*dimuons)[i];
     const Candidate* dau0 = zmm.daughter(0);
     const Candidate* dau1 = zmm.daughter(1);
     const pat::Muon& mu0 = dynamic_cast<const pat::Muon&>(*dau0->masterClone());
     const pat::GenericParticle& mu1 = dynamic_cast<const pat::GenericParticle&>(*dau1->masterClone());
 
     const pat::IsoDeposit* muTrackIso = mu0.isoDeposit(pat::TrackIso);
     const pat::IsoDeposit* tkTrackIso = mu1.isoDeposit(pat::TrackIso);
     const pat::IsoDeposit* muEcalIso = mu0.isoDeposit(pat::EcalIso);
     const pat::IsoDeposit* tkEcalIso = mu1.isoDeposit(pat::EcalIso);
     const pat::IsoDeposit* muHcalIso = mu0.isoDeposit(pat::HcalIso);
     const pat::IsoDeposit* tkHcalIso = mu1.isoDeposit(pat::HcalIso);
 
     if (mu0.pt() > pt && mu1.pt() > pt && abs(mu0.eta()) < eta && abs(mu1.eta()) < eta) {
       Direction muDir = Direction(mu0.eta(), mu0.phi());
       Direction tkDir = Direction(mu1.eta(), mu1.phi());
 
       IsoDeposit::AbsVetos vetos_mu;
       vetos_mu.push_back(new ConeVeto(muDir, dRVeto));
       vetos_mu.push_back(new ThresholdVeto(ptThreshold));
 
       reco::IsoDeposit::AbsVetos vetos_tk;
       vetos_tk.push_back(new ConeVeto(tkDir, dRVeto));
       vetos_tk.push_back(new ThresholdVeto(ptThreshold));
 
       reco::IsoDeposit::AbsVetos vetos_mu_ecal;
       vetos_mu_ecal.push_back(new ConeVeto(muDir, 0.));
       vetos_mu_ecal.push_back(new ThresholdVeto(etEcalThreshold));
 
       reco::IsoDeposit::AbsVetos vetos_tk_ecal;
       vetos_tk_ecal.push_back(new ConeVeto(tkDir, 0.));
       vetos_tk_ecal.push_back(new ThresholdVeto(etEcalThreshold));
 
       reco::IsoDeposit::AbsVetos vetos_mu_hcal;
       vetos_mu_hcal.push_back(new ConeVeto(muDir, 0.));
       vetos_mu_hcal.push_back(new ThresholdVeto(etHcalThreshold));
 
       reco::IsoDeposit::AbsVetos vetos_tk_hcal;
       vetos_tk_hcal.push_back(new ConeVeto(tkDir, 0.));
       vetos_tk_hcal.push_back(new ThresholdVeto(etHcalThreshold));
       MuTag tag_mu = muTag(mu0);
       MuTag tag_track = muTag(mu1);
 
       double Tk_isovalue = TMath::Max(muTrackIso->sumWithin(dRTrk, vetos_mu), tkTrackIso->sumWithin(dRTrk, vetos_tk));
       double Ecal_isovalue =
           TMath::Max(muEcalIso->sumWithin(dREcal, vetos_mu_ecal), tkEcalIso->sumWithin(dREcal, vetos_tk_ecal));
       double Hcal_isovalue =
           TMath::Max(muHcalIso->sumWithin(dRHcal, vetos_mu_hcal), tkHcalIso->sumWithin(dRHcal, vetos_tk_hcal));
       EcalEtZ->Fill(muEcalIso->candEnergy());
       EcalEtZ->Fill(tkEcalIso->candEnergy());
       HcalEtZ->Fill(muHcalIso->candEnergy());
       HcalEtZ->Fill(tkHcalIso->candEnergy());
 
       double iso_value0 = alpha * ((0.5 * (1 + beta) * muEcalIso->sumWithin(dREcal, vetos_mu_ecal)) +
                                    (0.5 * (1 - beta) * muHcalIso->sumWithin(dRHcal, vetos_mu_hcal))) +
                           (1 - alpha) * muTrackIso->sumWithin(dRTrk, vetos_mu);
       double iso_value1 = alpha * ((0.5 * (1 + beta) * tkEcalIso->sumWithin(dREcal, vetos_tk_ecal)) +
                                    (0.5 * (1 - beta) * tkHcalIso->sumWithin(dRHcal, vetos_tk_hcal))) +
                           (1 - alpha) * tkTrackIso->sumWithin(dRTrk, vetos_tk);
 
       double iso_value = TMath::Max(iso_value0, iso_value1);
 
       if (tag_mu == muFromZ && tag_track == muFromZ) {
         h_IsoZ_tk->Fill(Tk_isovalue);
         h_IsoZ_ecal->Fill(Ecal_isovalue);
         h_IsoZ_hcal->Fill(Hcal_isovalue);
         IsoZ->Fill(iso_value);
 
         Z_eta->Fill(mu0.eta());
         Z_eta->Fill(mu1.eta());
         Z_pt->Fill(mu0.pt());
         Z_pt->Fill(mu1.pt());
 
         if (iso_value0 < iso_cut) {
           Z_pt_postSelection->Fill(mu0.pt());
           Z_eta_postSelection->Fill(mu0.eta());
         }
         if (iso_value1 < iso_cut) {
           Z_pt_postSelection->Fill(mu1.pt());
           Z_eta_postSelection->Fill(mu1.eta());
         }
 
         Deposits(muTrackIso, dRTrk, TkrPt);
         Deposits(muEcalIso, dREcal, EcalEt);
         Deposits(muHcalIso, dRHcal, HcalEt);
         Deposits(tkTrackIso, dRTrk, TkrPt);
         Deposits(tkEcalIso, dREcal, EcalEt);
         Deposits(tkHcalIso, dRHcal, HcalEt);
       }
       if (tag_mu == muFromW || tag_track == muFromW) {
         h_IsoW_tk->Fill(Tk_isovalue);
         h_IsoW_ecal->Fill(Ecal_isovalue);
         h_IsoW_hcal->Fill(Hcal_isovalue);
         IsoW->Fill(iso_value);
 
         W_eta->Fill(mu0.eta());
         W_eta->Fill(mu1.eta());
         W_pt->Fill(mu0.pt());
         W_pt->Fill(mu1.pt());
 
         if (iso_value0 < iso_cut) {
           W_pt_postSelection->Fill(mu0.pt());
           W_eta_postSelection->Fill(mu0.eta());
         }
         if (iso_value1 < iso_cut) {
           W_pt_postSelection->Fill(mu1.pt());
           W_eta_postSelection->Fill(mu1.eta());
         }
 
         Deposits(muTrackIso, dRTrk, TkrPt);
         Deposits(muEcalIso, dREcal, EcalEt);
         Deposits(muHcalIso, dRHcal, HcalEt);
         Deposits(tkTrackIso, dRTrk, TkrPt);
         Deposits(tkEcalIso, dREcal, EcalEt);
         Deposits(tkHcalIso, dRHcal, HcalEt);
       } else {
         h_IsoOther_tk->Fill(Tk_isovalue);
         h_IsoOther_ecal->Fill(Ecal_isovalue);
         h_IsoOther_hcal->Fill(Hcal_isovalue);
         IsoOther->Fill(iso_value);
 
         Other_eta->Fill(mu0.eta());
         Other_eta->Fill(mu1.eta());
         Other_pt->Fill(mu0.pt());
         Other_pt->Fill(mu1.pt());
 
         if (iso_value0 < iso_cut) {
           Other_pt_postSelection->Fill(mu0.pt());
           Other_eta_postSelection->Fill(mu0.eta());
         }
         if (iso_value1 < iso_cut) {
           Other_pt_postSelection->Fill(mu1.pt());
           Other_eta_postSelection->Fill(mu1.eta());
         }
 
         Deposits(muTrackIso, dRTrk, TkrPt);
         Deposits(muEcalIso, dREcal, EcalEt);
         Deposits(muHcalIso, dRHcal, HcalEt);
         Deposits(tkTrackIso, dRTrk, TkrPt);
         Deposits(tkEcalIso, dREcal, EcalEt);
         Deposits(tkHcalIso, dRHcal, HcalEt);
       }
     }
   }
 
   histo(h_IsoZ_tk, "#Sigma p_{T}", "Events");
   histo(h_IsoW_tk, "#Sigma p_{T}", "Events");
   histo(h_IsoOther_tk, "#Sigma p_{T}", "#Events");
   histo(h_IsoZ_ecal, "#Sigma E_{t}", "Events");
   histo(h_IsoW_ecal, "#Sigma E_{t}", "Events");
   histo(h_IsoOther_ecal, "#Sigma E_{t}", "Events");
   histo(h_IsoZ_hcal, "#Sigma E_{t}", "Events");
   histo(h_IsoW_hcal, "#Sigma E_{t}", "Events");
   histo(h_IsoOther_hcal, "#Sigma E_{t}", "Events");
   histo(TkrPt, "p ", "");
   histo(EcalEt, "E ", "");
   histo(HcalEt, "E ", "");
   histo(HcalEtZ, "E_{T}", "");
   histo(EcalEtZ, "E_{T}", "");
 }

void ZMuMuIsolationAnalyzer::Deposits	(	const pat::IsoDeposit *	isodep,
		double	dR_max,
		TH1F *	hist
	)

private

Definition at line 109 of file ZMuMuIsolationAnalyzer.cc.

References reco::IsoDeposit::begin(), reco::IsoDeposit::end(), and theta().

Referenced by analyze().

                                                                                             {
   for (IsoDeposit::const_iterator it = isodep->begin(); it != isodep->end(); ++it) {
     if (it->dR() < dR_max) {
       double theta = 2 * (TMath::ATan(TMath::Exp(-(it->eta()))));
       // double theta= 2;
       hist->Fill(it->value() / TMath::Sin(theta));
     }
   }
 }

void ZMuMuIsolationAnalyzer::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 378 of file ZMuMuIsolationAnalyzer.cc.

References DEFINE_FWK_MODULE.

378 {}

void ZMuMuIsolationAnalyzer::histo	(	TH1F *	hist,
		const char *	cx,
		const char *	cy
	)		const

private

Definition at line 119 of file ZMuMuIsolationAnalyzer.cc.

Referenced by analyze().

                                                                                    {
   hist->GetXaxis()->SetTitle(cx);
   hist->GetYaxis()->SetTitle(cy);
   hist->GetXaxis()->SetTitleOffset(1);
   hist->GetYaxis()->SetTitleOffset(1.2);
   hist->GetXaxis()->SetTitleSize(0.04);
   hist->GetYaxis()->SetTitleSize(0.04);
   hist->GetXaxis()->SetLabelSize(0.03);
   hist->GetYaxis()->SetLabelSize(0.03);
 }

template<typename T >

ZMuMuIsolationAnalyzer::MuTag ZMuMuIsolationAnalyzer::muTag ( const T & mu ) const

private

Definition at line 70 of file ZMuMuIsolationAnalyzer.cc.

References funct::abs(), edm::Ref< C, T, F >::isNull(), reco::Candidate::mother(), AlCaHLTBitMon_ParallelJobs::p, and reco::Candidate::pdgId().

Referenced by analyze().

                                                                            {
   GenParticleRef p = mu.genParticleRef();
   if (p.isNull()) {
     //   cout<<"genParticleRef is null "<<endl;
     return muFromOther;
   }
   int sizem = p->numberOfMothers();
   if (sizem != 1) {
     //cout<<"number of mothers !=1 "<<endl;
     return muFromOther;
   }
   const Candidate* moth1 = p->mother();
   if (moth1 == nullptr) {
     return muFromOther;
     //cout<<"no mother "<<endl;
   }
   int pdgId1 = moth1->pdgId();
   if (abs(pdgId1) != 13) {
     return muFromOther;
     //cout<<"mother is not a muon"<<endl;
   }
   const Candidate* moth2 = moth1->mother();
   if (moth2 == nullptr) {
     return muFromOther;
     //cout<<"no mother "<<endl;
   }
   int pdgId2 = moth2->pdgId();
   if (pdgId2 == 23) {
     //cout<<" muon from Z"<<endl;
     return muFromZ;
   }
   if (abs(pdgId2) == 24)
     return muFromW;
   else {
     //cout<<" muon from other"<<endl;
     return muFromOther;
   }
 }