PatZToMuMuAnalyzer.cc

Go to the documentation of this file.

#include <map>
#include <string>

#include "TH1D.h"
#include "TH2D.h"

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "FWCore/Framework/interface/EDAnalyzer.h"
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "DataFormats/PatCandidates/interface/Muon.h"

class PatZToMuMuAnalyzer : public edm::EDAnalyzer {
  
 public:
  typedef math::XYZVector Vector;
  typedef math::XYZTLorentzVector LorentzVector;

  explicit PatZToMuMuAnalyzer(const edm::ParameterSet& cfg);
  ~PatZToMuMuAnalyzer(){};
  
 private:
  virtual void analyze(const edm::Event& event, const edm::EventSetup& setup);

  double mass(const math::XYZVector& t1, const math::XYZVector& t2) const;
  bool booked(const std::string histName) const { return hists_.find(histName.c_str())!=hists_.end(); };
  void fill(const std::string histName, double value) const { if(booked(histName.c_str())) hists_.find(histName.c_str())->second->Fill(value); };
  void fill(std::string hists, const reco::TrackRef& t1, const reco::TrackRef& t2) const;

  edm::InputTag muons_;
  double shift_;
  std::map< std::string, TH1D* > hists_;
};

inline double 
PatZToMuMuAnalyzer::mass(const Vector& t1,  const Vector& t2) const
{
  return (LorentzVector(shift_*t1.x(), shift_*t1.y(), t1.z(), sqrt((0.1057*0.1057)+t1.mag2())) + LorentzVector(shift_*t2.x(), shift_*t2.y(), t2.z(), sqrt((0.1057*0.1057)+t2.mag2()))).mass();
}

#include "FWCore/ServiceRegistry/interface/Service.h"
#include "CommonTools/UtilAlgos/interface/TFileService.h"

PatZToMuMuAnalyzer::PatZToMuMuAnalyzer(const edm::ParameterSet& cfg):
  muons_(cfg.getParameter< edm::InputTag >("muons")),
  shift_(cfg.getParameter< double >("shift"))
{
  edm::Service< TFileService > fileService;
  
  // mass plot around Z peak from global tracks
  hists_[ "globalMass"] = fileService->make< TH1D >( "globalMass" , "Mass_{Z} (global) (GeV)",   90,    30.,   120.);
  // eta from global tracks
  hists_[ "globalEta" ] = fileService->make< TH1D >( "globalEta"  , "#eta (global)"          ,   48,   -2.4,    2.4);
  // pt from global tracks
  hists_[ "globalPt"  ] = fileService->make< TH1D >( "globalPt"   , "p_{T} (global) (GeV)"   ,  100,     0.,   100.);
  // mass plot around Z peak from inner tracks
  hists_[ "innerMass" ] = fileService->make< TH1D >( "innerMass"  , "Mass_{Z} (inner) (GeV)" ,   90,    30.,   120.);
  // eta from inner tracks
  hists_[ "innerEta"  ] = fileService->make< TH1D >( "innerEta"   , "#eta (inner)"           ,   48,   -2.4,    2.4);
  // pt from inner tracks
  hists_[ "innerPt"   ] = fileService->make< TH1D >( "innerPt"    , "p_{T} (inner) (GeV)"    ,  100,     0.,   100.);
  // mass plot around Z peak from outer tracks
  hists_[ "outerMass" ] = fileService->make< TH1D >( "outerMass"  , "Mass_{Z} (outer) (GeV)" ,   90,    30.,   120.);
  // eta from outer tracks
  hists_[ "outerEta"  ] = fileService->make< TH1D >( "outerEta"   , "#eta (outer)"           ,   48,   -2.4,    2.4);
  // pt from outer tracks
  hists_[ "outerPt"   ] = fileService->make< TH1D >( "outerPt"    , "p_{T} (outer) (GeV)"    ,  100,     0.,   100.);
  // delta pt between global and outer track
  hists_[ "deltaPt"   ] = fileService->make< TH1D >( "deltaPt"    , "#Delta p_{T} (GeV)"     ,  100,   -20.,    20.);
  // delta eta between global and outer track
  hists_[ "deltaEta"  ] = fileService->make< TH1D >( "deltaEta"   , "#Delta #eta"            ,  100,   -0.2,    0.2);
  // delta phi between global and outer track
  hists_[ "deltaPhi"  ] = fileService->make< TH1D >( "deltaPhi"   , "#Delta #phi"            ,  100,   -0.2,    0.2);
}

void PatZToMuMuAnalyzer::fill(std::string hists, const reco::TrackRef& t1, const reco::TrackRef& t2) const 
{
  if( t1.isAvailable() ){
    // fill pt from global track for first muon
    fill( std::string(hists).append("Pt") , t1->pt() );
    // fill pt from global track for second muon
    fill( std::string(hists).append("Eta"), t1->eta() );
  }
  if( t2.isAvailable() ){
    // fill eta from global track for first muon
    fill( std::string(hists).append("Pt") , t2->pt() );
    // fill eta from global track for second muon
    fill( std::string(hists).append("Eta"), t2->eta() );
  }
  if( t1.isAvailable() && t2.isAvailable() ){
    // fill invariant mass of the Z boson candidate
    fill( std::string(hists).append("Mass"), mass(t1->momentum(), t2->momentum()));
  }
}

void PatZToMuMuAnalyzer::analyze(const edm::Event& event, const edm::EventSetup& setup)
{
  // pat candidate collection
  edm::Handle< edm::View<pat::Muon> > muons;
  event.getByLabel(muons_, muons);

  // Fill some basic muon quantities as 
  // reconstructed from inner and outer 
  // tack 
  for(edm::View<pat::Muon>::const_iterator mu1=muons->begin(); mu1!=muons->end(); ++mu1){
    for(edm::View<pat::Muon>::const_iterator mu2=muons->begin(); mu2!=muons->end(); ++mu2){
      if(mu2>mu1){ // prevent double conting
    if( mu1->charge()*mu2->charge()<0 ){ // check only muon pairs of unequal charge 
      fill(std::string("inner" ), mu1->innerTrack (), mu2->innerTrack ());
      fill(std::string("outer" ), mu1->outerTrack (), mu2->outerTrack ());
      fill(std::string("global"), mu1->globalTrack(), mu2->globalTrack());
      
      if(mu1->isGlobalMuon()){
        fill("deltaPt" , mu1->outerTrack()->pt ()-mu1->globalTrack()->pt ());
        fill("deltaEta", mu1->outerTrack()->eta()-mu1->globalTrack()->eta());
        fill("deltaPhi", mu1->outerTrack()->phi()-mu1->globalTrack()->phi());
      }
      if(mu2->isGlobalMuon()){
        fill("deltaPt" , mu2->outerTrack()->pt ()-mu2->globalTrack()->pt ());
        fill("deltaEta", mu2->outerTrack()->eta()-mu2->globalTrack()->eta());
        fill("deltaPhi", mu2->outerTrack()->phi()-mu2->globalTrack()->phi());
      }
    }
      }
    }
  }
}

#include "FWCore/Framework/interface/MakerMacros.h"
DEFINE_FWK_MODULE( PatZToMuMuAnalyzer );