Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-04-06 12:18:38 

0001 // -*- C++ -*-
0002 //
0003 // Package:    HLTrigger/Muon
0004 // Class:      HLTScoutingMuonProducer
0005 //
0006 /**\class HLTScoutingMuonProducer HLTScoutingMuonProducer.cc HLTScoutingMuonProducer.cc
0007 
0008 Description: Producer for ScoutingMuon
0009 
0010 */
0011 //
0012 // Original Author:  David G. Sheffield (Rutgers)
0013 //         Created:  Fri, 31 Jul 2015
0014 //
0015 //
0016 
0017 #include "HLTScoutingMuonProducer.h"
0018 #include "DataFormats/Math/interface/deltaR.h"
0019 #include "TMath.h"
0020 
0021 //
0022 // constructors and destructor
0023 //
0024 HLTScoutingMuonProducer::HLTScoutingMuonProducer(const edm::ParameterSet& iConfig)
0025     : ChargedCandidateCollection_(
0026           consumes<reco::RecoChargedCandidateCollection>(iConfig.getParameter<edm::InputTag>("ChargedCandidates"))),
0027       displacedvertexCollection_(
0028           consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("displacedvertexCollection"))),
0029       MuonCollection_(consumes<reco::MuonCollection>(iConfig.getParameter<edm::InputTag>("InputMuons"))),
0030       linkToken_(consumes<reco::MuonTrackLinksCollection>(iConfig.getParameter<edm::InputTag>("InputLinks"))),
0031       TrackCollection_(consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("Tracks"))),
0032       EcalPFClusterIsoMap_(consumes<RecoChargedCandMap>(iConfig.getParameter<edm::InputTag>("EcalPFClusterIsoMap"))),
0033       HcalPFClusterIsoMap_(consumes<RecoChargedCandMap>(iConfig.getParameter<edm::InputTag>("HcalPFClusterIsoMap"))),
0034       TrackIsoMap_(consumes<edm::ValueMap<double>>(iConfig.getParameter<edm::InputTag>("TrackIsoMap"))),
0035       muonPtCut(iConfig.getParameter<double>("muonPtCut")),
0036       muonEtaCut(iConfig.getParameter<double>("muonEtaCut")),
0037       minVtxProbCut(iConfig.getParameter<double>("minVtxProbCut")) {
0038   //register products
0039   produces<Run3ScoutingMuonCollection>();
0040   produces<Run3ScoutingVertexCollection>("displacedVtx");
0041 }
0042 
0043 HLTScoutingMuonProducer::~HLTScoutingMuonProducer() = default;
0044 
0045 // ------------ method called to produce the data  ------------
0046 void HLTScoutingMuonProducer::produce(edm::StreamID sid, edm::Event& iEvent, edm::EventSetup const& setup) const {
0047   using namespace edm;
0048 
0049   std::unique_ptr<Run3ScoutingMuonCollection> outMuons(new Run3ScoutingMuonCollection());
0050   std::unique_ptr<Run3ScoutingVertexCollection> dispVertices(new Run3ScoutingVertexCollection());
0051 
0052   // Get RecoChargedCandidate
0053   Handle<reco::RecoChargedCandidateCollection> ChargedCandidateCollection;
0054   if (!iEvent.getByToken(ChargedCandidateCollection_, ChargedCandidateCollection)) {
0055     iEvent.put(std::move(outMuons));
0056     iEvent.put(std::move(dispVertices), "displacedVtx");
0057     return;
0058   }
0059 
0060   std::pair<reco::RecoChargedCandidate, reco::RecoChargedCandidate> ivtxMuPair;
0061   std::vector<std::pair<reco::RecoChargedCandidate, reco::RecoChargedCandidate>> vtxMuPair;
0062 
0063   //get displaced vertices
0064   Handle<reco::VertexCollection> displacedvertexCollection;
0065   if (iEvent.getByToken(displacedvertexCollection_, displacedvertexCollection)) {
0066     for (auto& dispvtx : *displacedvertexCollection) {
0067       if (!dispvtx.isValid())
0068         continue;
0069       float vtxProb = 0.0;
0070       if ((dispvtx.chi2() >= 0.0) && (dispvtx.ndof() > 0))
0071         vtxProb = TMath::Prob(dispvtx.chi2(), dispvtx.ndof());
0072       if (vtxProb < minVtxProbCut)
0073         continue;
0074 
0075       // Get the 2 tracks associated to displaced vertex
0076       auto trackIt = dispvtx.tracks_begin();
0077       reco::TrackRef vertextkRef1 = (*trackIt).castTo<reco::TrackRef>();
0078       trackIt++;
0079       reco::TrackRef vertextkRef2 = (*trackIt).castTo<reco::TrackRef>();
0080 
0081       // Get the muons associated with the tracks
0082       int iFoundRefs = 0;
0083       for (auto const& cand : *ChargedCandidateCollection) {
0084         reco::TrackRef tkRef = cand.get<reco::TrackRef>();
0085         if (tkRef == vertextkRef1) {
0086           ivtxMuPair.first = cand;
0087           iFoundRefs++;
0088         }
0089         if (tkRef == vertextkRef2) {
0090           ivtxMuPair.second = cand;
0091           iFoundRefs++;
0092         }
0093       }
0094       if (iFoundRefs < 2)
0095         continue;
0096       vtxMuPair.push_back(ivtxMuPair);
0097 
0098       dispVertices->emplace_back(dispvtx.x(),
0099                                  dispvtx.y(),
0100                                  dispvtx.z(),
0101                                  dispvtx.zError(),
0102                                  dispvtx.xError(),
0103                                  dispvtx.yError(),
0104                                  dispvtx.tracksSize(),
0105                                  dispvtx.chi2(),
0106                                  dispvtx.ndof(),
0107                                  dispvtx.isValid(),
0108                                  dispvtx.covariance(0, 1),
0109                                  dispvtx.covariance(0, 2),
0110                                  dispvtx.covariance(1, 2));
0111     }
0112   }
0113 
0114   // Get Muon collection
0115   Handle<reco::MuonCollection> MuonCollection;
0116   if (!iEvent.getByToken(MuonCollection_, MuonCollection)) {
0117     iEvent.put(std::move(outMuons));
0118     iEvent.put(std::move(dispVertices), "displacedVtx");
0119     return;
0120   }
0121 
0122   // Get Links collection
0123   edm::Handle<reco::MuonTrackLinksCollection> links;
0124   if (!iEvent.getByToken(linkToken_, links)) {
0125     iEvent.put(std::move(outMuons));
0126     iEvent.put(std::move(dispVertices), "displacedVtx");
0127     return;
0128   }
0129 
0130   // Get EcalPFClusterIsoMap
0131   Handle<RecoChargedCandMap> EcalPFClusterIsoMap;
0132   iEvent.getByToken(EcalPFClusterIsoMap_, EcalPFClusterIsoMap);
0133 
0134   // Get HcalPFClusterIsoMap
0135   Handle<RecoChargedCandMap> HcalPFClusterIsoMap;
0136   iEvent.getByToken(HcalPFClusterIsoMap_, HcalPFClusterIsoMap);
0137 
0138   // Get TrackIsoMap
0139   Handle<ValueMap<double>> TrackIsoMap;
0140   iEvent.getByToken(TrackIsoMap_, TrackIsoMap);
0141 
0142   // Produce muons
0143   std::vector<int> vtxInd;
0144   float minDR2 = 1e-06;
0145   int index = 0;
0146 
0147   for (auto& muon : *ChargedCandidateCollection) {
0148     reco::RecoChargedCandidateRef muonRef = getRef(ChargedCandidateCollection, index);
0149     ++index;
0150     if (muonRef.isNull() || !muonRef.isAvailable())
0151       continue;
0152 
0153     reco::TrackRef track = muon.track();
0154     if (track.isNull() || !track.isAvailable())
0155       continue;
0156 
0157     int validStandAloneMuonHits = 0;
0158     int matchedStandAloneMuonStations = 0;
0159     for (auto const& link : *links) {
0160       const reco::Track& trackerTrack = *link.trackerTrack();
0161       float dR2 = deltaR2(track->eta(), track->phi(), trackerTrack.eta(), trackerTrack.phi());
0162       float dPt = std::abs(track->pt() - trackerTrack.pt());
0163       if (track->pt() != 0)
0164         dPt = dPt / track->pt();
0165 
0166       if (dR2 < 0.02 * 0.02 and dPt < 0.001) {
0167         if (link.standAloneTrack().isNonnull()) {
0168           validStandAloneMuonHits = link.standAloneTrack()->hitPattern().numberOfValidMuonHits();
0169           matchedStandAloneMuonStations = link.standAloneTrack()->hitPattern().muonStationsWithValidHits();
0170         }
0171       }
0172     }
0173 
0174     unsigned int recoMuonType = 2;  // Global muon
0175     float normalizedChi2 = 999.0;
0176     int nRecoMuonValidMuonHits = 0;
0177     int nRecoMuonChambers = 0;
0178     int nRecoMuonChambersCSCorDT = 0;
0179     int nRecoMuonMatches = 0;
0180     int nRecoMuonMatchedStations = 0;
0181     unsigned int nRecoMuonExpectedMatchedStations = 0;
0182     unsigned int recoMuonStationMask = 0;
0183     int nRecoMuonMatchedRPCLayers = 0;
0184     unsigned int recoMuonRPClayerMask = 0;
0185     for (auto const& recoMu : *MuonCollection) {
0186       float dR2 = deltaR2(muon.eta(), muon.phi(), recoMu.eta(), recoMu.phi());
0187       float dPt = std::abs(muon.pt() - recoMu.pt());
0188       if (muon.pt() != 0)
0189         dPt = dPt / muon.pt();
0190 
0191       if (dR2 < 0.02 * 0.02 and dPt < 0.001) {
0192         if (recoMu.globalTrack().isNonnull()) {
0193           normalizedChi2 = recoMu.globalTrack()->normalizedChi2();
0194           nRecoMuonValidMuonHits = recoMu.globalTrack()->hitPattern().numberOfValidMuonHits();
0195         }
0196         recoMuonType = recoMu.type();
0197         nRecoMuonChambers = recoMu.numberOfChambers();
0198         nRecoMuonChambersCSCorDT = recoMu.numberOfChambersCSCorDT();
0199         nRecoMuonMatches = recoMu.numberOfMatches();
0200         nRecoMuonMatchedStations = recoMu.numberOfMatchedStations();
0201         nRecoMuonExpectedMatchedStations = recoMu.expectedNnumberOfMatchedStations();
0202         recoMuonStationMask = recoMu.stationMask();
0203         nRecoMuonMatchedRPCLayers = recoMu.numberOfMatchedRPCLayers();
0204         recoMuonRPClayerMask = recoMu.RPClayerMask();
0205       }
0206     }
0207 
0208     if (muon.pt() < muonPtCut)
0209       continue;
0210     if (fabs(muon.eta()) > muonEtaCut)
0211       continue;
0212 
0213     double ecalisopf = -1.0;
0214     if (EcalPFClusterIsoMap.isValid()) {
0215       ecalisopf = (*EcalPFClusterIsoMap)[muonRef];
0216     }
0217 
0218     double hcalisopf = -1.0;
0219     if (HcalPFClusterIsoMap.isValid()) {
0220       hcalisopf = (*HcalPFClusterIsoMap)[muonRef];
0221     }
0222 
0223     double trackiso = -1.0;
0224     if (TrackIsoMap.isValid()) {
0225       trackiso = (*TrackIsoMap)[muonRef];
0226     }
0227 
0228     vtxInd.reserve(vtxMuPair.size());
0229     for (unsigned int i = 0; i < vtxMuPair.size(); i++) {
0230       float dr2_1 = reco::deltaR2(((vtxMuPair[i]).first), muon);
0231       float dr2_2 = reco::deltaR2(((vtxMuPair[i]).second), muon);
0232       if ((dr2_1 < minDR2) || (dr2_2 < minDR2))
0233         vtxInd.push_back(i);
0234     }
0235 
0236     outMuons->emplace_back(muon.pt(),
0237                            muon.eta(),
0238                            muon.phi(),
0239                            muon.mass(),
0240                            recoMuonType,
0241                            track->charge(),
0242                            normalizedChi2,
0243                            ecalisopf,
0244                            hcalisopf,
0245                            trackiso,
0246                            validStandAloneMuonHits,
0247                            matchedStandAloneMuonStations,
0248                            nRecoMuonValidMuonHits,
0249                            nRecoMuonChambers,
0250                            nRecoMuonChambersCSCorDT,
0251                            nRecoMuonMatches,
0252                            nRecoMuonMatchedStations,
0253                            nRecoMuonExpectedMatchedStations,
0254                            recoMuonStationMask,
0255                            nRecoMuonMatchedRPCLayers,
0256                            recoMuonRPClayerMask,
0257                            track->hitPattern().numberOfValidPixelHits(),
0258                            track->hitPattern().numberOfValidStripHits(),
0259                            track->hitPattern().pixelLayersWithMeasurement(),
0260                            track->hitPattern().trackerLayersWithMeasurement(),
0261                            track->chi2(),
0262                            track->ndof(),
0263                            track->dxy(),
0264                            track->dz(),
0265                            track->qoverp(),
0266                            track->lambda(),
0267                            track->pt(),
0268                            track->phi(),
0269                            track->eta(),
0270                            track->dxyError(),
0271                            track->dzError(),
0272                            track->qoverpError(),
0273                            track->lambdaError(),
0274                            track->phiError(),
0275                            track->dsz(),
0276                            track->dszError(),
0277                            track->covariance(0, 1),
0278                            track->covariance(0, 2),
0279                            track->covariance(0, 3),
0280                            track->covariance(0, 4),
0281                            track->covariance(1, 2),
0282                            track->covariance(1, 3),
0283                            track->covariance(1, 4),
0284                            track->covariance(2, 3),
0285                            track->covariance(2, 4),
0286                            track->covariance(3, 4),
0287                            track->vx(),
0288                            track->vy(),
0289                            track->vz(),
0290                            vtxInd,
0291                            track->hitPattern().run3ScoutingHitPatternPOD());
0292     vtxInd.clear();
0293   }
0294 
0295   // Put output
0296   iEvent.put(std::move(outMuons));
0297   iEvent.put(std::move(dispVertices), "displacedVtx");
0298 }
0299 
0300 // ------------ method fills 'descriptions' with the allowed parameters for the module  ------------
0301 void HLTScoutingMuonProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0302   edm::ParameterSetDescription desc;
0303   desc.add<edm::InputTag>("ChargedCandidates", edm::InputTag("hltIterL3MuonCandidatesNoVtx"));
0304   desc.add<edm::InputTag>("displacedvertexCollection", edm::InputTag("hltDisplacedmumuVtxProducer"));
0305   desc.add<edm::InputTag>("InputMuons", edm::InputTag("hltIterL3MuonsNoVtx"));
0306   desc.add<edm::InputTag>("InputLinks", edm::InputTag("hltL3MuonsIterL3LinksNoVtx"));
0307   desc.add<edm::InputTag>("Tracks", edm::InputTag("hltPixelTracks"));
0308   desc.add<edm::InputTag>("EcalPFClusterIsoMap", edm::InputTag("hltMuonEcalMFPFClusterIsoForMuonsNoVtx"));
0309   desc.add<edm::InputTag>("HcalPFClusterIsoMap", edm::InputTag("hltMuonHcalPFClusterIsoForMuonsNoVtx"));
0310   desc.add<edm::InputTag>("TrackIsoMap",
0311                           edm::InputTag("hltMuonTkRelIsolationCut0p09MapNoVtx:combinedRelativeIsoDeposits"));
0312   desc.add<double>("muonPtCut", 3.0);
0313   desc.add<double>("muonEtaCut", 2.4);
0314   desc.add<double>("minVtxProbCut", 0.001);
0315 
0316   descriptions.add("hltScoutingMuonProducer", desc);
0317 }
0318 
0319 // declare this class as a framework plugin
0320 #include "FWCore/Framework/interface/MakerMacros.h"
0321 DEFINE_FWK_MODULE(HLTScoutingMuonProducer);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!