#include <MuonCosmicCompatibilityFiller.h>

Public Member Functions
reco::MuonCosmicCompatibility	fillCompatibility (const reco::Muon &muon, edm::Event &, const edm::EventSetup &)
	fill cosmic compatibility variables More...

	MuonCosmicCompatibilityFiller (const edm::ParameterSet &)

	~MuonCosmicCompatibilityFiller ()

Private Member Functions
unsigned int	backToBack2LegCosmic (const edm::Event &, const reco::Muon &) const
	return cosmic-likeness based on presence of a track in opp side: 0 == no matching opp tracks More...

bool	checkMuonID (const reco::Muon &) const
	tag a muon as cosmic based on the muonID information More...

bool	checkMuonSegments (const reco::Muon &muon) const
	tag a muon as cosmic based on segment compatibility and the number of segment matches More...

float	combinedCosmicID (const edm::Event &, const edm::EventSetup &iSetup, const reco::Muon &, bool CheckMuonID, bool checkVertex) const
	combined cosmic-likeness: 0 == not cosmic-like More...

unsigned int	eventActivity (const edm::Event &, const reco::Muon &) const
	returns cosmic-likeness based on the event activity information: tracker track multiplicity and vertex quality. 0 == cosmic-like More...

bool	isOverlappingMuon (const edm::Event &, const edm::EventSetup &iSetup, const reco::Muon &) const
	returns cosmic-likeness based on overlap with traversing cosmic muon (only muon/STA hits are used) More...

float	muonTiming (const edm::Event &iEvent, const reco::Muon &muon, bool isLoose) const
	check muon time (DT and CSC) information: 0 == prompt-like More...

unsigned int	nMuons (const edm::Event &) const
	get number of muons in the vent More...

unsigned int	pvMatches (const edm::Event &, const reco::Muon &, bool) const
	return cosmic-likeness based on the 2D impact parameters (dxy, dz wrt to PV). 0 == cosmic-like More...

Private Attributes
double	angleThreshold_

double	corrTimeNeg_

double	corrTimePos_

double	deltaPt_

double	hIpTrdxy_

double	hIpTrvProb_

edm::InputTag	inputCosmicMuonCollection_

std::vector< edm::InputTag >	inputMuonCollections_

std::vector< edm::InputTag >	inputTrackCollections_

edm::InputTag	inputVertexCollection_

double	ipThreshold_

double	largedxy_

double	largedxyMult_

double	maxdxyLoose_

double	maxdxyLooseMult_

double	maxdxyTight_

double	maxdxyTightMult_

double	maxdzLoose_

double	maxdzLooseMult_

double	maxdzTight_

double	maxdzTightMult_

double	maxvertRho_

double	maxvertZ_

double	minvProb_

int	nChamberMatches_

unsigned int	nTrackThreshold_

double	offTimeNegLoose_

double	offTimeNegLooseMult_

double	offTimeNegTight_

double	offTimeNegTightMult_

double	offTimePosLoose_

double	offTimePosLooseMult_

double	offTimePosTight_

double	offTimePosTightMult_

double	segmentComp_

MuonServiceProxy *	service_

double	sharedFrac_

int	sharedHits_

Detailed Description

Description: class for cosmic muon identification

Date:: 2010/09/03 14:00:46

Revision:: 2.0

Author: : A. Everett, Purdue University; : A. Svyatkovskiy, Purdue University; : H.D. Yoo, Purdue University

Definition at line 32 of file MuonCosmicCompatibilityFiller.h.

Constructor & Destructor Documentation

MuonCosmicCompatibilityFiller::MuonCosmicCompatibilityFiller ( const edm::ParameterSet & iConfig )

Definition at line 55 of file MuonCosmicCompatibilityFiller.cc.

References angleThreshold_, corrTimeNeg_, corrTimePos_, deltaPt_, edm::ParameterSet::getParameter(), hIpTrdxy_, hIpTrvProb_, ipThreshold_, largedxy_, largedxyMult_, maxdxyLoose_, maxdxyLooseMult_, maxdxyTight_, maxdxyTightMult_, maxdzLoose_, maxdzLooseMult_, maxdzTight_, maxdzTightMult_, maxvertRho_, maxvertZ_, minvProb_, MuonServiceProxy_cff::MuonServiceProxy, nChamberMatches_, offTimeNegLoose_, offTimeNegLooseMult_, offTimeNegTight_, offTimeNegTightMult_, offTimePosLoose_, offTimePosLooseMult_, offTimePosTight_, offTimePosTightMult_, segmentComp_, service_, sharedFrac_, and sharedHits_.

                                                                                           :
   inputMuonCollections_(iConfig.getParameter<std::vector<edm::InputTag> >("InputMuonCollections")),
   inputTrackCollections_(iConfig.getParameter<std::vector<edm::InputTag> >("InputTrackCollections")),
   inputCosmicMuonCollection_(iConfig.getParameter<edm::InputTag>("InputCosmicMuonCollection")),
   inputVertexCollection_(iConfig.getParameter<edm::InputTag>("InputVertexCollection")),
   service_(0)
 {
   // service parameters
   edm::ParameterSet serviceParameters = iConfig.getParameter<edm::ParameterSet>("ServiceParameters");
   service_ = new MuonServiceProxy(serviceParameters);     
   
   //kinematic vars
   angleThreshold_ = iConfig.getParameter<double>("angleCut");
   deltaPt_ = iConfig.getParameter<double>("deltaPt");
   //time
   offTimePosTightMult_ = iConfig.getParameter<double>("offTimePosTightMult");
   offTimeNegTightMult_ = iConfig.getParameter<double>("offTimeNegTightMult");
   offTimePosTight_ = iConfig.getParameter<double>("offTimePosTight");
   offTimeNegTight_ = iConfig.getParameter<double>("offTimeNegTight");
   offTimePosLooseMult_ = iConfig.getParameter<double>("offTimePosLooseMult");
   offTimeNegLooseMult_ = iConfig.getParameter<double>("offTimeNegLooseMult");
   offTimePosLoose_ = iConfig.getParameter<double>("offTimePosLoose");
   offTimeNegLoose_ = iConfig.getParameter<double>("offTimeNegLoose");
   corrTimeNeg_ = iConfig.getParameter<double>("corrTimeNeg");
   corrTimePos_ = iConfig.getParameter<double>("corrTimePos");
   //rechits
   sharedHits_ = iConfig.getParameter<int>("sharedHits");
   sharedFrac_ = iConfig.getParameter<double>("sharedFrac");
   ipThreshold_ = iConfig.getParameter<double>("ipCut");
   //segment comp, matches
   nChamberMatches_ = iConfig.getParameter<int>("nChamberMatches");
   segmentComp_ = iConfig.getParameter<double>("segmentComp");
   //ip, vertex
   maxdzLooseMult_ = iConfig.getParameter<double>("maxdzLooseMult");
   maxdxyLooseMult_ = iConfig.getParameter<double>("maxdxyLooseMult");
   maxdzTightMult_ = iConfig.getParameter<double>("maxdzTightMult");
   maxdxyTightMult_ = iConfig.getParameter<double>("maxdxyTightMult");
   maxdzLoose_ = iConfig.getParameter<double>("maxdzLoose");
   maxdxyLoose_ = iConfig.getParameter<double>("maxdxyLoose");
   maxdzTight_ = iConfig.getParameter<double>("maxdzTight");
   maxdxyTight_ = iConfig.getParameter<double>("maxdxyTight");
   largedxyMult_ = iConfig.getParameter<double>("largedxyMult");
   largedxy_ = iConfig.getParameter<double>("largedxy");
   hIpTrdxy_ = iConfig.getParameter<double>("hIpTrdxy");
   hIpTrvProb_ = iConfig.getParameter<double>("hIpTrvProb");
   minvProb_ = iConfig.getParameter<double>("minvProb");
   maxvertZ_ = iConfig.getParameter<double>("maxvertZ");
   maxvertRho_ = iConfig.getParameter<double>("maxvertRho");
 //  nTrackThreshold_ = iConfig.getParameter<unsigned int>("nTrackThreshold");
 }

MuonCosmicCompatibilityFiller::~MuonCosmicCompatibilityFiller ( )

Definition at line 106 of file MuonCosmicCompatibilityFiller.cc.

References service_.

                                                               {
   if (service_) delete service_;
 }

Member Function Documentation

unsigned int MuonCosmicCompatibilityFiller::backToBack2LegCosmic	(	const edm::Event &	iEvent,
		const reco::Muon &	muon
	)		const

private

return cosmic-likeness based on presence of a track in opp side: 0 == no matching opp tracks

Definition at line 222 of file MuonCosmicCompatibilityFiller.cc.

References angleThreshold_, deltaPt_, muonid::findOppositeTrack(), edm::Event::getByLabel(), reco::Muon::innerTrack(), inputTrackCollections_, reco::Muon::isGlobalMuon(), reco::Muon::isStandAloneMuon(), reco::Muon::isTrackerMuon(), query::result, and reco::Muon::track().

Referenced by combinedCosmicID(), and fillCompatibility().

                                                                                                       {
 
   unsigned int result = 0; //no partners - collision
   reco::TrackRef track;
   if ( muon.isGlobalMuon()  )            track = muon.innerTrack();
   else if ( muon.isTrackerMuon() )       track = muon.track();
   else if ( muon.isStandAloneMuon() )    return false;
 
   for (unsigned int iColl = 0; iColl<inputTrackCollections_.size(); ++iColl){
     edm::Handle<reco::TrackCollection> trackHandle;
     iEvent.getByLabel(inputTrackCollections_[iColl],trackHandle);
     if (muonid::findOppositeTrack(trackHandle, *track, angleThreshold_, deltaPt_).isNonnull()) { 
       result++;
      }
    } //loop over track collections
 
   return result;
 }

bool MuonCosmicCompatibilityFiller::checkMuonID ( const reco::Muon & imuon ) const

private

tag a muon as cosmic based on the muonID information

Definition at line 604 of file MuonCosmicCompatibilityFiller.cc.

References muon::GlobalMuonPromptTight, muon::isGoodMuon(), query::result, and muon::TMOneStationLoose.

 {
   bool result = false;
   // initial set up using Jordan's study: GlobalMuonPromptTight + TMOneStationLoose
   if( muon::isGoodMuon(imuon, muon::GlobalMuonPromptTight) && muon::isGoodMuon(imuon, muon::TMOneStationLoose) ) result = true;
   
   return result;
 }

bool MuonCosmicCompatibilityFiller::checkMuonSegments ( const reco::Muon & muon ) const

private

tag a muon as cosmic based on segment compatibility and the number of segment matches

Definition at line 613 of file MuonCosmicCompatibilityFiller.cc.

References nChamberMatches_, reco::Muon::numberOfMatches(), query::result, segmentComp_, and muon::segmentCompatibility().

                                                                                  {
 
    bool result = false;
    if (imuon.numberOfMatches() < nChamberMatches_ &&  muon::segmentCompatibility(imuon) < segmentComp_) result = true;
 
    return result;
 }

float MuonCosmicCompatibilityFiller::combinedCosmicID	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const reco::Muon &	muon,
		bool	CheckMuonID,
		bool	checkVertex
	)		const

private

combined cosmic-likeness: 0 == not cosmic-like

Definition at line 480 of file MuonCosmicCompatibilityFiller.cc.

References backToBack2LegCosmic(), eventActivity(), reco::Muon::isGlobalMuon(), isOverlappingMuon(), muonTiming(), pvMatches(), and query::result.

Referenced by fillCompatibility().

                                                                                                                                 {
 
   float result = 0.0;
 
   // return >=1 = identify as cosmic muon (the more like cosmics, the higher is the number) 
   // return 0.0 = identify as collision muon
   if( muon.isGlobalMuon() ) {
 
     unsigned int cosmicVertex = eventActivity(iEvent, muon);
     bool isOverlapping = isOverlappingMuon(iEvent, iSetup, muon);
     unsigned int looseIp = pvMatches(iEvent, muon, true);
     unsigned int tightIp = pvMatches(iEvent, muon, false);
     float looseTime = muonTiming(iEvent, muon, true);
     float tightTime = muonTiming(iEvent, muon, false);
     unsigned int backToback = backToBack2LegCosmic(iEvent,muon);
     //bool cosmicSegment = checkMuonSegments(muon);
 
     //short cut to reject cosmic event
     if (checkVertex && cosmicVertex == 0) return 10.0;
 
     // compatibility (0 - 10)
     // weight is assigned by the performance of individual module
     // btob: ~90% eff / ~0% misid
     // ip: ~90% eff / ~0% misid
     // time: ~30% eff / ~0% misid
     double weight_btob = 2.0;
     double weight_ip = 2.0;
     double weight_time = 1.0;
     double weight_overlap = 0.5;
 
     // collision muon should have compatibility < 4 (0 - 4)
     // cosmic muon should have compatibility >= 4 (4 - 10)
 
     // b-to-b (max comp.: 4.0)
     if( backToback >= 1 ) {
        //in this case it is cosmic for sure
        result += weight_btob*2.;
        if( tightIp == 1 ) {
            // check with other observables to reduce mis-id (subtract compatibilities)
            if( looseIp == 1 ) {
              if( backToback < 2 ) result -= weight_btob*0.5;
            }
        }
     }
 
     // ip (max comp.: 4.0)
     if( tightIp == 0 ) {
         //in this case it is cosmic for sure
         result += weight_ip*2.0;
     if( backToback == 0 ) {
            // check with other observables to reduce mis-id (subtract compatibilities)
        if( tightTime == 0 ) {
          if( looseTime == 0 && !isOverlapping ) result -= weight_ip*1.0;
        }
     }
     }
     else if( tightIp >= 2 ) {
         // in this case it is almost collision-like (reduce compatibility)
         // if multi pvs: comp = -2.0 
         if( backToback >= 1 ) result -= weight_ip*1.0;
     }
 
     // timing (max comp.: 2.0)
     if( tightTime > 0 ) {
         // bonus track
         if( looseTime > 0 ) {
       if( backToback >= 1 ) {
         if( tightIp == 0 ) result += weight_time*tightTime;
         else if( looseIp == 0 ) result += weight_time*0.25;
       }
     }
     else {
       if( backToback >= 1 && tightIp == 0 ) result += weight_time*0.25;
     }
     }
 
     // overlapping
     if( backToback == 0 && isOverlapping ) {
         // bonus track
         if( tightIp == 0 && tightTime >= 1 ) {
             result += weight_overlap*1.0;
         }
     }
  }//is global muon
 
 
 //  if (CheckMuonID && cosmicSegment) result += 4;  
 
   return result;
 }

unsigned int MuonCosmicCompatibilityFiller::eventActivity	(	const edm::Event &	iEvent,
		const reco::Muon &	muon
	)		const

private

returns cosmic-likeness based on the event activity information: tracker track multiplicity and vertex quality. 0 == cosmic-like

Definition at line 578 of file MuonCosmicCompatibilityFiller.cc.

References edm::HandleBase::failedToGet(), edm::Event::getByLabel(), inputTrackCollections_, inputVertexCollection_, maxvertRho_, maxvertZ_, minvProb_, edm::Handle< T >::product(), query::result, and testEve_cfg::tracks.

Referenced by combinedCosmicID(), and fillCompatibility().

 {
 
   unsigned int result = 0; //no good vertices - cosmic-like
 
   //check track activity
   edm::Handle<reco::TrackCollection> tracks;
   iEvent.getByLabel(inputTrackCollections_[0],tracks);
   if (!tracks.failedToGet() && tracks->size() < 3) return 0; 
 
   //cosmic event should have zero good vertices
   edm::Handle<reco::VertexCollection> pvHandle;
   if (!iEvent.getByLabel(inputVertexCollection_,pvHandle)) {return 0;} else {
       const reco::VertexCollection & vertices = *pvHandle.product();
       //check if vertex collection is empty
       if (vertices.begin() == vertices.end()) return 0;
       for(reco::VertexCollection::const_iterator it=vertices.begin() ; it!=vertices.end() ; ++it){
           if ((TMath::Prob(it->chi2(),(int)it->ndof()) > minvProb_) && (fabs(it->z()) <= maxvertZ_) && (fabs(it->position().rho()) <= maxvertRho_)) result++;
           }
        }
   return result;
 }

reco::MuonCosmicCompatibility MuonCosmicCompatibilityFiller::fillCompatibility	(	const reco::Muon &	muon,
		edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

fill cosmic compatibility variables

Definition at line 111 of file MuonCosmicCompatibilityFiller.cc.

References backToBack2LegCosmic(), reco::MuonCosmicCompatibility::backToBackCompatibility, combinedCosmicID(), reco::MuonCosmicCompatibility::cosmicCompatibility, eventActivity(), reco::MuonCosmicCompatibility::ipCompatibility, isOverlappingMuon(), muonTiming(), reco::MuonCosmicCompatibility::overlapCompatibility, pvMatches(), service_, reco::MuonCosmicCompatibility::timeCompatibility, and reco::MuonCosmicCompatibility::vertexCompatibility.

Referenced by CosmicsMuonIdProducer::produce().

 {
   const std::string theCategory = "MuonCosmicCompatibilityFiller";
 
   reco::MuonCosmicCompatibility returnComp;
   
   service_->update(iSetup);
   
   float timeCompatibility = muonTiming(iEvent, muon, false);
   float backToBackCompatibility = backToBack2LegCosmic(iEvent,muon);    
   float overlapCompatibility = isOverlappingMuon(iEvent,iSetup,muon);
   float ipCompatibility = pvMatches(iEvent,muon,false);
   float vertexCompatibility = eventActivity(iEvent,muon);
   float combinedCompatibility = combinedCosmicID(iEvent,iSetup,muon,false,false);
   
   returnComp.timeCompatibility = timeCompatibility;
   returnComp.backToBackCompatibility = backToBackCompatibility;
   returnComp.overlapCompatibility = overlapCompatibility;
   returnComp.cosmicCompatibility = combinedCompatibility;
   returnComp.ipCompatibility = ipCompatibility;
   returnComp.vertexCompatibility = vertexCompatibility;
   
   return returnComp;
   
 }

bool MuonCosmicCompatibilityFiller::isOverlappingMuon	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const reco::Muon &	muon
	)		const

private

returns cosmic-likeness based on overlap with traversing cosmic muon (only muon/STA hits are used)

Definition at line 267 of file MuonCosmicCompatibilityFiller.cc.

References edm::HandleBase::failedToGet(), edm::EventSetup::get(), edm::Event::getByLabel(), reco::Muon::innerTrack(), inputCosmicMuonCollection_, inputVertexCollection_, ipThreshold_, reco::Muon::isGlobalMuon(), edm::Ref< C, T, F >::isNonnull(), mag(), max(), reco::Muon::outerTrack(), edm::Handle< T >::product(), sharedFrac_, sharedHits_, and MuonServiceProxy::trackingGeometry().

Referenced by combinedCosmicID(), and fillCompatibility().

                                                                                                                                 {
 
   // 4 steps in this module
   // step1 : check whether it's 1leg cosmic muon or not
   // step2 : both muons (muons and muonsFromCosmics1Leg) should have close IP
   // step3 : both muons should share very close reference point
   // step4 : check shared hits in both muon tracks
 
   // check if this muon is available in muonsFromCosmics collection
   bool overlappingMuon = false; //false - not cosmic-like
   if( !muon.isGlobalMuon() ) return false;
   
   // reco muons for cosmics
   edm::Handle<reco::MuonCollection> muonHandle;
   iEvent.getByLabel(inputCosmicMuonCollection_, muonHandle);
   
   // Global Tracking Geometry
   ESHandle<GlobalTrackingGeometry> trackingGeometry;
   iSetup.get<GlobalTrackingGeometryRecord>().get(trackingGeometry);
   
   // PV
   math::XYZPoint RefVtx;
   RefVtx.SetXYZ(0, 0, 0);
   
   edm::Handle<reco::VertexCollection> pvHandle;
   iEvent.getByLabel(inputVertexCollection_,pvHandle);
   const reco::VertexCollection & vertices = *pvHandle.product();
   for(reco::VertexCollection::const_iterator it=vertices.begin() ; it!=vertices.end() ; ++it) {
       RefVtx = it->position();
   }
   
   
   if( !muonHandle.failedToGet() ) {
     for ( reco::MuonCollection::const_iterator cosmicMuon = muonHandle->begin();cosmicMuon !=  muonHandle->end(); ++cosmicMuon ) {
       if ( cosmicMuon->innerTrack() == muon.innerTrack() || cosmicMuon->outerTrack() == muon.outerTrack()) return true;
       
       reco::TrackRef outertrack = muon.outerTrack();
       reco::TrackRef costrack = cosmicMuon->outerTrack();
       
       bool isUp = false;
       if( outertrack->phi() > 0 ) isUp = true; 
       
       // shared hits 
       int RecHitsMuon = outertrack->numberOfValidHits();
       int RecHitsCosmicMuon = 0;
       int shared = 0;
       // count hits for same hemisphere
       if( costrack.isNonnull() ) {
     int nhitsUp = 0;
     int nhitsDown = 0;
     bool isCosmic1Leg = false;
     bool isCloseIP = false;
     bool isCloseRef = false;
 
     for( trackingRecHit_iterator coshit = costrack->recHitsBegin(); coshit != costrack->recHitsEnd(); coshit++ ) {
       if( (*coshit)->isValid() ) {
         DetId id((*coshit)->geographicalId());
         double hity = trackingGeometry->idToDet(id)->position().y();
         if( hity > 0 ) nhitsUp++;
         if( hity < 0 ) nhitsDown++;
 
         if( isUp && hity > 0 ) RecHitsCosmicMuon++;
         if( !isUp && hity < 0 ) RecHitsCosmicMuon++;
       }
     }
     // step1
     if( nhitsUp > 0 && nhitsDown > 0 ) isCosmic1Leg = true;
     //if( !isCosmic1Leg ) continue;
     
     if( outertrack.isNonnull() ) {
       // step2
           const double ipErr = (double)outertrack->d0Error();
           double ipThreshold  = max(ipThreshold_, ipErr);
       if( fabs(outertrack->dxy(RefVtx) + costrack->dxy(RefVtx)) < ipThreshold ) isCloseIP = true;
       //if( !isCloseIP ) continue;
 
       // step3
       GlobalPoint muonRefVtx( outertrack->vx(), outertrack->vy(), outertrack->vz() );
       GlobalPoint cosmicRefVtx( costrack->vx(), costrack->vy(), costrack->vz() );
       float dist = (muonRefVtx - cosmicRefVtx).mag();
       if( dist < 0.1 ) isCloseRef = true;
       //if( !isCloseRef ) continue;
 
       for( trackingRecHit_iterator trkhit = outertrack->recHitsBegin(); trkhit != outertrack->recHitsEnd(); trkhit++ ) {
         if( (*trkhit)->isValid() ) {
           for( trackingRecHit_iterator coshit = costrack->recHitsBegin(); coshit != costrack->recHitsEnd(); coshit++ ) {
         if( (*coshit)->isValid() ) {
           if( (*trkhit)->geographicalId() == (*coshit)->geographicalId() ) {
             if( ((*trkhit)->localPosition() - (*coshit)->localPosition()).mag()< 10e-5 ) shared++;
           }
           
         }
           }
         }
       }
     }
       }
       // step4
       double fraction = -1;
       if( RecHitsMuon != 0 ) fraction = shared/(double)RecHitsMuon;
     //       std::cout << "shared = " << shared << " " << fraction << " " << RecHitsMuon << " " << RecHitsCosmicMuon << std::endl;
       if( shared > sharedHits_ && fraction > sharedFrac_ ) {
     overlappingMuon = true;
     break;
       }
     }
   }
   
   return overlappingMuon;
 }

float MuonCosmicCompatibilityFiller::muonTiming	(	const edm::Event &	iEvent,
		const reco::Muon &	muon,
		bool	isLoose
	)		const

private

check muon time (DT and CSC) information: 0 == prompt-like

Definition at line 141 of file MuonCosmicCompatibilityFiller.cc.

References corrTimeNeg_, corrTimePos_, edm::HandleBase::failedToGet(), edm::Event::getByLabel(), inputMuonCollections_, edm::Ref< C, T, F >::isNonnull(), reco::Muon::isTimeValid(), nMuons(), offTimeNegLoose_, offTimeNegLooseMult_, offTimeNegTight_, offTimeNegTightMult_, offTimePosLoose_, offTimePosLooseMult_, offTimePosTight_, offTimePosTightMult_, reco::Muon::outerTrack(), pvMatches(), query::result, reco::Muon::time(), and reco::MuonTime::timeAtIpInOut.

Referenced by combinedCosmicID(), and fillCompatibility().

                                                                                                           {
 
    float offTimeNegMult, offTimePosMult, offTimeNeg, offTimePos;
 
    if (isLoose) {
      //use "loose" parameter set
      offTimeNegMult = offTimeNegLooseMult_; 
      offTimePosMult = offTimePosLooseMult_;
      offTimeNeg     = offTimeNegLoose_;
      offTimePos     = offTimePosLoose_;
   } else {
      offTimeNegMult = offTimeNegTightMult_;
      offTimePosMult = offTimePosTightMult_;
      offTimeNeg     = offTimeNegTight_;
      offTimePos     = offTimePosTight_;
   }
 
   float result = 0.0;
 
   if( muon.isTimeValid() ) {
     //case of multiple muon event
     if (nMuons(iEvent) > 1) {
 
       float positiveTime = 0;
       if ( muon.time().timeAtIpInOut < offTimeNegMult || muon.time().timeAtIpInOut > offTimePosMult) result = 1.;
       if ( muon.time().timeAtIpInOut > 0.) positiveTime = muon.time().timeAtIpInOut;
 
       //special case, looking for time-correlation 
       // between muons in opposite hemispheres 
       if (!isLoose && result == 0 && positiveTime > corrTimePos_) { 
 
           //check hemi of this muon
           bool isUp = false;
           reco::TrackRef outertrack = muon.outerTrack();
           if( outertrack.isNonnull() ) {
               if( outertrack->phi() > 0 ) isUp = true;
 
               //loop over muons in that event and find if there are any in the opposite hemi 
               edm::Handle<reco::MuonCollection> muonHandle;
               iEvent.getByLabel(inputMuonCollections_[1], muonHandle);
 
               if( !muonHandle.failedToGet() ) {
                   for ( reco::MuonCollection::const_iterator iMuon = muonHandle->begin(); iMuon !=  muonHandle->end(); ++iMuon ) {
                       if (!iMuon->isGlobalMuon()) continue;
 
                       reco::TrackRef checkedTrack = iMuon->outerTrack();
                       if( muon.isTimeValid() ) {
 
                           // from bottom up
                           if (checkedTrack->phi() < 0 && isUp) {
                               if (iMuon->time().timeAtIpInOut < corrTimeNeg_) result = 1.0;
                               break;
                           } else if (checkedTrack->phi() > 0 && !isUp) {
                                // from top down 
                                if (iMuon->time().timeAtIpInOut < corrTimeNeg_) result = 1.0; 
                                break;
                              }
                          } //muon is time valid
                      } 
                  }
              } //track is nonnull
          } //double check timing
      } else {
         //case of a single muon event
         if ( muon.time().timeAtIpInOut < offTimeNeg || muon.time().timeAtIpInOut > offTimePos) result = 1.;
       }
     } //is time valid
 
   
    if (!isLoose && result > 0) {
      //check loose ip
      if (pvMatches(iEvent, muon, true) == 0) result *= 2.;
    } 
 
    return result;
 }

unsigned int MuonCosmicCompatibilityFiller::nMuons ( const edm::Event & iEvent ) const

private

get number of muons in the vent

Definition at line 245 of file MuonCosmicCompatibilityFiller.cc.

References edm::HandleBase::failedToGet(), edm::Event::getByLabel(), and inputMuonCollections_.

Referenced by muonTiming(), and pvMatches().

                                                                   {
 
     unsigned int nGlb = 0;
 
     edm::Handle<reco::MuonCollection> muonHandle;
     iEvent.getByLabel(inputMuonCollections_[1], muonHandle);
 
     if( !muonHandle.failedToGet() ) {
       for ( reco::MuonCollection::const_iterator iMuon = muonHandle->begin(); iMuon !=  muonHandle->end(); ++iMuon ) {
          if (!iMuon->isGlobalMuon()) continue;
            nGlb++;
         }
       } 
  
     return nGlb;
 }

unsigned int MuonCosmicCompatibilityFiller::pvMatches	(	const edm::Event &	iEvent,
		const reco::Muon &	muon,
		bool	isLoose
	)		const

private

return cosmic-likeness based on the 2D impact parameters (dxy, dz wrt to PV). 0 == cosmic-like

Definition at line 382 of file MuonCosmicCompatibilityFiller.cc.

References edm::HandleBase::failedToGet(), edm::Event::getByLabel(), hIpTrdxy_, hIpTrvProb_, reco::Muon::innerTrack(), inputMuonCollections_, inputVertexCollection_, reco::Muon::isGlobalMuon(), edm::Ref< C, T, F >::isNonnull(), reco::Muon::isStandAloneMuon(), reco::Muon::isTrackerMuon(), largedxy_, largedxyMult_, maxdxyLoose_, maxdxyLooseMult_, maxdxyTight_, maxdxyTightMult_, maxdzLoose_, maxdzLooseMult_, maxdzTight_, maxdzTightMult_, patZpeak::muons, nMuons(), reco::Muon::outerTrack(), edm::Handle< T >::product(), query::result, reco::Muon::standAloneMuon(), reco::Muon::track(), and testEve_cfg::tracks.

Referenced by combinedCosmicID(), fillCompatibility(), and muonTiming().

                                                                                                          {
 
    float maxdxyMult, maxdzMult, maxdxy, maxdz;
 
    if (isLoose) {
      //use "loose" parameter set
      maxdxyMult = maxdxyLooseMult_;
      maxdzMult  = maxdzLooseMult_;
      maxdxy     = maxdxyLoose_;
      maxdz      = maxdzLoose_;
   } else {
      maxdxyMult = maxdxyTightMult_;
      maxdzMult  = maxdzTightMult_;
      maxdxy     = maxdxyTight_;
      maxdz      = maxdzTight_;
   }
 
   unsigned int result = 0;
 
   reco::TrackRef track;
   if ( muon.isGlobalMuon() )          track = muon.innerTrack();
   else if ( muon.isTrackerMuon() )    track = muon.track();
   else if ( muon.isStandAloneMuon())  track = muon.standAloneMuon();
   
   bool multipleMu = false;
   if (nMuons(iEvent) > 1) multipleMu = true;
 
   math::XYZPoint RefVtx;
   RefVtx.SetXYZ(0, 0, 0);
 
   edm::Handle<reco::VertexCollection> pvHandle;
   iEvent.getByLabel(inputVertexCollection_,pvHandle);
   const reco::VertexCollection & vertices = *pvHandle.product();
   for(reco::VertexCollection::const_iterator it=vertices.begin() ; it!=vertices.end() ; ++it){
     RefVtx = it->position();
 
     if ( track.isNonnull() ) {
        if (multipleMu) {
          //multiple muon event
 
          if ( fabs( (*track).dxy(RefVtx) ) < maxdxyMult || fabs( (*track).dz(RefVtx) ) < maxdzMult) {
            result++;
 
            //case of extra large dxy
            if (!isLoose && fabs( (*track).dxy(RefVtx) ) > largedxyMult_) result -= 1;  
 
           }
      } else {
         //single muon event
 
         if (fabs( (*track).dxy(RefVtx) ) < maxdxy || fabs( (*track).dz(RefVtx) ) < maxdz) {
           result++;
 
           //case of extra large dxy
           if (!isLoose && fabs( (*track).dxy(RefVtx) ) > largedxy_) result -= 1; 
 
          }
       }
    }//track is nonnull
 }//loop over vertices
 
    //special case for non-cosmic large ip muons
    if (result == 0 && multipleMu) {
       // consider all reco muons in an event
       edm::Handle<reco::MuonCollection> muonHandle;
       iEvent.getByLabel(inputMuonCollections_[1], muonHandle);
 
       //cosmic event should have zero good vertices
       edm::Handle<reco::VertexCollection> pvHandle;
       iEvent.getByLabel(inputVertexCollection_,pvHandle);
       const reco::VertexCollection & vertices = *pvHandle.product();
 
       //find the "other" one
       if( !muonHandle.failedToGet() ) {
          for ( reco::MuonCollection::const_iterator muons = muonHandle->begin(); muons !=  muonHandle->end(); ++muons ) {
             if (!muons->isGlobalMuon()) continue;
             //skip this track  
             if ( muons->innerTrack() == muon.innerTrack() && muons->outerTrack() == muon.outerTrack()) continue;
                 //check ip and vertex of the "other" muon
                 reco::TrackRef tracks;
                 if (muons->isGlobalMuon()) tracks = muons->innerTrack();
                 if (fabs((*tracks).dxy(RefVtx)) > hIpTrdxy_) continue; 
                 //check if vertex collection is empty
                 if (vertices.begin() == vertices.end()) continue;
                 //for(reco::VertexCollection::const_iterator it=vertices.begin() ; it!=vertices.end() ; ++it) {
                     //find matching vertex by position
                     //if (fabs(it->z() - tracks->vz()) > 0.01) continue; //means will not be untagged from cosmics 
                     if (TMath::Prob(vertices.front().chi2(),(int)(vertices.front().ndof())) > hIpTrvProb_) result = 1; 
                //}
            }
       }
  }
 
     return result;
 
 }