EgammaCoreTools. More...

#include <ZToMuMuGammaAnalyzer.h>

Inheritance diagram for ZToMuMuGammaAnalyzer:

Public Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &)
virtual void	beginJob ()
virtual void	endJob ()
virtual void	endRun (const edm::Run &, const edm::EventSetup &)
	ZToMuMuGammaAnalyzer (const edm::ParameterSet &)
virtual	~ZToMuMuGammaAnalyzer ()
Private Member Functions
bool	basicMuonSelection (const reco::Muon &m)
float	mumuGammaInvMass (const reco::Muon &mu1, const reco::Muon &mu2, const reco::Photon &pho)
float	mumuInvMass (const reco::Muon &m1, const reco::Muon &m2)
bool	muonSelection (const reco::Muon &m, const reco::BeamSpot &bs)
bool	photonSelection (const reco::Photon &p)
Private Attributes
std::string	barrelRecHitCollection_
std::string	barrelRecHitProducer_
std::stringstream	currentFolder_
DQMStore *	dbe_
std::string	endcapRecHitCollection_
std::string	endcapRecHitProducer_
float	farMuonEcalIso_
float	farMuonMinPt_
float	farMuonTrackIso_
std::string	fName_
MonitorElement *	h1_mumuGammaInvMass_
MonitorElement *	h1_mumuInvMass_
bool	isHeavyIon_
float	maxMumuGammaInvMass_
float	maxMumuInvMass_
float	minMumuGammaInvMass_
float	minMumuInvMass_
int	minPixStripHits_
std::string	muonCollection_
int	muonMatches_
float	muonMaxChi2_
float	muonMaxDxy_
float	muonMinPt_
std::string	muonProducer_
float	muonTightEta_
float	muonTrackIso_
float	nearMuonDr_
float	nearMuonHcalIso_
int	nEntry_
int	nEvt_
std::string	outputFileName_
edm::ParameterSet	parameters_
std::string	photonCollection_
float	photonMaxEta_
float	photonMinEt_
std::string	photonProducer_
float	photonTrackIso_
unsigned int	prescaleFactor_
bool	standAlone_
edm::InputTag	triggerEvent_
bool	useTriggerFiltering_
int	validMuonHits_
int	validPixHits_
int	verbosity_

Detailed Description

EgammaCoreTools.

$Id: ZToMuMuGammaAnalyzer

Date:: 2012/02/07 13:11:00

authors: Nancy Marinelli, U. of Notre Dame, US

$Id: ZToMuMuGammaAnalyzer

Date:: 2012/01/26 13:48:59

authors: Nancy Marinelli, U. of Notre Dame, US Jamie Antonelli, U. of Notre Dame, US

Definition at line 107 of file ZToMuMuGammaAnalyzer.h.

Constructor & Destructor Documentation

ZToMuMuGammaAnalyzer::ZToMuMuGammaAnalyzer ( const edm::ParameterSet & pset ) [explicit]

Definition at line 22 of file ZToMuMuGammaAnalyzer.cc.

References edm::ParameterSet::getParameter(), and edm::ParameterSet::getUntrackedParameter().

{

    fName_                  = pset.getUntrackedParameter<string>("Name");
    verbosity_              = pset.getUntrackedParameter<int>("Verbosity");
    prescaleFactor_         = pset.getUntrackedParameter<int>("prescaleFactor",1);
    standAlone_             = pset.getParameter<bool>("standAlone");
    outputFileName_         = pset.getParameter<string>("OutputFileName");
    isHeavyIon_             = pset.getUntrackedParameter<bool>("isHeavyIon",false);
    triggerEvent_           = pset.getParameter<edm::InputTag>("triggerEvent");
    useTriggerFiltering_    = pset.getParameter<bool>("useTriggerFiltering");
    //
    photonProducer_         = pset.getParameter<string>("phoProducer");
    photonCollection_       = pset.getParameter<string>("photonCollection");

    barrelRecHitProducer_   = pset.getParameter<string>("barrelRecHitProducer");
    barrelRecHitCollection_ = pset.getParameter<string>("barrelRecHitCollection");

    endcapRecHitProducer_   = pset.getParameter<string>("endcapRecHitProducer");
    endcapRecHitCollection_ = pset.getParameter<string>("endcapRecHitCollection");

    muonProducer_         = pset.getParameter<string>("muonProducer");
    muonCollection_       = pset.getParameter<string>("muonCollection");
    // Muon selection
    muonMinPt_             = pset.getParameter<double>("muonMinPt");
    minPixStripHits_       = pset.getParameter<int>("minPixStripHits");
    muonMaxChi2_           = pset.getParameter<double>("muonMaxChi2");
    muonMaxDxy_            = pset.getParameter<double>("muonMaxDxy");
    muonMatches_           = pset.getParameter<int>("muonMatches");
    validPixHits_          = pset.getParameter<int>("validPixHits");
    validMuonHits_         = pset.getParameter<int>("validMuonHits");
    muonTrackIso_          = pset.getParameter<double>("muonTrackIso");
    muonTightEta_          = pset.getParameter<double>("muonTightEta");
    // Dimuon selection
    minMumuInvMass_       = pset.getParameter<double>("minMumuInvMass");
    maxMumuInvMass_       = pset.getParameter<double>("maxMumuInvMass");
    // Photon selection
    photonMinEt_             = pset.getParameter<double>("photonMinEt");
    photonMaxEta_            = pset.getParameter<double>("photonMaxEta");
    photonTrackIso_          = pset.getParameter<double>("photonTrackIso");
    // mumuGamma selection
    nearMuonDr_               = pset.getParameter<double>("nearMuonDr");
    nearMuonHcalIso_          = pset.getParameter<double>("nearMuonHcalIso");
    farMuonEcalIso_           = pset.getParameter<double>("farMuonEcalIso");
    farMuonTrackIso_          = pset.getParameter<double>("farMuonTrackIso");
    farMuonMinPt_             = pset.getParameter<double>("farMuonMinPt");
    minMumuGammaInvMass_  = pset.getParameter<double>("minMumuGammaInvMass");
    maxMumuGammaInvMass_  = pset.getParameter<double>("maxMumuGammaInvMass");
    //
    parameters_ = pset;

}

ZToMuMuGammaAnalyzer::~ZToMuMuGammaAnalyzer ( ) [virtual]

Definition at line 77 of file ZToMuMuGammaAnalyzer.cc.

{}

Member Function Documentation

void ZToMuMuGammaAnalyzer::analyze	(	const edm::Event &	e,
		const edm::EventSetup &	esup
	)		`[virtual]`

Implements edm::EDAnalyzer.

Definition at line 184 of file ZToMuMuGammaAnalyzer.cc.

References deltaR(), HcalObjRepresent::Fill(), edm::Event::getByLabel(), i, edm::EventBase::id(), reco::Muon::isolationR03(), label, reco::LeafCandidate::pt(), and python::multivaluedict::sort().

{
  using namespace edm;

  if (nEvt_% prescaleFactor_ ) return;
  nEvt_++;
  LogInfo("ZToMuMuGammaAnalyzer") << "ZToMuMuGammaAnalyzer Analyzing event number: " << e.id() << " Global Counter " << nEvt_ <<"\n";


  // Get the trigger results
  bool validTriggerEvent=true;
  edm::Handle<trigger::TriggerEvent> triggerEventHandle;
  trigger::TriggerEvent triggerEvent;
  e.getByLabel(triggerEvent_,triggerEventHandle);
  if(!triggerEventHandle.isValid()) {
    edm::LogInfo("PhotonAnalyzer") << "Error! Can't get the product "<< triggerEvent_.label() << endl;
    validTriggerEvent=false;
  }
  if(validTriggerEvent) triggerEvent = *(triggerEventHandle.product());


  // Get the reconstructed photons
  bool validPhotons=true;
  Handle<reco::PhotonCollection> photonHandle;
  reco::PhotonCollection photonCollection;
  e.getByLabel(photonProducer_, photonCollection_ , photonHandle);
  if ( !photonHandle.isValid()) {
    edm::LogInfo("ZToMuMuGammaAnalyzer") << "Error! Can't get the product "<< photonCollection_ << endl;
    validPhotons=false;
  }
  if(validPhotons) photonCollection = *(photonHandle.product());

  // Get the PhotonId objects
  bool validloosePhotonID=true;
  Handle<edm::ValueMap<bool> > loosePhotonFlag;
  edm::ValueMap<bool> loosePhotonID;
  e.getByLabel("PhotonIDProd", "PhotonCutBasedIDLoose", loosePhotonFlag);
  if ( !loosePhotonFlag.isValid()) {
    edm::LogInfo("ZToMuMuGammaAnalyzer") << "Error! Can't get the product "<< "PhotonCutBasedIDLoose" << endl;
    validloosePhotonID=false;
  }
  if (validloosePhotonID) loosePhotonID = *(loosePhotonFlag.product());

  bool validtightPhotonID=true;
  Handle<edm::ValueMap<bool> > tightPhotonFlag;
  edm::ValueMap<bool> tightPhotonID;
  e.getByLabel("PhotonIDProd", "PhotonCutBasedIDTight", tightPhotonFlag);
  if ( !tightPhotonFlag.isValid()) {
    edm::LogInfo("ZToMuMuGammaAnalyzer") << "Error! Can't get the product "<< "PhotonCutBasedIDTight" << endl;
    validtightPhotonID=false;
  }
  if (validtightPhotonID) tightPhotonID = *(tightPhotonFlag.product());

  // Get the reconstructed muons
  bool validMuons=true;
  Handle<reco::MuonCollection> muonHandle;
  reco::MuonCollection muonCollection;
  e.getByLabel(muonProducer_, muonCollection_ , muonHandle);
  if ( !muonHandle.isValid()) {
    edm::LogInfo("ZToMuMuGammaAnalyzer") << "Error! Can't get the product "<< muonCollection_ << endl;
    validMuons=false;
  }
  if(validMuons) muonCollection = *(muonHandle.product());

  // Get the beam spot
  edm::Handle<reco::BeamSpot> bsHandle;
  e.getByLabel("offlineBeamSpot", bsHandle);
  if (!bsHandle.isValid()) {
      edm::LogError("TrackerOnlyConversionProducer") << "Error! Can't get the product primary Vertex Collection "<< "\n";
      return;
  }
  const reco::BeamSpot &thebs = *bsHandle.product();




  //Prepare list of photon-related HLT filter names
  vector<int> Keys;
  for(uint filterIndex=0;filterIndex<triggerEvent.sizeFilters();++filterIndex){  //loop over all trigger filters in event (i.e. filters passed)
    string label = triggerEvent.filterTag(filterIndex).label();
    if(label.find( "Photon" ) != string::npos ) {  //get photon-related filters
      for(uint filterKeyIndex=0;filterKeyIndex<triggerEvent.filterKeys(filterIndex).size();++filterKeyIndex){  //loop over keys to objects passing this filter
        Keys.push_back(triggerEvent.filterKeys(filterIndex)[filterKeyIndex]);  //add keys to a vector for later reference
      }
    }
  }

  // sort Keys vector in ascending order
  // and erases duplicate entries from the vector
  sort(Keys.begin(),Keys.end());
  for ( uint i=0 ; i<Keys.size() ; )
   {
    if (i!=(Keys.size()-1))
     {
      if (Keys[i]==Keys[i+1]) Keys.erase(Keys.begin()+i+1) ;
      else ++i ;
     }
    else ++i ;
   }



  if ( muonCollection.size() < 2 ) return;

  for( reco::MuonCollection::const_iterator  iMu = muonCollection.begin(); iMu != muonCollection.end(); iMu++) {
    if ( !basicMuonSelection (*iMu) ) continue;
 
    for( reco::MuonCollection::const_iterator  iMu2 = iMu+1; iMu2 != muonCollection.end(); iMu2++) {
      if ( !basicMuonSelection (*iMu2) ) continue;
      if ( iMu->charge()*iMu2->charge() > 0) continue;

      if ( !muonSelection(*iMu,thebs) && !muonSelection(*iMu2,thebs) ) continue;

 
     
      float mumuMass = mumuInvMass(*iMu,*iMu2) ;
      if ( mumuMass <  minMumuInvMass_  ||  mumuMass >  maxMumuInvMass_ ) continue;

      h1_mumuInvMass_ -> Fill (mumuMass);      

      if (  photonCollection.size() < 1 ) continue;

      reco::Muon nearMuon;
      reco::Muon farMuon;
      for( reco::PhotonCollection::const_iterator  iPho = photonCollection.begin(); iPho != photonCollection.end(); iPho++) {
        if ( !photonSelection (*iPho) ) continue;


        DeltaR<reco::Muon, reco::Photon> deltaR;
        double dr1 = deltaR(*iMu, *iPho);
        double dr2 = deltaR(*iMu2,*iPho);
        double drNear = dr1;
        if (dr1 < dr2) {
          nearMuon =*iMu ; farMuon  = *iMu2; drNear = dr1;
        } else {
          nearMuon = *iMu2; farMuon  = *iMu; drNear = dr2;
        }

        if ( nearMuon.isolationR03().hadEt > nearMuonHcalIso_ )  continue;
        if ( farMuon.isolationR03().sumPt > farMuonTrackIso_ )  continue;
        if ( farMuon.isolationR03().emEt  > farMuonEcalIso_ )  continue;
        if ( farMuon.pt() < farMuonMinPt_ )       continue;
        if ( drNear > nearMuonDr_)                continue;
        

        float mumuGammaMass = mumuGammaInvMass(*iMu,*iMu2,*iPho) ;
        if ( mumuGammaMass < minMumuGammaInvMass_ || mumuGammaMass > maxMumuGammaInvMass_ ) continue;
            
        h1_mumuGammaInvMass_ ->Fill (mumuGammaMass);


      } 
      
    }

  }


}//End of Analyze method

bool ZToMuMuGammaAnalyzer::basicMuonSelection ( const reco::Muon & m ) [private]

Definition at line 369 of file ZToMuMuGammaAnalyzer.cc.

References reco::LeafCandidate::eta(), reco::Muon::globalTrack(), reco::Muon::innerTrack(), reco::Muon::isGlobalMuon(), reco::LeafCandidate::pt(), and query::result.

                                                                   {
  bool result=true;
  if (!mu.innerTrack().isNonnull())    result=false;
  if (!mu.globalTrack().isNonnull())   result=false;
  if ( !mu.isGlobalMuon() )            result=false; 
  if ( mu.pt() < muonMinPt_ )                  result=false;
  if ( fabs(mu.eta())>2.4 )            result=false;

  int pixHits=0;
  int tkHits=0;
  if ( mu.innerTrack().isNonnull() ) {
    pixHits=mu.innerTrack()->hitPattern().numberOfValidPixelHits();
    tkHits=mu.innerTrack()->hitPattern().numberOfValidStripHits();
  }

  if ( pixHits+tkHits < minPixStripHits_ ) result=false;
  

  return result;  
}

void ZToMuMuGammaAnalyzer::beginJob ( void ) [virtual]

Reimplemented from edm::EDAnalyzer.

Definition at line 80 of file ZToMuMuGammaAnalyzer.cc.

References DQMStore::book1D(), dbe_, jptDQMConfig_cff::etMax, reco::tau::qcuts::etMin(), cppFunctionSkipper::operator, and DQMStore::setCurrentFolder().

{

  nEvt_=0;
  nEntry_=0;

  dbe_ = 0;
  dbe_ = edm::Service<DQMStore>().operator->();



//   double eMin = parameters_.getParameter<double>("eMin");
//   double eMax = parameters_.getParameter<double>("eMax");
//   int    eBin = parameters_.getParameter<int>("eBin");

  double etMin = parameters_.getParameter<double>("etMin");
  double etMax = parameters_.getParameter<double>("etMax");
  int    etBin = parameters_.getParameter<int>("etBin");

//   double sumMin = parameters_.getParameter<double>("sumMin");
//   double sumMax = parameters_.getParameter<double>("sumMax");
//   int    sumBin = parameters_.getParameter<int>("sumBin");

//   double etaMin = parameters_.getParameter<double>("etaMin");
//   double etaMax = parameters_.getParameter<double>("etaMax");
//   int    etaBin = parameters_.getParameter<int>("etaBin");

//   double phiMin = parameters_.getParameter<double>("phiMin");
//   double phiMax = parameters_.getParameter<double>("phiMax");
//   int    phiBin = parameters_.getParameter<int>("phiBin");

//   double r9Min = parameters_.getParameter<double>("r9Min");
//   double r9Max = parameters_.getParameter<double>("r9Max");
//   int    r9Bin = parameters_.getParameter<int>("r9Bin");

//   double hOverEMin = parameters_.getParameter<double>("hOverEMin");
//   double hOverEMax = parameters_.getParameter<double>("hOverEMax");
//   int    hOverEBin = parameters_.getParameter<int>("hOverEBin");

//   double xMin = parameters_.getParameter<double>("xMin");
//   double xMax = parameters_.getParameter<double>("xMax");
//   int    xBin = parameters_.getParameter<int>("xBin");

//   double yMin = parameters_.getParameter<double>("yMin");
//   double yMax = parameters_.getParameter<double>("yMax");
//   int    yBin = parameters_.getParameter<int>("yBin");

//   double numberMin = parameters_.getParameter<double>("numberMin");
//   double numberMax = parameters_.getParameter<double>("numberMax");
//   int    numberBin = parameters_.getParameter<int>("numberBin");

//   double zMin = parameters_.getParameter<double>("zMin");
//   double zMax = parameters_.getParameter<double>("zMax");
//   int    zBin = parameters_.getParameter<int>("zBin");

//   double rMin = parameters_.getParameter<double>("rMin");
//   double rMax = parameters_.getParameter<double>("rMax");
//   int    rBin = parameters_.getParameter<int>("rBin");

//   double dPhiTracksMin = parameters_.getParameter<double>("dPhiTracksMin");
//   double dPhiTracksMax = parameters_.getParameter<double>("dPhiTracksMax");
//   int    dPhiTracksBin = parameters_.getParameter<int>("dPhiTracksBin");

//   double dEtaTracksMin = parameters_.getParameter<double>("dEtaTracksMin");
//   double dEtaTracksMax = parameters_.getParameter<double>("dEtaTracksMax");
//   int    dEtaTracksBin = parameters_.getParameter<int>("dEtaTracksBin");

//   double sigmaIetaMin = parameters_.getParameter<double>("sigmaIetaMin");
//   double sigmaIetaMax = parameters_.getParameter<double>("sigmaIetaMax");
//   int    sigmaIetaBin = parameters_.getParameter<int>("sigmaIetaBin");

//   double eOverPMin = parameters_.getParameter<double>("eOverPMin");
//   double eOverPMax = parameters_.getParameter<double>("eOverPMax");
//   int    eOverPBin = parameters_.getParameter<int>("eOverPBin");

//   double chi2Min = parameters_.getParameter<double>("chi2Min");
//   double chi2Max = parameters_.getParameter<double>("chi2Max");
//   int    chi2Bin = parameters_.getParameter<int>("chi2Bin");


//   int reducedEtBin  = etBin/4;
//   int reducedEtaBin = etaBin/4;
//   int reducedSumBin = sumBin/4;
//   int reducedR9Bin  = r9Bin/4;



  if (dbe_) {


    dbe_->setCurrentFolder("Egamma/PhotonAnalyzer/ZToMuMuGamma");
    h1_mumuInvMass_ = dbe_->book1D("mumuInvMass","Two muon invariant mass: M (GeV)",etBin/2,etMin,etMax/2);
    h1_mumuGammaInvMass_ = dbe_->book1D("mumuGammaInvMass","Two-muon plus gamma invariant mass: M (GeV)",etBin/2,etMin,etMax/2);
 


  }//end if(dbe_)


}//end BeginJob

void ZToMuMuGammaAnalyzer::endJob ( void ) [virtual]

Reimplemented from edm::EDAnalyzer.

Definition at line 357 of file ZToMuMuGammaAnalyzer.cc.

References dbe_, DQMStore::save(), and DQMStore::setCurrentFolder().

{
  //dbe_->showDirStructure();
  if(standAlone_){
    dbe_->setCurrentFolder("Egamma/PhotonAnalyzer/ZToMuMuGamma");

    dbe_->save(outputFileName_);
  }


}

void ZToMuMuGammaAnalyzer::endRun	(	const edm::Run &	run,
		const edm::EventSetup &	setup
	)		`[virtual]`

Reimplemented from edm::EDAnalyzer.

Definition at line 345 of file ZToMuMuGammaAnalyzer.cc.

References dbe_, and DQMStore::setCurrentFolder().

{
  if(!standAlone_){

    dbe_->setCurrentFolder("Egamma/PhotonAnalyzer/ZToMuMuGamma");


  }

}

float ZToMuMuGammaAnalyzer::mumuGammaInvMass	(	const reco::Muon &	mu1,
		const reco::Muon &	mu2,
		const reco::Photon &	pho
	)		`[private]`

Definition at line 429 of file ZToMuMuGammaAnalyzer.cc.

References reco::LeafCandidate::p4(), reco::Photon::p4(), and mathSSE::sqrt().

 {
   math::XYZTLorentzVector p12 = mu1.p4()+mu2.p4()+pho.p4() ;
   float Mass2 = p12.Dot(p12) ;
   float invMass = sqrt(Mass2) ;
   return invMass ;
 }

float ZToMuMuGammaAnalyzer::mumuInvMass	(	const reco::Muon &	m1,
		const reco::Muon &	m2
	)		`[private]`

Definition at line 421 of file ZToMuMuGammaAnalyzer.cc.

References reco::LeafCandidate::p4(), and mathSSE::sqrt().

 {
  math::XYZTLorentzVector p12 = mu1.p4()+mu2.p4() ;
  float mumuMass2 = p12.Dot(p12) ;
  float invMass = sqrt(mumuMass2) ;
  return invMass ;
 }

bool ZToMuMuGammaAnalyzer::muonSelection	(	const reco::Muon &	m,
		const reco::BeamSpot &	bs
	)		`[private]`

Definition at line 390 of file ZToMuMuGammaAnalyzer.cc.

References reco::LeafCandidate::eta(), reco::Muon::globalTrack(), reco::Muon::isolationR03(), reco::Muon::isTrackerMuon(), reco::Muon::numberOfMatches(), query::result, and reco::Muon::track().

                                                                                             {
  bool result=true;
  if ( mu.globalTrack()->normalizedChi2() > muonMaxChi2_ )          result=false;
  if ( fabs( mu.globalTrack()->dxy(beamSpot)) > muonMaxDxy_ )       result=false;
  if ( mu.numberOfMatches() < muonMatches_ )                                   result=false;

  if ( mu.track()-> hitPattern().numberOfValidPixelHits() <  validPixHits_ )     result=false;
  if ( mu.globalTrack()->hitPattern().numberOfValidMuonHits() < validMuonHits_ ) result=false;
  if ( !mu.isTrackerMuon() )                                        result=false;
  // track isolation 
  if ( mu.isolationR03().sumPt > muonTrackIso_ )                                result=false;
  if ( fabs(mu.eta())>  muonTightEta_ )                                         result=false;
 

  return result;  
}

bool ZToMuMuGammaAnalyzer::photonSelection ( const reco::Photon & p ) [private]

Definition at line 408 of file ZToMuMuGammaAnalyzer.cc.

References reco::LeafCandidate::eta(), reco::Photon::isEBEEGap(), reco::LeafCandidate::pt(), and query::result.

                                                                   {
  bool result=true;
  if ( pho.pt() < photonMinEt_ )          result=false;
  if ( fabs(pho.eta())> photonMaxEta_ )   result=false;
  if ( pho.isEBEEGap() )       result=false;
  //  if ( pho.trkSumPtHollowConeDR04() >   photonTrackIso_ )   result=false; // check how to exclude the muon track (which muon track).


  return result;  
}