/data/refman/pasoursint/CMSSW_6_1_2_SLHC2/src/MuonAnalysis/MomentumScaleCalibration/plugins/MuScleFitMuonSelector.h

Go to the documentation of this file.

#ifndef MUSCLEFITMUONSELECTOR
#define MUSCLEFITMUONSELECTOR

#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/Event.h"
#include "DataFormats/Candidate/interface/LeafCandidate.h"
#include "DataFormats/PatCandidates/interface/CompositeCandidate.h"
#include "DataFormats/PatCandidates/interface/CompositeCandidate.h"
#include "DataFormats/PatCandidates/interface/Muon.h"
#include "SimDataFormats/GeneratorProducts/interface/HepMCProduct.h"
#include "SimDataFormats/Track/interface/SimTrackContainer.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "MuonAnalysis/MomentumScaleCalibration/interface/GenMuonPair.h"

#include "HepMC/GenParticle.h"
#include "HepMC/GenEvent.h"

#include "MuScleFitPlotter.h"

#include <vector>

typedef reco::Particle::LorentzVector lorentzVector;

class MuScleFitMuonSelector
{
 public:
  MuScleFitMuonSelector(const edm::InputTag & muonLabel, const int muonType, const bool PATmuons,
                        const std::vector<int> & resfind,
                        const bool speedup, const std::string & genParticlesName,
                        const bool compareToSimTracks, const edm::InputTag & simTracksCollectionName,
                        const bool sherpa, const bool debug) :
    muonLabel_(muonLabel),
    muonType_(muonType),
    PATmuons_(PATmuons),
    resfind_(resfind),
    speedup_(speedup),
    genParticlesName_(genParticlesName),
    compareToSimTracks_(compareToSimTracks),
    simTracksCollectionName_(simTracksCollectionName),
    sherpa_(sherpa),
    debug_(debug)
  {}
  ~MuScleFitMuonSelector() {}

  //Method to get the muon after FSR (status 1 muon) starting from status 3 muon which is daughter of the Z
  const reco::Candidate* getStatus1Muon(const reco::Candidate* status3Muon);
  
  void selectMuons(const edm::Event & event, std::vector<reco::LeafCandidate> & muons,
                   std::vector<GenMuonPair> & genPair,
                   std::vector<std::pair<lorentzVector,lorentzVector> > & simPair,
                   MuScleFitPlotter * plotter);

 protected:
  bool selGlobalMuon(const pat::Muon* aMuon);
  bool selTrackerMuon(const pat::Muon* aMuon);

  // Generator and simulation level information
  GenMuonPair findGenMuFromRes( const reco::GenParticleCollection* genParticles);
  GenMuonPair findGenMuFromRes( const edm::HepMCProduct* evtMC );
  std::pair<lorentzVector, lorentzVector> findSimMuFromRes( const edm::Handle<edm::HepMCProduct> & evtMC,
                                                            const edm::Handle<edm::SimTrackContainer> & simTracks );
  void selectGeneratedMuons(const edm::Handle<pat::CompositeCandidateCollection> & collAll,
                            const std::vector<const pat::Muon*> & collMuSel,
                            std::vector<GenMuonPair> & genPair,
                            MuScleFitPlotter * plotter);
  void selectGenSimMuons(const edm::Event & event,
                         std::vector<GenMuonPair> & genPair,
                         std::vector<std::pair<lorentzVector,lorentzVector> > & simPair,
                         MuScleFitPlotter * plotter);
  // void selectGeneratedMuons(const edm::Event & event, std::vector<std::pair<lorentzVector,lorentzVector> > & genPair);
  void selectSimulatedMuons(const edm::Event & event,
                            const bool ifHepMC, edm::Handle<edm::HepMCProduct> evtMC,
                            std::vector<std::pair<lorentzVector,lorentzVector> > & simPair,
                            MuScleFitPlotter * plotter);

  template<typename T>
  std::vector<reco::LeafCandidate> fillMuonCollection( const std::vector<T>& tracks )
  {
    std::vector<reco::LeafCandidate> muons;
    typename std::vector<T>::const_iterator track;
    for( track = tracks.begin(); track != tracks.end(); ++track ) {
      reco::Particle::LorentzVector mu;
      mu = reco::Particle::LorentzVector(track->px(),track->py(),track->pz(),
                                         sqrt(track->p()*track->p() + mMu2));
      reco::LeafCandidate muon(track->charge(),mu);
      muons.push_back(muon);
    }
    return muons;
  }

  template<typename T>
  void takeSelectedMuonType(const T & muon, std::vector<reco::Track> & tracks)
  {
    // std::cout<<"muon "<<muon->isGlobalMuon()<<muon->isStandAloneMuon()<<muon->isTrackerMuon()<<std::endl;
    //NNBB: one muon can be of many kinds at once but with the muonType_ we are sure
    // to avoid double counting of the same muon
    if(muon->isGlobalMuon() && muonType_==1)
      tracks.push_back(*(muon->globalTrack()));
    else if(muon->isStandAloneMuon() && muonType_==2)
      tracks.push_back(*(muon->outerTrack()));
    else if(muon->isTrackerMuon() && muonType_==3)
      tracks.push_back(*(muon->innerTrack()));

    else if( muonType_ == 10 && !(muon->isStandAloneMuon()) ) //particular case!!
      tracks.push_back(*(muon->innerTrack()));
    else if( muonType_ == 11 && muon->isGlobalMuon() )
      tracks.push_back(*(muon->innerTrack()));
    else if( muonType_ == 13 && muon->isTrackerMuon() )
      tracks.push_back(*(muon->innerTrack()));
  }

  const edm::InputTag muonLabel_;
  const int muonType_;
  const bool PATmuons_;
  const std::vector<int> resfind_;
  const bool speedup_;
  const std::string genParticlesName_;
  const bool compareToSimTracks_;
  const edm::InputTag simTracksCollectionName_;
  const bool sherpa_;
  const bool debug_;
  static const double mMu2;
  static const unsigned int motherPdgIdArray[6];
};

#endif