Inheritance diagram for ZMuPtScaleAnalyzer:

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

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

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

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

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

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

virtual	~EDConsumerBase () noexcept(false)

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

virtual void	endJob () override

Private Attributes
double	accEtaMax_

double	accEtaMin_

double	accMassMax_

double	accMassMaxDen_

double	accMassMin_

double	accMassMinDen_

double	accPtMin_

double	angMax_

edm::EDGetTokenT< reco::GenParticleCollection >	genToken_

TH1F *	h_etaZ_

TH1F *	h_etaZMC_

TH1F *	h_mZ_

TH1F *	h_mZMC_

TH1F *	h_nZ_

TH1F *	h_phiZ_

TH1F *	h_phiZMC_

TH1F *	h_ptZ_

TH1F *	h_ptZMC_

TH1F *	h_rapidityZ_

TH1F *	h_rapidityZMC_

TH1F *	h_thetaZ_

TH1F *	h_thetaZMC_

TH1F *	hardeta

TH1F *	hardpt

double	massMax_

int	muPdgStatus_

unsigned int	nAcc_

unsigned int	nAccPtScaleN_

unsigned int	nAccPtScaleP_

unsigned int	nAccPtScaleSmearedFlat_

unsigned int	nAccPtScaleSmearedGaus_

unsigned int	nbinsAng_

unsigned int	nbinsMass_

unsigned int	nbinsPt_

unsigned int	nBothMuHasZHasGrandMa_

double	ptMax_

double	ptScale_

TH1F *	softeta

TH1F *	softpt

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

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 9 of file ZMuPtScaleAnalyzer.cc.

Constructor & Destructor Documentation

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

Definition at line 45 of file ZMuPtScaleAnalyzer.cc.

References angMax_, gather_cfg::cout, h_etaZMC_, h_mZMC_, h_phiZMC_, h_ptZMC_, h_rapidityZMC_, h_thetaZMC_, hardeta, hardpt, TFileDirectory::make(), massMax_, TFileService::mkdir(), nAcc_, nAccPtScaleN_, nAccPtScaleP_, nAccPtScaleSmearedFlat_, nAccPtScaleSmearedGaus_, nbinsAng_, nbinsMass_, nbinsPt_, nBothMuHasZHasGrandMa_, ptMax_, softeta, and softpt.

                                                                :
   genToken_(consumes<GenParticleCollection>(pset.getParameter<InputTag>("genParticles"))),
   nbinsMass_(pset.getUntrackedParameter<unsigned int>("nbinsMass")),
   nbinsPt_(pset.getUntrackedParameter<unsigned int>("nbinsPt")),
   nbinsAng_(pset.getUntrackedParameter<unsigned int>("nbinsAng")),
   massMax_(pset.getUntrackedParameter<double>("massMax")),
   ptMax_(pset.getUntrackedParameter<double>("ptMax")),
   angMax_(pset.getUntrackedParameter<double>("angMax")),
   accPtMin_(pset.getUntrackedParameter<double>("accPtMin")),
   accMassMin_(pset.getUntrackedParameter<double>("accMassMin")),
   accMassMax_(pset.getUntrackedParameter<double>("accMassMax")),
   accMassMinDen_(pset.getUntrackedParameter<double>("accMassMinDen")),
   accMassMaxDen_(pset.getUntrackedParameter<double>("accMassMaxDen")),
   accEtaMin_(pset.getUntrackedParameter<double>("accEtaMin")),
   accEtaMax_(pset.getUntrackedParameter<double>("accEtaMax")),
   ptScale_(pset.getUntrackedParameter<double>("ptScale")),
   muPdgStatus_(pset.getUntrackedParameter<int>("muPdgStatus")){
 
   cout << ">>> Z Histogrammer constructor" << endl;
   Service<TFileService> fs;
   TFileDirectory ZMCHisto = fs->mkdir( "ZMCHisto" );
 
   h_mZMC_ = ZMCHisto.make<TH1F>("ZMCMass", "Z MC mass (GeV/c^{2})", nbinsMass_,  0, massMax_);
   h_ptZMC_ = ZMCHisto.make<TH1F>("ZMCPt", "Z MC p_{t} (GeV/c)", nbinsPt_, 0, ptMax_);
  hardpt = ZMCHisto.make<TH1F>("hardpt", "hard muon p_{t} (GeV/c)", nbinsPt_, 0, ptMax_);
  softpt = ZMCHisto.make<TH1F>("softpt", "soft muon p_{t} (GeV/c)", nbinsPt_, 0, ptMax_);
 
 
   h_phiZMC_ = ZMCHisto.make<TH1F>("ZMCPhi", "Z MC #phi", nbinsAng_,  -angMax_, angMax_);
   h_thetaZMC_ = ZMCHisto.make<TH1F>("ZMCTheta", "Z MC #theta", nbinsAng_,  0, angMax_);
   h_etaZMC_ = ZMCHisto.make<TH1F>("ZMCEta", "Z MC #eta", nbinsAng_,  -angMax_, angMax_);
   h_rapidityZMC_ = ZMCHisto.make<TH1F>("ZMCRapidity", "Z MC y", nbinsAng_,  -angMax_, angMax_);
 
   hardeta = ZMCHisto.make<TH1F>("hard muon eta", "hard muon #eta", nbinsAng_,  -angMax_, angMax_);
   softeta = ZMCHisto.make<TH1F>("soft muon eta", "soft muon #eta", nbinsAng_,  -angMax_, angMax_);
   nAcc_=0;
   nAccPtScaleP_=0;
   nAccPtScaleN_=0;
   nAccPtScaleSmearedFlat_=0;
   nAccPtScaleSmearedGaus_=0;
   nBothMuHasZHasGrandMa_=0;}

Member Function Documentation

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

overrideprivatevirtual

Definition at line 89 of file ZMuPtScaleAnalyzer.cc.

References funct::abs(), accEtaMax_, accEtaMin_, accMassMax_, accMassMaxDen_, accMassMin_, accMassMinDen_, accPtMin_, gather_cfg::cout, reco::LeafCandidate::eta(), f, alignCSCRings::ff, HcalObjRepresent::Fill(), relval_steps::gen(), genToken_, h_etaZMC_, h_mZMC_, h_phiZMC_, h_ptZMC_, h_rapidityZMC_, h_thetaZMC_, hardeta, hardpt, mps_fire::i, reco::LeafCandidate::mass(), reco::CompositeRefCandidateT< D >::mother(), reco::Candidate::mother(), electronCleaner_cfi::muons, muPdgStatus_, nAcc_, nAccPtScaleN_, nAccPtScaleP_, nAccPtScaleSmearedFlat_, nAccPtScaleSmearedGaus_, nBothMuHasZHasGrandMa_, reco::CompositeRefCandidateT< D >::numberOfDaughters(), reco::CompositeRefCandidateT< D >::numberOfMothers(), reco::Candidate::numberOfMothers(), p4, reco::Candidate::pdgId(), reco::LeafCandidate::pdgId(), hiDetachedQuadStep_cff::pt1, hiDetachedQuadStep_cff::pt2, ptScale_, softeta, softpt, mathSSE::sqrt(), reco::LeafCandidate::status(), and create_public_lumi_plots::weights.

                                                                                   {
   cout << ">>> Z HistogrammerZLONLOHistogrammer.cc analyze" << endl;
 
   Handle<GenParticleCollection> gen;
   Handle<double> weights;
 
   event.getByToken(genToken_, gen);
 
 
 
 
    // get weight and fill it to histogram
 
 
 
 
   std::vector<GenParticle> muons;
 
   double mZGen = -100;
 
     for(unsigned int i = 0; i < gen->size(); ++i){
       const GenParticle & muMC  = (*gen)[i];
       // filliScaledPng only muons coming form Z
       if (abs(muMC.pdgId())==13 &&  muMC.status()==muPdgStatus_  && muMC.numberOfMothers()>0) {
 
       cout << "I'm getting a muon \n"
            << "with " << "muMC.numberOfMothers()  " <<  muMC.numberOfMothers() << "\n the first mother has pdgId " << muMC.mother()->pdgId()
            << "with " << "muMC.mother()->numberOfMothers()  " <<  muMC.mother()->numberOfMothers()<< "\n the first grandma has pdgId " << muMC.mother()->mother()->pdgId()<<endl;
            cout << "with  muMC.eta() " <<  muMC.eta()<<endl;
            muons.push_back(muMC);
       }
       // introducing here the gen mass cut......................
            /*
    if (muPdgStatus_ ==1) {
         mZGen = muMC.mother()->mother()->mass();
         if (muMC.mother()->mother()->pdgId() ==23  && mZGen>accMassMinDen_ && mZGen<accMassMaxDen_ ) muons.push_back(muMC);}
     }
           if (muPdgStatus_ ==3) {
          mZGen = muMC.mother()->mass();
         if (muMC.mother()->pdgId() ==23  && mZGen>accMassMinDen_ && mZGen<accMassMaxDen_ ) muons.push_back(muMC);}
     }
 */
 
 
       const GenParticle & zMC  = (*gen)[i];
             if (zMC.pdgId()==23 &&  zMC.status()==3 &&zMC.numberOfDaughters()>1  ) {
         mZGen = zMC.mass();
     cout << "I'm selecting a Z MC with mass " << mZGen << endl;
       if(mZGen>accMassMinDen_ && mZGen<accMassMaxDen_ ) h_mZMC_->Fill(mZGen);
 
 
 
       }
       }
 
 
   cout << "finally I selected " << muons.size() << " muons" << endl;
 
 
 
 
 
 // if there are at least two muons,
    // calculate invarant mass of first two and fill it into histogram
 
 
 
  double inv_mass = 0.0;
    double Zpt_ = 0.0;
    double Zeta_ = 0.0;
    double Ztheta_ = 0.0;
    double Zphi_ = 0.0;
    double Zrapidity_ = 0.0;
 
    if(muons.size()>1) {
 
 
     if (muons[0].mother()->mother()->pdgId()==23 && muons[1].mother()->mother()->pdgId()==23) nBothMuHasZHasGrandMa_ ++;
      math::XYZTLorentzVector tot_momentum(muons[0].p4());
      math::XYZTLorentzVector mom2(muons[1].p4());
      tot_momentum += mom2;
      inv_mass = sqrt(tot_momentum.mass2());
      Zpt_=tot_momentum.pt();
      Zeta_ = tot_momentum.eta();
      Ztheta_ = tot_momentum.theta();
      Zphi_ = tot_momentum.phi();
     Zrapidity_ = tot_momentum.Rapidity();
 
 
 
 
       double weight_sign = 1.    ;
 
       //h_mZMC_->Fill(inv_mass);
       h_ptZMC_->Fill(Zpt_,weight_sign);
       h_etaZMC_->Fill(Zeta_,weight_sign);
       h_thetaZMC_->Fill(Ztheta_,weight_sign);
       h_phiZMC_->Fill(Zphi_,weight_sign);
       h_rapidityZMC_-> Fill (Zrapidity_,weight_sign );
 
       double pt1 = muons[0].pt();
       double pt2 = muons[1].pt();
       double eta1 = muons[0].eta();
       double eta2 = muons[1].eta();
 
 
 
 
 
      if(pt1>pt2) {
        hardpt->Fill(pt1,weight_sign);
        softpt->Fill(pt2,weight_sign);
        hardeta->Fill(eta1,weight_sign);
        softeta->Fill(eta2,weight_sign);
      } else {
        hardpt->Fill(pt2,weight_sign);
        softpt->Fill(pt1,weight_sign);
        hardeta->Fill(eta2,weight_sign);
        softeta->Fill(eta1,weight_sign);
      }
 
  //evaluating the geometric acceptance
    if ( pt1 >= accPtMin_  && pt2 >= accPtMin_ &&  fabs(eta1)>= accEtaMin_  && fabs(eta2) >= accEtaMin_ && fabs(eta1)<= accEtaMax_  && fabs(eta2) <= accEtaMax_ && inv_mass>= accMassMin_ && inv_mass<= accMassMax_) nAcc_++;
 
 
    cout << "pt1" <<  pt1 << endl;
 
      // scaling the muon pt
    double  pt1ScaledP = pt1* ( 1. + ptScale_);
   cout << "pt1 ScaledP of " <<  ( 1. + ptScale_) << endl;
    cout << "pt1ScaledP" <<  pt1ScaledP << endl;
 
    double  pt2ScaledP = pt2 * ( 1. + ptScale_);
 
 
    //evaluating the geometric acceptance
    if ( pt1ScaledP >= accPtMin_  && pt2ScaledP >= accPtMin_ &&  fabs(eta1)>= accEtaMin_  && fabs(eta2) >= accEtaMin_ && fabs(eta1)<= accEtaMax_  && fabs(eta2) <= accEtaMax_ && inv_mass>= accMassMin_ && inv_mass<= accMassMax_)
 nAccPtScaleP_++;
 
 
 
 
      // scaling the muon pt
    double  pt1ScaledN = pt1* ( 1. - ptScale_);
    double  pt2ScaledN = pt2 * ( 1. - ptScale_);
 
 
    //evaluating the geometric acceptance
    if ( pt1ScaledN >= accPtMin_  && pt2ScaledN >= accPtMin_ &&  fabs(eta1)>= accEtaMin_  && fabs(eta2) >= accEtaMin_ && fabs(eta1)<= accEtaMax_  && fabs(eta2) <= accEtaMax_ && inv_mass>= accMassMin_ && inv_mass<= accMassMax_)
 nAccPtScaleN_++;
 
 
   // scaling the muon pt
    TRandom3 f;
    f.SetSeed(123456789);
    double  pt1SmearedFlat = pt1* ( 1. + ptScale_ * f.Uniform() );
    double  pt2SmearedFlat = pt2 * ( 1. + ptScale_ * f.Uniform() ) ;
 
 
    //evaluating the geometric acceptance
    if ( pt1SmearedFlat >= accPtMin_  && pt2SmearedFlat >= accPtMin_ &&  fabs(eta1)>= accEtaMin_  && fabs(eta2) >= accEtaMin_ && fabs(eta1)<= accEtaMax_  && fabs(eta2) <= accEtaMax_ && inv_mass>= accMassMin_ && inv_mass<= accMassMax_)
  nAccPtScaleSmearedFlat_++;
 
 
 // scaling the muon pt
    TRandom3 ff;
    ff.SetSeed(123456789);
    double  pt1SmearedGaus = pt1* ( 1. + ptScale_ * f.Gaus() );
    double  pt2SmearedGaus = pt2 * ( 1. + ptScale_ * f.Gaus() ) ;
 
 
    //evaluating the geometric acceptance
    if ( pt1SmearedGaus >= accPtMin_  && pt2SmearedGaus >= accPtMin_ &&  fabs(eta1)>= accEtaMin_  && fabs(eta2) >= accEtaMin_ && fabs(eta1)<= accEtaMax_  && fabs(eta2) <= accEtaMax_ && inv_mass>= accMassMin_ && inv_mass<= accMassMax_)
  nAccPtScaleSmearedGaus_++;
 
 
 
 
    }}

void ZMuPtScaleAnalyzer::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 272 of file ZMuPtScaleAnalyzer.cc.

References gather_cfg::cout, DEFINE_FWK_MODULE, h_mZMC_, nAcc_, nAccPtScaleN_, nAccPtScaleP_, nAccPtScaleSmearedFlat_, nAccPtScaleSmearedGaus_, nBothMuHasZHasGrandMa_, and mathSSE::sqrt().

                                 {
   cout << " number of events accepted :" << nAcc_ << endl;
   cout << " number of total events :" << h_mZMC_->GetEntries()  << endl;
    cout << " number of cases in which BothMuHasZHasGrandMa :" << nBothMuHasZHasGrandMa_  << endl;
   cout << " number of events pt scaled positively accepted :" << nAccPtScaleP_ << endl;
 
   cout << " number of events pt scaled negatively accepted :" << nAccPtScaleN_ << endl;
 
 cout << " number of events pt scaled smeared flattely accepted :" << nAccPtScaleSmearedFlat_ << endl;
 
 cout << " number of events pt scaled smeared gaussianely accepted :" << nAccPtScaleSmearedGaus_ << endl;
 
 
   double eff = (double)nAcc_ / (double) h_mZMC_->GetEntries();
   double err = sqrt( eff * (1. - eff) / (double) h_mZMC_->GetEntries() );
   cout << " geometric acceptance: " << eff << "+/-" << err << endl;
 
  double effScaledP = (double)nAccPtScaleP_ / (double) h_mZMC_->GetEntries();
   double errScaledP = sqrt( effScaledP * (1. - effScaledP) / (double) h_mZMC_->GetEntries() );
   cout << " geometric acceptance when pt muon is positively scaled: " << effScaledP << "+/-" << errScaledP << endl;
 
  double effScaledN = (double)nAccPtScaleN_ / (double) h_mZMC_->GetEntries();
   double errScaledN = sqrt( effScaledN * (1. - effScaledN) / (double) h_mZMC_->GetEntries() );
   cout << " geometric acceptance when pt muon is negatively scaled: " << effScaledN << "+/-" << errScaledN << endl;
 
  double effSmearedFlat = (double) nAccPtScaleSmearedFlat_ / (double) h_mZMC_->GetEntries();
   double errSmearedFlat = sqrt( effSmearedFlat * (1. - effSmearedFlat) / (double) h_mZMC_->GetEntries() );
   cout << " geometric acceptance when pt muon is scaled with a flat smaering: " << effSmearedFlat << "+/-" << errSmearedFlat << endl;
 
  double effSmearedGaus = (double) nAccPtScaleSmearedGaus_ / (double) h_mZMC_->GetEntries();
   double errSmearedGaus = sqrt( effSmearedGaus * (1. - effSmearedGaus) / (double) h_mZMC_->GetEntries() );
   cout << " geometric acceptance when pt muon is scaled with a gaussian smearing: " << effSmearedGaus << "+/-" << errSmearedGaus << endl;
 
 
 }