#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 &, edm::ConsumesCollector &)

	~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_

edm::EDGetTokenT< reco::MuonCollection >	cosmicToken_

double	deltaPt_

edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	geometryToken_

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_

std::vector< edm::EDGetTokenT< reco::MuonCollection > >	muonTokens_

int	nChamberMatches_

unsigned int	nTrackThreshold_

double	offTimeNegLoose_

double	offTimeNegLooseMult_

double	offTimeNegTight_

double	offTimeNegTightMult_

double	offTimePosLoose_

double	offTimePosLooseMult_

double	offTimePosTight_

double	offTimePosTightMult_

double	segmentComp_

double	sharedFrac_

int	sharedHits_

std::vector< edm::EDGetTokenT< reco::TrackCollection > >	trackTokens_

edm::EDGetTokenT< reco::VertexCollection >	vertexToken_

Detailed Description

Description: class for cosmic muon identification

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

Definition at line 43 of file MuonCosmicCompatibilityFiller.h.

Constructor & Destructor Documentation

◆ MuonCosmicCompatibilityFiller()

MuonCosmicCompatibilityFiller::MuonCosmicCompatibilityFiller	(	const edm::ParameterSet &	iConfig,
		edm::ConsumesCollector &	iC
	)

Definition at line 43 of file MuonCosmicCompatibilityFiller.cc.

References angleThreshold_, edm::ConsumesCollector::consumes(), corrTimeNeg_, corrTimePos_, cosmicToken_, deltaPt_, edm::ConsumesCollector::esConsumes(), geometryToken_, edm::ParameterSet::getParameter(), hIpTrdxy_, hIpTrvProb_, mps_fire::i, inputCosmicMuonCollection_, inputMuonCollections_, inputTrackCollections_, inputVertexCollection_, ipThreshold_, largedxy_, largedxyMult_, maxdxyLoose_, maxdxyLooseMult_, maxdxyTight_, maxdxyTightMult_, maxdzLoose_, maxdzLooseMult_, maxdzTight_, maxdzTightMult_, maxvertRho_, maxvertZ_, minvProb_, muonTokens_, nChamberMatches_, offTimeNegLoose_, offTimeNegLooseMult_, offTimeNegTight_, offTimeNegTightMult_, offTimePosLoose_, offTimePosLooseMult_, offTimePosTight_, offTimePosTightMult_, segmentComp_, sharedFrac_, sharedHits_, trackTokens_, and vertexToken_.

     : 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")) {
   //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");
 
   for (unsigned int i = 0; i < inputMuonCollections_.size(); ++i)
     muonTokens_.push_back(iC.consumes<reco::MuonCollection>(inputMuonCollections_.at(i)));
   for (unsigned int i = 0; i < inputTrackCollections_.size(); ++i)
     trackTokens_.push_back(iC.consumes<reco::TrackCollection>(inputTrackCollections_.at(i)));
 
   cosmicToken_ = iC.consumes<reco::MuonCollection>(inputCosmicMuonCollection_);
   vertexToken_ = iC.consumes<reco::VertexCollection>(inputVertexCollection_);
   geometryToken_ = iC.esConsumes<GlobalTrackingGeometry, GlobalTrackingGeometryRecord>();
 }

◆ ~MuonCosmicCompatibilityFiller()

MuonCosmicCompatibilityFiller::~MuonCosmicCompatibilityFiller ( )

Definition at line 98 of file MuonCosmicCompatibilityFiller.cc.

98 {}

Member Function Documentation

◆ backToBack2LegCosmic()

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 211 of file MuonCosmicCompatibilityFiller.cc.

References angleThreshold_, deltaPt_, muonid::findOppositeTrack(), iEvent, mps_fire::result, HLT_2023v12_cff::track, and trackTokens_.

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() || muon.isRPCMuon() || muon.isGEMMuon() || muon.isME0Muon())
     return false;
 
   for (unsigned int iColl = 0; iColl < trackTokens_.size(); ++iColl) {
     edm::Handle<reco::TrackCollection> trackHandle;
     iEvent.getByToken(trackTokens_[iColl], trackHandle);
     if (muonid::findOppositeTrack(trackHandle, *track, angleThreshold_, deltaPt_).isNonnull()) {
       result++;
     }
   }  //loop over track collections
 
   return result;
 }

◆ checkMuonID()

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

private

tag a muon as cosmic based on the muonID information

Definition at line 590 of file MuonCosmicCompatibilityFiller.cc.

References muon::GlobalMuonPromptTight, muon::isGoodMuon(), mps_fire::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;
 }

◆ checkMuonSegments()

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 599 of file MuonCosmicCompatibilityFiller.cc.

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

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

◆ combinedCosmicID()

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 460 of file MuonCosmicCompatibilityFiller.cc.

References backToBack2LegCosmic(), eventActivity(), iEvent, isOverlappingMuon(), muonTiming(), pvMatches(), and mps_fire::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;
 }

◆ eventActivity()

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 560 of file MuonCosmicCompatibilityFiller.cc.

References iEvent, createfilelist::int, maxvertRho_, maxvertZ_, minvProb_, edm::Handle< T >::product(), mps_fire::result, DiMuonV_cfg::tracks, trackTokens_, vertexToken_, and AlignmentTracksFromVertexSelector_cfi::vertices.

Referenced by combinedCosmicID(), and fillCompatibility().

                                                                                                             {
   unsigned int result = 0;  //no good vertices - cosmic-like
 
   //check track activity
   edm::Handle<reco::TrackCollection> tracks;
   iEvent.getByToken(trackTokens_[0], tracks);
   if (!tracks.failedToGet() && tracks->size() < 3)
     return 0;
 
   //cosmic event should have zero good vertices
   edm::Handle<reco::VertexCollection> pvHandle;
   if (!iEvent.getByToken(vertexToken_, 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;
 }

◆ fillCompatibility()

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

fill cosmic compatibility variables

Definition at line 100 of file MuonCosmicCompatibilityFiller.cc.

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

Referenced by CosmicsMuonIdProducer::produce().

                                                                                                             {
   const std::string theCategory = "MuonCosmicCompatibilityFiller";
 
   reco::MuonCosmicCompatibility returnComp;
 
   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;
 }

◆ isOverlappingMuon()

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 256 of file MuonCosmicCompatibilityFiller.cc.

References cosmicToken_, MillePedeFileConverter_cfg::e, edm::HandleBase::failedToGet(), HLT_2023v12_cff::fraction, geometryToken_, edm::EventSetup::getHandle(), iEvent, edm::Ref< C, T, F >::isNonnull(), mag(), edm::Handle< T >::product(), sharedFrac_, sharedHits_, MuonServiceProxy::trackingGeometry(), vertexToken_, and AlignmentTracksFromVertexSelector_cfi::vertices.

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.getByToken(cosmicToken_, muonHandle);
 
   // Global Tracking Geometry
   ESHandle<GlobalTrackingGeometry> trackingGeometry = iSetup.getHandle(geometryToken_);
 
   // PV
   math::XYZPoint RefVtx;
   RefVtx.SetXYZ(0, 0, 0);
 
   edm::Handle<reco::VertexCollection> pvHandle;
   iEvent.getByToken(vertexToken_, 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();
 
       // shared hits
       int RecHitsMuon = outertrack->numberOfValidHits();
       int shared = 0;
       if (costrack.isNonnull()) {
         // unused
         //  bool isCosmic1Leg = false;
         //  bool isCloseIP = false;
         //  bool isCloseRef = false;
 
         if (outertrack.isNonnull()) {
           // step2
           //UNUSED:          const double ipErr = (double)outertrack->d0Error();
           //UNUSED:          double ipThreshold  = max(ipThreshold_, ipErr);
           //UNUSED:   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());
           //UNUSED:   float dist = (muonRefVtx - cosmicRefVtx).mag();
           //UNUSED:   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;
       if (shared > sharedHits_ && fraction > sharedFrac_) {
         overlappingMuon = true;
         break;
       }
     }
   }
 
   return overlappingMuon;
 }

◆ muonTiming()

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 127 of file MuonCosmicCompatibilityFiller.cc.

References corrTimeNeg_, corrTimePos_, edm::HandleBase::failedToGet(), iEvent, nano_mu_reco_cff::isLoose, edm::Ref< C, T, F >::isNonnull(), muonTokens_, nMuons(), offTimeNegLoose_, offTimeNegLooseMult_, offTimeNegTight_, offTimeNegTightMult_, offTimePosLoose_, offTimePosLooseMult_, offTimePosTight_, offTimePosTightMult_, pvMatches(), and mps_fire::result.

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.getByToken(muonTokens_[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;
 }

◆ nMuons()

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

private

get number of muons in the vent

Definition at line 236 of file MuonCosmicCompatibilityFiller.cc.

References edm::HandleBase::failedToGet(), iEvent, and muonTokens_.

Referenced by muonTiming(), and pvMatches().

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

◆ pvMatches()

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 353 of file MuonCosmicCompatibilityFiller.cc.

References edm::HandleBase::failedToGet(), hIpTrdxy_, hIpTrvProb_, iEvent, createfilelist::int, nano_mu_reco_cff::isLoose, largedxy_, largedxyMult_, maxdxyLoose_, maxdxyLooseMult_, maxdxyTight_, maxdxyTightMult_, maxdzLoose_, maxdzLooseMult_, maxdzTight_, maxdzTightMult_, DiMuonV_cfg::muons, muonTokens_, nMuons(), edm::Handle< T >::product(), mps_fire::result, HLT_2023v12_cff::track, DiMuonV_cfg::tracks, vertexToken_, and AlignmentTracksFromVertexSelector_cfi::vertices.

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() || muon.isRPCMuon())
     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.getByToken(vertexToken_, 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.getByToken(muonTokens_[1], muonHandle);
 
     //cosmic event should have zero good vertices
     edm::Handle<reco::VertexCollection> pvHandle;
     iEvent.getByToken(vertexToken_, 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;
 }