#include <MuScleFitMuonSelector.h>

Public Member Functions
const reco::Candidate *	getStatus1Muon (const reco::Candidate *status3Muon)

const reco::Candidate *	getStatus3Muon (const reco::Candidate *status3Muon)

	MuScleFitMuonSelector (edm::ConsumesCollector &iC, 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)

void	selectMuons (const edm::Event &event, std::vector< MuScleFitMuon > &muons, std::vector< GenMuonPair > &genPair, std::vector< std::pair< lorentzVector, lorentzVector > > &simPair, MuScleFitPlotter *plotter)
	Main method used to select muons of type specified by muonType_ from the collection specified by muonLabel_ and PATmuons_. More...

	~MuScleFitMuonSelector ()=default

Protected Member Functions
template<typename T >
std::vector< MuScleFitMuon >	fillMuonCollection (const std::vector< T > &tracks)
	Template function used to convert the muon collection to a vector of reco::LeafCandidate. More...

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)
	For PATmuons the generator information is read directly from the PAT object. More...

void	selectGenSimMuons (const edm::Event &event, std::vector< GenMuonPair > &genPair, std::vector< std::pair< lorentzVector, lorentzVector > > &simPair, MuScleFitPlotter *plotter)

void	selectSimulatedMuons (const edm::Event &event, const bool ifHepMC, edm::Handle< edm::HepMCProduct > evtMC, std::vector< std::pair< lorentzVector, lorentzVector > > &simPair, MuScleFitPlotter *plotter)

bool	selGlobalMuon (const pat::Muon *aMuon)
	Apply the Onia cuts to select globalMuons. More...

bool	selTrackerMuon (const pat::Muon *aMuon)
	Apply the Onia cuts to select trackerMuons. More...

template<typename T >
void	takeSelectedMuonType (const T &muon, std::vector< reco::Track > &tracks)
	Template function used to extract the selected muon type from the muon collection. More...

Protected Attributes
const edm::EDGetTokenT< reco::CaloMuonCollection >	caloMuonToken_

const bool	compareToSimTracks_

const bool	debug_

const edm::EDGetTokenT< edm::HepMCProduct >	evtMCToken_

const std::string	genParticlesName_

const edm::EDGetTokenT< reco::GenParticleCollection >	genParticleToken_

const edm::InputTag	muonLabel_

const int	muonType_

const edm::EDGetTokenT< pat::CompositeCandidateCollection >	onia2MuMuToken_

const bool	PATmuons_

const edm::EDGetTokenT< pat::MuonCollection >	patMuonToken_

const edm::EDGetTokenT< reco::MuonCollection >	recoMuonToken_

const std::vector< int >	resfind_

const bool	sherpa_

const edm::InputTag	simTracksCollectionName_

const edm::EDGetTokenT< edm::SimTrackContainer >	simTrackToken_

const bool	speedup_

const edm::EDGetTokenT< reco::TrackCollection >	trackCollectionToken_

Static Protected Attributes
static const double	mMu2 = 0.011163612

static const unsigned int	motherPdgIdArray [6] = {23, 100553, 100553, 553, 100443, 443}

Detailed Description

Definition at line 30 of file MuScleFitMuonSelector.h.

Constructor & Destructor Documentation

◆ MuScleFitMuonSelector()

MuScleFitMuonSelector::MuScleFitMuonSelector	(	edm::ConsumesCollector &	iC,
		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
	)

inline

Definition at line 32 of file MuScleFitMuonSelector.h.

       : muonLabel_(muonLabel),
         muonType_(muonType),
         PATmuons_(PATmuons),
         resfind_(resfind),
         speedup_(speedup),
         genParticlesName_(genParticlesName),
         compareToSimTracks_(compareToSimTracks),
         simTracksCollectionName_(simTracksCollectionName),
         sherpa_(sherpa),
         debug_(debug),
         onia2MuMuToken_(iC.consumes<pat::CompositeCandidateCollection>(edm::InputTag("onia2MuMuPatTrkTrk"))),
         trackCollectionToken_(iC.consumes<reco::TrackCollection>(muonLabel_)),
         patMuonToken_(iC.consumes<pat::MuonCollection>(muonLabel_)),
         recoMuonToken_(iC.consumes<reco::MuonCollection>(muonLabel_)),
         caloMuonToken_(iC.consumes<reco::CaloMuonCollection>(muonLabel_)),
         evtMCToken_(iC.consumes<edm::HepMCProduct>(genParticlesName_)),
         genParticleToken_(iC.consumes<reco::GenParticleCollection>(genParticlesName_)),
         simTrackToken_(iC.consumes<edm::SimTrackContainer>(simTracksCollectionName_)) {}

◆ ~MuScleFitMuonSelector()

MuScleFitMuonSelector::~MuScleFitMuonSelector ( )

default

Member Function Documentation

◆ fillMuonCollection()

template<typename T >

std::vector<MuScleFitMuon> MuScleFitMuonSelector::fillMuonCollection ( const std::vector< T > & tracks )

inlineprotected

Template function used to convert the muon collection to a vector of reco::LeafCandidate.

Definition at line 104 of file MuScleFitMuonSelector.h.

References gather_cfg::cout, debug_, mMu2, amptDefaultParameters_cff::mu, HLT_2024v11_cff::muon, DiMuonV_cfg::muons, mathSSE::sqrt(), HLT_2024v11_cff::track, and DiMuonV_cfg::tracks.

Referenced by selectMuons().

                                                                           {
     std::vector<MuScleFitMuon> 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));
 
       Double_t hitsTk(0), hitsMuon(0), ptError(0);
       if (const reco::Muon* myMu = dynamic_cast<const reco::Muon*>(&(*track))) {
         hitsTk = myMu->innerTrack()->hitPattern().numberOfValidTrackerHits();
         hitsMuon = myMu->innerTrack()->hitPattern().numberOfValidMuonHits();
         ptError = myMu->innerTrack()->ptError();
       } else if (const pat::Muon* myMu = dynamic_cast<const pat::Muon*>(&(*track))) {
         hitsTk = myMu->innerTrack()->hitPattern().numberOfValidTrackerHits();
         hitsMuon = myMu->innerTrack()->hitPattern().numberOfValidMuonHits();
         ptError = myMu->innerTrack()->ptError();
       } else if (const reco::Track* myMu = dynamic_cast<const reco::Track*>(&(*track))) {
         hitsTk = myMu->hitPattern().numberOfValidTrackerHits();
         hitsMuon = myMu->hitPattern().numberOfValidMuonHits();
         ptError = myMu->ptError();
       }
 
       MuScleFitMuon muon(mu, track->charge(), ptError, hitsTk, hitsMuon);
 
       if (debug_ > 0) {
         std::cout << "[MuScleFitMuonSelector::fillMuonCollection] after MuScleFitMuon initialization" << std::endl;
         std::cout << "  muon = " << muon << std::endl;
       }
 
       muons.push_back(muon);
     }
     return muons;
   }

◆ findGenMuFromRes() [1/2]

GenMuonPair MuScleFitMuonSelector::findGenMuFromRes ( const reco::GenParticleCollection * genParticles )

protected

Definition at line 388 of file MuScleFitMuonSelector.cc.

References funct::abs(), gather_cfg::cout, debug_, AJJGenJetFilter_cfi::genParticles, getStatus1Muon(), GenMuonPair::motherId, motherPdgIdArray, GenMuonPair::mu1, GenMuonPair::mu2, reco::Candidate::p4(), and resfind_.

Referenced by selectGenSimMuons().

                                                                                                  {
   // std::pair<lorentzVector,lorentzVector> muFromRes;
   GenMuonPair muFromRes;
 
   //Loop on generated particles
   if (debug_ > 0)
     std::cout << "Starting loop on " << genParticles->size() << " genParticles" << std::endl;
   for (reco::GenParticleCollection::const_iterator part = genParticles->begin(); part != genParticles->end(); ++part) {
     if (debug_ > 0)
       std::cout << "genParticle has pdgId = " << std::abs(part->pdgId()) << " and status = " << part->status()
                 << std::endl;
     if (std::abs(part->pdgId()) == 13) {  // && part->status()==3) {
       bool fromRes = false;
       unsigned int motherPdgId = part->mother()->pdgId();
       if (debug_ > 0) {
         std::cout << "Found a muon with mother: " << motherPdgId << std::endl;
       }
       for (int ires = 0; ires < 6; ++ires) {
         // if( motherPdgId == motherPdgIdArray[ires] && resfind_[ires] ) fromRes = true; // changed by EM 2015.07.30
         // begin of comment
         // the list of resonances motherPdgIdArray does not contain the photon (PdgId = 21) while ~1% of the
         // mu+mu- events in the range [50,120] GeV has a photon as the mother.
         // It needs to be fixed without spoiling the logic of the selection of different resonances
         // e.g. mixing up onia etc.
         // end of comment
         if ((motherPdgId == motherPdgIdArray[ires] && resfind_[ires]) || motherPdgId == 21)
           fromRes = true;
       }
       if (fromRes) {
         if (debug_ > 0)
           std::cout << "fromRes = true, motherPdgId = " << motherPdgId << std::endl;
         const reco::Candidate* status3Muon = &(*part);
         const reco::Candidate* status1Muon = getStatus1Muon(status3Muon);
         if (part->pdgId() == 13) {
           if (status1Muon->p4().pt() != 0)
             muFromRes.mu1 = MuScleFitMuon(status1Muon->p4(), -1);
           else
             muFromRes.mu1 = MuScleFitMuon(status3Muon->p4(), -1);
           if (debug_ > 0)
             std::cout << "Found a genMuon - : " << muFromRes.mu1 << std::endl;
           //      muFromRes.first = (lorentzVector(status1Muon->p4().px(),status1Muon->p4().py(),
           //                       status1Muon->p4().pz(),status1Muon->p4().e()));
         } else {
           if (status1Muon->p4().pt() != 0)
             muFromRes.mu2 = MuScleFitMuon(status1Muon->p4(), +1);
           else
             muFromRes.mu2 = MuScleFitMuon(status3Muon->p4(), +1);
           if (debug_ > 0)
             std::cout << "Found a genMuon + : " << muFromRes.mu2 << std::endl;
           //      muFromRes.second = (lorentzVector(status1Muon->p4().px(),status1Muon->p4().py(),
           //                        status1Muon->p4().pz(),status1Muon->p4().e()));
         }
         muFromRes.motherId = motherPdgId;
       }
     }
   }
   return muFromRes;
 }

◆ findGenMuFromRes() [2/2]

GenMuonPair MuScleFitMuonSelector::findGenMuFromRes ( const edm::HepMCProduct * evtMC )

protected

Definition at line 346 of file MuScleFitMuonSelector.cc.

References funct::abs(), edm::HepMCProduct::GetEvent(), GenMuonPair::motherId, motherPdgIdArray, GenMuonPair::mu1, GenMuonPair::mu2, resfind_, and sherpa_.

                                                                                 {
   const HepMC::GenEvent* Evt = evtMC->GetEvent();
   GenMuonPair muFromRes;
   //Loop on generated particles
   for (HepMC::GenEvent::particle_const_iterator part = Evt->particles_begin(); part != Evt->particles_end(); part++) {
     if (std::abs((*part)->pdg_id()) == 13 && (*part)->status() == 1) {
       bool fromRes = false;
       unsigned int motherPdgId = 0;
       for (HepMC::GenVertex::particle_iterator mother = (*part)->production_vertex()->particles_begin(HepMC::ancestors);
            mother != (*part)->production_vertex()->particles_end(HepMC::ancestors);
            ++mother) {
         motherPdgId = (*mother)->pdg_id();
 
         // For sherpa the resonance is not saved. The muons from the resonance can be identified
         // by having as mother a muon of status 3.
         if (sherpa_) {
           if (motherPdgId == 13 && (*mother)->status() == 3)
             fromRes = true;
         } else {
           for (int ires = 0; ires < 6; ++ires) {
             if (motherPdgId == motherPdgIdArray[ires] && resfind_[ires])
               fromRes = true;
           }
         }
       }
       if (fromRes) {
         if ((*part)->pdg_id() == 13) {
           //   muFromRes.first = (*part)->momentum();
           muFromRes.mu1 = (lorentzVector(
               (*part)->momentum().px(), (*part)->momentum().py(), (*part)->momentum().pz(), (*part)->momentum().e()));
         } else {
           muFromRes.mu2 = (lorentzVector(
               (*part)->momentum().px(), (*part)->momentum().py(), (*part)->momentum().pz(), (*part)->momentum().e()));
         }
         muFromRes.motherId = motherPdgId;
       }
     }
   }
   return muFromRes;
 }

◆ findSimMuFromRes()

std::pair< lorentzVector, lorentzVector > MuScleFitMuonSelector::findSimMuFromRes	(	const edm::Handle< edm::HepMCProduct > &	evtMC,
		const edm::Handle< edm::SimTrackContainer > &	simTracks
	)

protected

Definition at line 447 of file MuScleFitMuonSelector.cc.

References funct::abs(), GenParticle::GenParticle, edm::HepMCProduct::GetEvent(), runTauDisplay::gp, motherPdgIdArray, resfind_, cscDigiValidation_cfi::simTrack, and TrackCandidateProducer_cfi::simTracks.

Referenced by selectSimulatedMuons().

                                                                                                {
   //Loop on simulated tracks
   std::pair<lorentzVector, lorentzVector> simMuFromRes;
   for (edm::SimTrackContainer::const_iterator simTrack = simTracks->begin(); simTrack != simTracks->end(); ++simTrack) {
     //Chose muons
     if (std::abs((*simTrack).type()) == 13) {
       //If tracks from IP than find mother
       if ((*simTrack).genpartIndex() > 0) {
         HepMC::GenParticle* gp = evtMC->GetEvent()->barcode_to_particle((*simTrack).genpartIndex());
         if (gp != nullptr) {
           for (HepMC::GenVertex::particle_iterator mother = gp->production_vertex()->particles_begin(HepMC::ancestors);
                mother != gp->production_vertex()->particles_end(HepMC::ancestors);
                ++mother) {
             bool fromRes = false;
             unsigned int motherPdgId = (*mother)->pdg_id();
             for (int ires = 0; ires < 6; ++ires) {
               if ((motherPdgId == motherPdgIdArray[ires] && resfind_[ires]) || motherPdgId == 21)
                 fromRes = true;
             }
             if (fromRes) {
               if (gp->pdg_id() == 13)
                 simMuFromRes.first = lorentzVector(simTrack->momentum().px(),
                                                    simTrack->momentum().py(),
                                                    simTrack->momentum().pz(),
                                                    simTrack->momentum().e());
               else
                 simMuFromRes.second = lorentzVector(simTrack->momentum().px(),
                                                     simTrack->momentum().py(),
                                                     simTrack->momentum().pz(),
                                                     simTrack->momentum().e());
             }
           }
         }
         // else LogDebug("MuScleFitUtils") << "WARNING: no matching genParticle found for simTrack" << std::endl;
       }
     }
   }
   return simMuFromRes;
 }

◆ getStatus1Muon()

const reco::Candidate * MuScleFitMuonSelector::getStatus1Muon ( const reco::Candidate * status3Muon )

Definition at line 9 of file MuScleFitMuonSelector.cc.

References reco::Candidate::daughter(), mps_fire::i, reco::Candidate::numberOfDaughters(), and reco::Candidate::pdgId().

Referenced by findGenMuFromRes().

                                                                                            {
   const reco::Candidate* tempMuon = status3Muon;
   //  bool lastCopy = (static_cast<const reco::GenParticle*>(tempMuon))->isLastCopy();                      //  isLastCopy() likely not enough robust
   bool isPromptFinalState = static_cast<const reco::GenParticle*>(tempMuon)
                                 ->isPromptFinalState();  //  pre-CMSSW_74X code: int status = tempStatus1Muon->status();
   while (tempMuon == nullptr || tempMuon->numberOfDaughters() != 0) {
     if (isPromptFinalState)
       break;  //  pre-CMSSW_74X code: if (status == 1) break;
     //std::vector<const reco::Candidate*> daughters;
     for (unsigned int i = 0; i < tempMuon->numberOfDaughters(); ++i) {
       if (tempMuon->daughter(i)->pdgId() == tempMuon->pdgId()) {
         tempMuon = tempMuon->daughter(i);
         isPromptFinalState = static_cast<const reco::GenParticle*>(tempMuon)
                                  ->isPromptFinalState();  //  pre-CMSSW_74X code: status = tempStatus1Muon->status();
         break;
       } else
         continue;
     }  //for loop
   }    //while loop
 
   return tempMuon;
 }

◆ getStatus3Muon()

const reco::Candidate * MuScleFitMuonSelector::getStatus3Muon ( const reco::Candidate * status3Muon )

Definition at line 32 of file MuScleFitMuonSelector.cc.

References reco::Candidate::daughter(), mps_fire::i, reco::Candidate::numberOfDaughters(), and reco::Candidate::pdgId().

                                                                                            {
   const reco::Candidate* tempMuon = status3Muon;
   bool lastCopy = static_cast<const reco::GenParticle*>(tempMuon)
                       ->isLastCopyBeforeFSR();  //  pre-CMSSW_74X code: int status = tempStatus1Muon->status();
   while (tempMuon == nullptr || tempMuon->numberOfDaughters() != 0) {
     if (lastCopy)
       break;  //  pre-CMSSW_74X code: if (status == 3) break;
     //std::vector<const reco::Candidate*> daughters;
     for (unsigned int i = 0; i < tempMuon->numberOfDaughters(); ++i) {
       if (tempMuon->daughter(i)->pdgId() == tempMuon->pdgId()) {
         tempMuon = tempMuon->daughter(i);
         lastCopy = static_cast<const reco::GenParticle*>(tempMuon)
                        ->isLastCopyBeforeFSR();  //  pre-CMSSW_74X code: status = tempStatus1Muon->status();
         break;
       } else
         continue;
     }  //for loop
   }    //while loop
 
   return tempMuon;
 }

◆ selectGeneratedMuons()

void MuScleFitMuonSelector::selectGeneratedMuons	(	const edm::Handle< pat::CompositeCandidateCollection > &	collAll,
		const std::vector< const pat::Muon *> &	collMuSel,
		std::vector< GenMuonPair > &	genPair,
		MuScleFitPlotter *	plotter
	)

protected

For PATmuons the generator information is read directly from the PAT object.

Definition at line 232 of file MuScleFitMuonSelector.cc.

References gather_cfg::cout, debug_, edm::Ref< C, T, F >::get(), edm::Ref< C, T, F >::isAvailable(), trackerHitRTTI::isMatched(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, objects.autophobj::motherId, and mkLumiAveragedPlots::plotter.

                                                                             {
   reco::GenParticleCollection genPatParticles{};
 
   //explicitly for JPsi but can be adapted!!!!!
   for (std::vector<pat::CompositeCandidate>::const_iterator it = collAll->begin(); it != collAll->end(); ++it) {
     reco::GenParticleRef genJpsi = it->genParticleRef();
     bool isMatched = (genJpsi.isAvailable() && genJpsi->pdgId() == 443);
     if (isMatched) {
       genPatParticles.push_back(*genJpsi.get());
     }
   }
 
   if (collMuSel.size() == 2) {
     reco::GenParticleRef genMu1 = collMuSel[0]->genParticleRef();
     reco::GenParticleRef genMu2 = collMuSel[1]->genParticleRef();
     bool isMuMatched = (genMu1.isAvailable() && genMu2.isAvailable() && genMu1->pdgId() * genMu2->pdgId() == -169);
     if (isMuMatched) {
       genPatParticles.push_back(*genMu1.get());
       genPatParticles.push_back(*genMu2.get());
 
       unsigned int motherId = 0;
       if (genMu1->mother() != nullptr) {
         motherId = genMu1->mother()->pdgId();
       }
       if (genMu1->pdgId() == 13)
         genPair.push_back(GenMuonPair(genMu1.get()->p4(), genMu2.get()->p4(), motherId));
       else
         // genPair.push_back(std::make_pair(genMu2.get()->p4(),genMu1.get()->p4()) );
         genPair.push_back(GenMuonPair(genMu2.get()->p4(), genMu1.get()->p4(), motherId));
 
       plotter->fillGen(genPatParticles, true);
 
       if (debug_ > 0)
         std::cout << "Found genParticles in PAT" << std::endl;
     } else {
       std::cout << "No recomuon selected so no access to generated info" << std::endl;
       // Fill it in any case, otherwise it will not be in sync with the event number
       // genPair.push_back( std::make_pair( lorentzVector(0.,0.,0.,0.), lorentzVector(0.,0.,0.,0.) ) );
       genPair.push_back(GenMuonPair(lorentzVector(0., 0., 0., 0.), lorentzVector(0., 0., 0., 0.), 0));
     }
   } else {
     std::cout << "No recomuon selected so no access to generated info" << std::endl;
     // Fill it in any case, otherwise it will not be in sync with the event number
     // genPair.push_back( std::make_pair( lorentzVector(0.,0.,0.,0.), lorentzVector(0.,0.,0.,0.) ) );
     genPair.push_back(GenMuonPair(lorentzVector(0., 0., 0., 0.), lorentzVector(0., 0., 0., 0.), 0));
   }
   if (debug_ > 0) {
     std::cout << "genParticles:" << std::endl;
     // std::cout << genPair.back().first << " , " << genPair.back().second << std::endl;
     std::cout << genPair.back().mu1 << " , " << genPair.back().mu2 << std::endl;
   }
 }

◆ selectGenSimMuons()

void MuScleFitMuonSelector::selectGenSimMuons	(	const edm::Event &	event,
		std::vector< GenMuonPair > &	genPair,
		std::vector< std::pair< lorentzVector, lorentzVector > > &	simPair,
		MuScleFitPlotter *	plotter
	)

protected

Definition at line 288 of file MuScleFitMuonSelector.cc.

References gather_cfg::cout, debug_, evtMCToken_, findGenMuFromRes(), AJJGenJetFilter_cfi::genParticles, genParticleToken_, edm::HandleBase::isValid(), mkLumiAveragedPlots::plotter, edm::Handle< T >::product(), selectSimulatedMuons(), and sherpa_.

Referenced by selectMuons().

                                                                          {
   // Find and store in histograms the generated and simulated resonance and muons
   // ----------------------------------------------------------------------------
   edm::Handle<edm::HepMCProduct> evtMC = event.getHandle(evtMCToken_);
   edm::Handle<reco::GenParticleCollection> genParticles = event.getHandle(genParticleToken_);
 
   // Fill gen information only in the first loop
   bool ifHepMC = false;
   if (evtMC.isValid()) {
     genPair.push_back(findGenMuFromRes(evtMC.product()));
     plotter->fillGen(*evtMC, sherpa_);
     ifHepMC = true;
     if (debug_ > 0)
       std::cout << "Found hepMC" << std::endl;
   } else if (genParticles.isValid()) {
     genPair.push_back(findGenMuFromRes(genParticles.product()));
     plotter->fillGen(*genParticles);
     if (debug_ > 0)
       std::cout << "Found genParticles" << std::endl;
   } else {
     std::cout << "ERROR "
               << "non generation info and speedup true!!!!!!!!!!!!" << std::endl;
     // Fill it in any case, otherwise it will not be in sync with the event number
     // genPair.push_back( std::make_pair( lorentzVector(0.,0.,0.,0.), lorentzVector(0.,0.,0.,0.) ) );
     genPair.push_back(GenMuonPair(lorentzVector(0., 0., 0., 0.), lorentzVector(0., 0., 0., 0.), 0));
   }
   if (debug_ > 0) {
     std::cout << "genParticles:" << std::endl;
     std::cout << genPair.back().mu1 << " , " << genPair.back().mu2 << std::endl;
   }
   selectSimulatedMuons(event, ifHepMC, evtMC, simPair, plotter);
 }

◆ selectMuons()

void MuScleFitMuonSelector::selectMuons	(	const edm::Event &	event,
		std::vector< MuScleFitMuon > &	muons,
		std::vector< GenMuonPair > &	genPair,
		std::vector< std::pair< lorentzVector, lorentzVector > > &	simPair,
		MuScleFitPlotter *	plotter
	)

Main method used to select muons of type specified by muonType_ from the collection specified by muonLabel_ and PATmuons_.

Definition at line 85 of file MuScleFitMuonSelector.cc.

References allMuons_cfi::allMuons, mergedMuons_cfi::caloMuons, caloMuonToken_, reco::LeafCandidate::charge(), gather_cfg::cout, fillMuonCollection(), pat::Muon::innerTrack(), reco::Muon::isGlobalMuon(), reco::Muon::isTrackerMuon(), edm::HandleBase::isValid(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, HLT_2024v11_cff::muon, DiMuonV_cfg::muons, muonType_, onia2MuMuToken_, PATmuons_, patMuonToken_, mkLumiAveragedPlots::plotter, recoMuonToken_, selectGenSimMuons(), selGlobalMuon(), selTrackerMuon(), speedup_, takeSelectedMuonType(), trackCollectionToken_, and DiMuonV_cfg::tracks.

                                                                    {
   edm::Handle<pat::CompositeCandidateCollection> collAll = event.getHandle(onia2MuMuToken_);
   if (!collAll.isValid()) {
     edm::LogWarning("MuScleFitUtils") << "J/psi not present in event!";
   }
   std::vector<const pat::Muon*> collMuSel;
 
   //================onia cuts===========================/
 
   if (muonType_ <= -1 && PATmuons_) {
     std::vector<const pat::CompositeCandidate*> collSelGG;
     std::vector<const pat::CompositeCandidate*> collSelGT;
     std::vector<const pat::CompositeCandidate*> collSelTT;
     if (collAll.isValid()) {
       for (std::vector<pat::CompositeCandidate>::const_iterator it = collAll->begin(); it != collAll->end(); ++it) {
         const pat::CompositeCandidate* cand = &(*it);
         // cout << "Now checking candidate of type " << theJpsiCat << " with pt = " << cand->pt() << endl;
         const pat::Muon* muon1 = dynamic_cast<const pat::Muon*>(cand->daughter("muon1"));
         const pat::Muon* muon2 = dynamic_cast<const pat::Muon*>(cand->daughter("muon2"));
 
         if ((muon1->charge() * muon2->charge()) > 0)
           continue;
         // global + global?
         if (muon1->isGlobalMuon() && muon2->isGlobalMuon()) {
           if (selGlobalMuon(muon1) && selGlobalMuon(muon2) && cand->userFloat("vProb") > 0.001) {
             collSelGG.push_back(cand);
             continue;
           }
         }
         // global + tracker? (x2)
         if (muon1->isGlobalMuon() && muon2->isTrackerMuon()) {
           if (selGlobalMuon(muon1) && selTrackerMuon(muon2) && cand->userFloat("vProb") > 0.001) {
             collSelGT.push_back(cand);
             continue;
           }
         }
         if (muon2->isGlobalMuon() && muon1->isTrackerMuon()) {
           if (selGlobalMuon(muon2) && selTrackerMuon(muon1) && cand->userFloat("vProb") > 0.001) {
             collSelGT.push_back(cand);
             continue;
           }
         }
         // tracker + tracker?
         if (muon1->isTrackerMuon() && muon2->isTrackerMuon()) {
           if (selTrackerMuon(muon1) && selTrackerMuon(muon2) && cand->userFloat("vProb") > 0.001) {
             collSelTT.push_back(cand);
             continue;
           }
         }
       }
     }
     // Split them in independent collections if using muonType_ == -2, -3 or -4. Take them all if muonType_ == -1.
     std::vector<reco::Track> tracks;
     if (!collSelGG.empty()) {
       //CHECK THAT THEY ARE ORDERED BY PT !!!!!!!!!!!!!!!!!!!!!!!
       const pat::Muon* muon1 = dynamic_cast<const pat::Muon*>(collSelGG[0]->daughter("muon1"));
       const pat::Muon* muon2 = dynamic_cast<const pat::Muon*>(collSelGG[0]->daughter("muon2"));
       if (muonType_ == -1 || muonType_ == -2) {
         tracks.push_back(*(muon1->innerTrack()));
         tracks.push_back(*(muon2->innerTrack()));
         collMuSel.push_back(muon1);
         collMuSel.push_back(muon2);
       }
     } else if (collSelGG.empty() && !collSelGT.empty()) {
       //CHECK THAT THEY ARE ORDERED BY PT !!!!!!!!!!!!!!!!!!!!!!!
       const pat::Muon* muon1 = dynamic_cast<const pat::Muon*>(collSelGT[0]->daughter("muon1"));
       const pat::Muon* muon2 = dynamic_cast<const pat::Muon*>(collSelGT[0]->daughter("muon2"));
       if (muonType_ == -1 || muonType_ == -3) {
         tracks.push_back(*(muon1->innerTrack()));
         tracks.push_back(*(muon2->innerTrack()));
         collMuSel.push_back(muon1);
         collMuSel.push_back(muon2);
       }
     } else if (collSelGG.empty() && collSelGT.empty() && !collSelTT.empty()) {
       //CHECK THAT THEY ARE ORDERED BY PT !!!!!!!!!!!!!!!!!!!!!!!
       const pat::Muon* muon1 = dynamic_cast<const pat::Muon*>(collSelTT[0]->daughter("muon1"));
       const pat::Muon* muon2 = dynamic_cast<const pat::Muon*>(collSelTT[0]->daughter("muon2"));
       if (muonType_ == -1 || muonType_ == -4) {
         tracks.push_back(*(muon1->innerTrack()));
         tracks.push_back(*(muon2->innerTrack()));
         collMuSel.push_back(muon1);
         collMuSel.push_back(muon2);
       }
     }
     if (tracks.size() != 2 && !tracks.empty()) {
       std::cout << "ERROR strange number of muons selected by onia cuts!" << std::endl;
       abort();
     }
     muons = fillMuonCollection(tracks);
   } else if ((muonType_ < 4 && muonType_ >= 0) || muonType_ >= 10) {  // Muons (glb,sta,trk)
     std::vector<reco::Track> tracks;
     if (PATmuons_ == true) {
       edm::Handle<pat::MuonCollection> allMuons = event.getHandle(patMuonToken_);
       if (muonType_ == 0) {
         // Take directly the muon
         muons = fillMuonCollection(*allMuons);
       } else {
         for (std::vector<pat::Muon>::const_iterator muon = allMuons->begin(); muon != allMuons->end(); ++muon) {
           //std::cout<<"pat muon is global "<<muon->isGlobalMuon()<<std::endl;
           takeSelectedMuonType(muon, tracks);
         }
         muons = fillMuonCollection(tracks);
       }
     } else {
       edm::Handle<reco::MuonCollection> allMuons = event.getHandle(recoMuonToken_);
       if (muonType_ == 0) {
         // Take directly the muon
         muons = fillMuonCollection(*allMuons);
       } else {
         for (std::vector<reco::Muon>::const_iterator muon = allMuons->begin(); muon != allMuons->end(); ++muon) {
           takeSelectedMuonType(muon, tracks);
         }
         muons = fillMuonCollection(tracks);
       }
     }
   } else if (muonType_ == 4) {  //CaloMuons
     edm::Handle<reco::CaloMuonCollection> caloMuons = event.getHandle(caloMuonToken_);
     std::vector<reco::Track> tracks;
     for (std::vector<reco::CaloMuon>::const_iterator muon = caloMuons->begin(); muon != caloMuons->end(); ++muon) {
       tracks.push_back(*(muon->track()));
     }
     muons = fillMuonCollection(tracks);
   }
 
   else if (muonType_ == 5) {  // Inner tracker tracks
     edm::Handle<reco::TrackCollection> tracks = event.getHandle(trackCollectionToken_);
     muons = fillMuonCollection(*tracks);
   }
   plotter->fillRec(muons);
 
   // Generation and simulation part
   if (speedup_ == false) {
     if (PATmuons_) {
       // EM 2015.04.02 temporary fix to run on MINIAODSIM (which contains PAT muons) but not the "onia2MuMuPatTrkTrk" collection
       // selectGeneratedMuons(collAll, collMuSel, genPair, plotter);
       selectGenSimMuons(event, genPair, simPair, plotter);
     } else {
       selectGenSimMuons(event, genPair, simPair, plotter);
     }
   }
 }

◆ selectSimulatedMuons()

void MuScleFitMuonSelector::selectSimulatedMuons	(	const edm::Event &	event,
		const bool	ifHepMC,
		edm::Handle< edm::HepMCProduct >	evtMC,
		std::vector< std::pair< lorentzVector, lorentzVector > > &	simPair,
		MuScleFitPlotter *	plotter
	)

protected

Definition at line 324 of file MuScleFitMuonSelector.cc.

References gather_cfg::cout, findSimMuFromRes(), mkLumiAveragedPlots::plotter, TrackCandidateProducer_cfi::simTracks, and simTrackToken_.

Referenced by selectGenSimMuons().

                                                                             {
   edm::Handle<edm::SimTrackContainer> simTracks = event.getHandle(simTrackToken_);
   bool simTracksFound = false;
   if (simTracks.isValid()) {
     plotter->fillSim(simTracks);
     if (ifHepMC) {
       simPair.push_back(findSimMuFromRes(evtMC, simTracks));
       simTracksFound = true;
       plotter->fillGenSim(evtMC, simTracks);
     }
   } else {
     std::cout << "SimTracks not existent" << std::endl;
   }
   if (!simTracksFound) {
     simPair.push_back(std::make_pair(lorentzVector(0., 0., 0., 0.), lorentzVector(0., 0., 0., 0.)));
   }
 }

◆ selGlobalMuon()

bool MuScleFitMuonSelector::selGlobalMuon ( const pat::Muon * aMuon )

protected

Apply the Onia cuts to select globalMuons.

Definition at line 54 of file MuScleFitMuonSelector.cc.

References funct::abs(), pat::Muon::globalTrack(), pat::Muon::innerTrack(), pat::Muon::muonID(), AlCaHLTBitMon_ParallelJobs::p, and submitPVResolutionJobs::q.

Referenced by selectMuons().

                                                               {
   reco::TrackRef iTrack = aMuon->innerTrack();
   const reco::HitPattern& p = iTrack->hitPattern();
 
   reco::TrackRef gTrack = aMuon->globalTrack();
   const reco::HitPattern& q = gTrack->hitPattern();
 
   return (  //isMuonInAccept(aMuon) &&// no acceptance cuts!
       iTrack->found() > 11 && gTrack->chi2() / gTrack->ndof() < 20.0 && q.numberOfValidMuonHits() > 0 &&
       iTrack->chi2() / iTrack->ndof() < 4.0 && aMuon->muonID("TrackerMuonArbitrated") &&
       aMuon->muonID("TMLastStationAngTight") && p.pixelLayersWithMeasurement() > 1 &&
       std::abs(iTrack->dxy()) < 3.0 &&  //should be done w.r.t. PV!
       std::abs(iTrack->dz()) < 15.0     //should be done w.r.t. PV!
   );
 }

◆ selTrackerMuon()

bool MuScleFitMuonSelector::selTrackerMuon ( const pat::Muon * aMuon )

protected

Apply the Onia cuts to select trackerMuons.

Definition at line 70 of file MuScleFitMuonSelector.cc.

References funct::abs(), pat::Muon::innerTrack(), pat::Muon::muonID(), and AlCaHLTBitMon_ParallelJobs::p.

Referenced by selectMuons().

                                                                {
   reco::TrackRef iTrack = aMuon->innerTrack();
   const reco::HitPattern& p = iTrack->hitPattern();
 
   return (  //isMuonInAccept(aMuon) // no acceptance cuts!
       iTrack->found() > 11 && iTrack->chi2() / iTrack->ndof() < 4.0 && aMuon->muonID("TrackerMuonArbitrated") &&
       aMuon->muonID("TMLastStationAngTight") && p.pixelLayersWithMeasurement() > 1 &&
       std::abs(iTrack->dxy()) < 3.0 &&  //should be done w.r.t. PV!
       std::abs(iTrack->dz()) < 15.0     //should be done w.r.t. PV!
   );
 }

◆ takeSelectedMuonType()

template<typename T >

void MuScleFitMuonSelector::takeSelectedMuonType	(	const T &	muon,
		std::vector< reco::Track > &	tracks
	)

inlineprotected

Template function used to extract the selected muon type from the muon collection.

Definition at line 140 of file MuScleFitMuonSelector.h.

References muonType_, and DiMuonV_cfg::tracks.

Referenced by selectMuons().

                                                                          {
     // 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()));
   }

Member Data Documentation

◆ caloMuonToken_

const edm::EDGetTokenT<reco::CaloMuonCollection> MuScleFitMuonSelector::caloMuonToken_

protected

Definition at line 174 of file MuScleFitMuonSelector.h.

Referenced by selectMuons().

◆ compareToSimTracks_

const bool MuScleFitMuonSelector::compareToSimTracks_

protected

Definition at line 165 of file MuScleFitMuonSelector.h.

◆ debug_

const bool MuScleFitMuonSelector::debug_

protected

Definition at line 168 of file MuScleFitMuonSelector.h.

Referenced by fillMuonCollection(), findGenMuFromRes(), selectGeneratedMuons(), and selectGenSimMuons().

◆ evtMCToken_

const edm::EDGetTokenT<edm::HepMCProduct> MuScleFitMuonSelector::evtMCToken_

protected

Definition at line 175 of file MuScleFitMuonSelector.h.

Referenced by selectGenSimMuons().

◆ genParticlesName_

const std::string MuScleFitMuonSelector::genParticlesName_

protected

Definition at line 164 of file MuScleFitMuonSelector.h.

◆ genParticleToken_

const edm::EDGetTokenT<reco::GenParticleCollection> MuScleFitMuonSelector::genParticleToken_

protected

Definition at line 176 of file MuScleFitMuonSelector.h.

Referenced by selectGenSimMuons().

◆ mMu2

const double MuScleFitMuonSelector::mMu2 = 0.011163612

staticprotected

Definition at line 179 of file MuScleFitMuonSelector.h.

Referenced by fillMuonCollection().

◆ motherPdgIdArray

const unsigned int MuScleFitMuonSelector::motherPdgIdArray = {23, 100553, 100553, 553, 100443, 443}

staticprotected

Definition at line 180 of file MuScleFitMuonSelector.h.

Referenced by findGenMuFromRes(), and findSimMuFromRes().

◆ muonLabel_

const edm::InputTag MuScleFitMuonSelector::muonLabel_

protected

Definition at line 159 of file MuScleFitMuonSelector.h.

◆ muonType_

const int MuScleFitMuonSelector::muonType_

protected

Definition at line 160 of file MuScleFitMuonSelector.h.

Referenced by selectMuons(), and takeSelectedMuonType().

◆ onia2MuMuToken_

const edm::EDGetTokenT<pat::CompositeCandidateCollection> MuScleFitMuonSelector::onia2MuMuToken_

protected

Definition at line 170 of file MuScleFitMuonSelector.h.

Referenced by selectMuons().

◆ PATmuons_

const bool MuScleFitMuonSelector::PATmuons_

protected

Definition at line 161 of file MuScleFitMuonSelector.h.

Referenced by selectMuons().

◆ patMuonToken_

const edm::EDGetTokenT<pat::MuonCollection> MuScleFitMuonSelector::patMuonToken_

protected

Definition at line 172 of file MuScleFitMuonSelector.h.

Referenced by selectMuons().

◆ recoMuonToken_

const edm::EDGetTokenT<reco::MuonCollection> MuScleFitMuonSelector::recoMuonToken_

protected

Definition at line 173 of file MuScleFitMuonSelector.h.

Referenced by selectMuons().

◆ resfind_

const std::vector<int> MuScleFitMuonSelector::resfind_

protected

Definition at line 162 of file MuScleFitMuonSelector.h.

Referenced by findGenMuFromRes(), and findSimMuFromRes().

◆ sherpa_

const bool MuScleFitMuonSelector::sherpa_

protected

Definition at line 167 of file MuScleFitMuonSelector.h.

Referenced by findGenMuFromRes(), and selectGenSimMuons().

◆ simTracksCollectionName_

const edm::InputTag MuScleFitMuonSelector::simTracksCollectionName_

protected

Definition at line 166 of file MuScleFitMuonSelector.h.

◆ simTrackToken_

const edm::EDGetTokenT<edm::SimTrackContainer> MuScleFitMuonSelector::simTrackToken_

protected

Definition at line 177 of file MuScleFitMuonSelector.h.

Referenced by selectSimulatedMuons().

◆ speedup_

const bool MuScleFitMuonSelector::speedup_

protected

Definition at line 163 of file MuScleFitMuonSelector.h.

Referenced by selectMuons().

◆ trackCollectionToken_

const edm::EDGetTokenT<reco::TrackCollection> MuScleFitMuonSelector::trackCollectionToken_

protected

Definition at line 171 of file MuScleFitMuonSelector.h.

Referenced by selectMuons().

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MuScleFitMuonSelector()

◆ ~MuScleFitMuonSelector()

Member Function Documentation

◆ fillMuonCollection()

◆ findGenMuFromRes() [1/2]

◆ findGenMuFromRes() [2/2]

◆ findSimMuFromRes()

◆ getStatus1Muon()

◆ getStatus3Muon()

◆ selectGeneratedMuons()

◆ selectGenSimMuons()

◆ selectMuons()

◆ selectSimulatedMuons()

◆ selGlobalMuon()

◆ selTrackerMuon()

◆ takeSelectedMuonType()

Member Data Documentation

◆ caloMuonToken_

◆ compareToSimTracks_

◆ debug_

◆ evtMCToken_

◆ genParticlesName_

◆ genParticleToken_

◆ mMu2

◆ motherPdgIdArray

◆ muonLabel_

◆ muonType_

◆ onia2MuMuToken_

◆ PATmuons_

◆ patMuonToken_

◆ recoMuonToken_

◆ resfind_

◆ sherpa_

◆ simTracksCollectionName_

◆ simTrackToken_

◆ speedup_

◆ trackCollectionToken_