Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-07-03 00:42:46 

0001 //
0002 // modified & integrated by Giovanni Abbiendi
0003 // from code by Arun Luthra:
0004 // UserCode/luthra/MuonTrackSelector/src/MuonTrackSelector.cc
0005 //
0006 #include "DataFormats/CSCRecHit/interface/CSCSegmentCollection.h"
0007 #include "DataFormats/DTRecHit/interface/DTRecSegment4DCollection.h"
0008 #include "DataFormats/MuonDetId/interface/CSCDetId.h"
0009 #include "DataFormats/MuonDetId/interface/DTChamberId.h"
0010 #include "DataFormats/MuonDetId/interface/MuonSubdetId.h"
0011 #include "DataFormats/MuonReco/interface/Muon.h"
0012 #include "DataFormats/MuonReco/interface/MuonFwd.h"
0013 #include "DataFormats/MuonReco/interface/MuonSelectors.h"
0014 #include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
0015 #include "DataFormats/TrackReco/interface/Track.h"
0016 #include "DataFormats/TrackReco/interface/TrackFwd.h"
0017 #include "Geometry/Records/interface/TrackerTopologyRcd.h"
0018 #include "FWCore/Framework/interface/Event.h"
0019 #include "FWCore/Framework/interface/global/EDProducer.h"
0020 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0021 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0022 
0023 #include <algorithm>
0024 #include <sstream>
0025 #include <memory>
0026 
0027 class MuonTrackProducer : public edm::global::EDProducer<> {
0028 public:
0029   explicit MuonTrackProducer(const edm::ParameterSet &);
0030 
0031 private:
0032   void produce(edm::StreamID, edm::Event &, const edm::EventSetup &) const override;
0033 
0034   edm::EDGetTokenT<reco::MuonCollection> muonsToken;
0035   edm::EDGetTokenT<DTRecSegment4DCollection> inputDTRecSegment4DToken_;
0036   edm::EDGetTokenT<CSCSegmentCollection> inputCSCSegmentToken_;
0037   edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> ttopoToken_;
0038 
0039   std::vector<std::string> selectionTags;
0040   std::string trackType;
0041   bool ignoreMissingMuonCollection;
0042 };
0043 
0044 MuonTrackProducer::MuonTrackProducer(const edm::ParameterSet &parset)
0045     : muonsToken(consumes<reco::MuonCollection>(parset.getParameter<edm::InputTag>("muonsTag"))),
0046       inputDTRecSegment4DToken_(
0047           consumes<DTRecSegment4DCollection>(parset.getParameter<edm::InputTag>("inputDTRecSegment4DCollection"))),
0048       inputCSCSegmentToken_(
0049           consumes<CSCSegmentCollection>(parset.getParameter<edm::InputTag>("inputCSCSegmentCollection"))),
0050       ttopoToken_(esConsumes<TrackerTopology, TrackerTopologyRcd>()),
0051       selectionTags(parset.getParameter<std::vector<std::string>>("selectionTags")),
0052       trackType(parset.getParameter<std::string>("trackType")),
0053       ignoreMissingMuonCollection(parset.getUntrackedParameter<bool>("ignoreMissingMuonCollection", false)) {
0054   edm::LogVerbatim("MuonTrackProducer") << "constructing  MuonTrackProducer" << parset.dump();
0055   produces<reco::TrackCollection>();
0056   produces<reco::TrackExtraCollection>();
0057   produces<TrackingRecHitCollection>();
0058 }
0059 
0060 void MuonTrackProducer::produce(edm::StreamID, edm::Event &iEvent, const edm::EventSetup &iSetup) const {
0061   edm::Handle<reco::MuonCollection> muonCollectionH = iEvent.getHandle(muonsToken);
0062 
0063   std::unique_ptr<reco::TrackCollection> selectedTracks(new reco::TrackCollection);
0064   std::unique_ptr<reco::TrackExtraCollection> selectedTrackExtras(new reco::TrackExtraCollection());
0065   std::unique_ptr<TrackingRecHitCollection> selectedTrackHits(new TrackingRecHitCollection());
0066 
0067   if (ignoreMissingMuonCollection && !muonCollectionH.isValid()) {
0068     edm::LogVerbatim("MuonTrackProducer") << "\n ignoring missing muon collection.";
0069 
0070     iEvent.put(std::move(selectedTracks));
0071     iEvent.put(std::move(selectedTrackExtras));
0072     iEvent.put(std::move(selectedTrackHits));
0073 
0074   } else {
0075     const DTRecSegment4DCollection &dtSegmentCollection = iEvent.get(inputDTRecSegment4DToken_);
0076     const CSCSegmentCollection &cscSegmentCollection = iEvent.get(inputCSCSegmentToken_);
0077 
0078     const TrackerTopology &ttopo = iSetup.getData(ttopoToken_);
0079 
0080     //reco::TrackRefProd rTracks = iEvent.getRefBeforePut<reco::TrackCollection>();
0081     reco::TrackExtraRefProd rTrackExtras = iEvent.getRefBeforePut<reco::TrackExtraCollection>();
0082     TrackingRecHitRefProd rHits = iEvent.getRefBeforePut<TrackingRecHitCollection>();
0083 
0084     edm::Ref<reco::TrackExtraCollection>::key_type idx = 0;
0085     edm::Ref<reco::TrackExtraCollection>::key_type hidx = 0;
0086 
0087     edm::LogVerbatim("MuonTrackProducer") << "\nThere are " << dtSegmentCollection.size() << " DT segments.";
0088     unsigned int index_dt_segment = 0;
0089     for (DTRecSegment4DCollection::const_iterator segment = dtSegmentCollection.begin();
0090          segment != dtSegmentCollection.end();
0091          ++segment, index_dt_segment++) {
0092       LocalPoint segmentLocalPosition = segment->localPosition();
0093       LocalVector segmentLocalDirection = segment->localDirection();
0094       LocalError segmentLocalPositionError = segment->localPositionError();
0095       LocalError segmentLocalDirectionError = segment->localDirectionError();
0096       DetId geoid = segment->geographicalId();
0097       DTChamberId dtdetid = DTChamberId(geoid);
0098       int wheel = dtdetid.wheel();
0099       int station = dtdetid.station();
0100       int sector = dtdetid.sector();
0101 
0102       float segmentX = segmentLocalPosition.x();
0103       float segmentY = segmentLocalPosition.y();
0104       float segmentdXdZ = segmentLocalDirection.x() / segmentLocalDirection.z();
0105       float segmentdYdZ = segmentLocalDirection.y() / segmentLocalDirection.z();
0106       float segmentXerr = sqrt(segmentLocalPositionError.xx());
0107       float segmentYerr = sqrt(segmentLocalPositionError.yy());
0108       float segmentdXdZerr = sqrt(segmentLocalDirectionError.xx());
0109       float segmentdYdZerr = sqrt(segmentLocalDirectionError.yy());
0110 
0111       edm::LogVerbatim("MuonTrackProducer")
0112           << "\nDT segment index :" << index_dt_segment << "\nchamber Wh:" << wheel << ",St:" << station
0113           << ",Se:" << sector << "\nLocal Position (X,Y)=(" << segmentX << "," << segmentY << ") +/- (" << segmentXerr
0114           << "," << segmentYerr << "), "
0115           << "Local Direction (dXdZ,dYdZ)=(" << segmentdXdZ << "," << segmentdYdZ << ") +/- (" << segmentdXdZerr << ","
0116           << segmentdYdZerr << ")";
0117     }
0118 
0119     edm::LogVerbatim("MuonTrackProducer") << "\nThere are " << cscSegmentCollection.size() << " CSC segments.";
0120     unsigned int index_csc_segment = 0;
0121     for (CSCSegmentCollection::const_iterator segment = cscSegmentCollection.begin();
0122          segment != cscSegmentCollection.end();
0123          ++segment, index_csc_segment++) {
0124       LocalPoint segmentLocalPosition = segment->localPosition();
0125       LocalVector segmentLocalDirection = segment->localDirection();
0126       LocalError segmentLocalPositionError = segment->localPositionError();
0127       LocalError segmentLocalDirectionError = segment->localDirectionError();
0128 
0129       DetId geoid = segment->geographicalId();
0130       CSCDetId cscdetid = CSCDetId(geoid);
0131       int endcap = cscdetid.endcap();
0132       int station = cscdetid.station();
0133       int ring = cscdetid.ring();
0134       int chamber = cscdetid.chamber();
0135 
0136       float segmentX = segmentLocalPosition.x();
0137       float segmentY = segmentLocalPosition.y();
0138       float segmentdXdZ = segmentLocalDirection.x() / segmentLocalDirection.z();
0139       float segmentdYdZ = segmentLocalDirection.y() / segmentLocalDirection.z();
0140       float segmentXerr = sqrt(segmentLocalPositionError.xx());
0141       float segmentYerr = sqrt(segmentLocalPositionError.yy());
0142       float segmentdXdZerr = sqrt(segmentLocalDirectionError.xx());
0143       float segmentdYdZerr = sqrt(segmentLocalDirectionError.yy());
0144 
0145       edm::LogVerbatim("MuonTrackProducer")
0146           << "\nCSC segment index :" << index_csc_segment << "\nchamber Endcap:" << endcap << ",St:" << station
0147           << ",Ri:" << ring << ",Ch:" << chamber << "\nLocal Position (X,Y)=(" << segmentX << "," << segmentY
0148           << ") +/- (" << segmentXerr << "," << segmentYerr << "), "
0149           << "Local Direction (dXdZ,dYdZ)=(" << segmentdXdZ << "," << segmentdYdZ << ") +/- (" << segmentdXdZerr << ","
0150           << segmentdYdZerr << ")";
0151     }
0152 
0153     edm::LogVerbatim("MuonTrackProducer") << "\nThere are " << muonCollectionH->size() << " reco::Muons.";
0154     unsigned int muon_index = 0;
0155     for (reco::MuonCollection::const_iterator muon = muonCollectionH->begin(); muon != muonCollectionH->end();
0156          ++muon, muon_index++) {
0157       edm::LogVerbatim("MuonTrackProducer") << "\n******* muon index : " << muon_index;
0158 
0159       const bool isGoodResult =
0160           std::all_of(selectionTags.begin(), selectionTags.end(), [&muon](const std::string &name) {
0161             muon::SelectionType muonType = muon::selectionTypeFromString(name);
0162             return muon::isGoodMuon(*muon, muonType);
0163           });
0164 
0165       if (isGoodResult) {
0166         // new copy of Track
0167         reco::TrackRef trackref;
0168         bool addMatchedMuonSegments = false;
0169 
0170         if (trackType == "innerTrack") {
0171           if (muon->innerTrack().isNonnull())
0172             trackref = muon->innerTrack();
0173           else
0174             continue;
0175         } else if (trackType == "outerTrack") {
0176           if (muon->outerTrack().isNonnull())
0177             trackref = muon->outerTrack();
0178           else
0179             continue;
0180         } else if (trackType == "globalTrack") {
0181           if (muon->globalTrack().isNonnull())
0182             trackref = muon->globalTrack();
0183           else
0184             continue;
0185         } else if (trackType == "innerTrackPlusSegments") {
0186           if (muon->innerTrack().isNonnull()) {
0187             trackref = muon->innerTrack();
0188             addMatchedMuonSegments = true;
0189           } else
0190             continue;
0191         } else if (trackType == "rpcMuonTrack") {
0192           if (muon->innerTrack().isNonnull() && muon->isRPCMuon()) {
0193             trackref = muon->innerTrack();
0194           } else
0195             continue;
0196         } else if (trackType == "gemMuonTrack") {
0197           if (muon->innerTrack().isNonnull() && muon->isGEMMuon()) {
0198             trackref = muon->innerTrack();
0199           } else
0200             continue;
0201         } else if (trackType == "me0MuonTrack") {
0202           if (muon->innerTrack().isNonnull() && muon->isME0Muon()) {
0203             trackref = muon->innerTrack();
0204           } else
0205             continue;
0206         } else if (trackType == "tunepTrack") {
0207           if (muon->isGlobalMuon() && muon->tunePMuonBestTrack().isNonnull())
0208             trackref = muon->tunePMuonBestTrack();
0209           else
0210             continue;
0211         } else if (trackType == "pfTrack") {
0212           if (muon->isPFMuon() && muon->muonBestTrack().isNonnull())
0213             trackref = muon->muonBestTrack();
0214           else
0215             continue;
0216         } else if (trackType == "recomuonTrack") {
0217           if (muon->muonBestTrackType() != muon->tunePMuonBestTrackType())
0218             edm::LogVerbatim("MuonTrackProducer") << "\n *** PF != TuneP *** \n" << std::endl;
0219 
0220           edm::LogVerbatim("MuonTrackProducer") << "isGlobal     ? " << muon->isGlobalMuon() << std::endl;
0221           edm::LogVerbatim("MuonTrackProducer")
0222               << "isTracker    ? " << muon->isTrackerMuon() << ", isRPC ? " << muon->isRPCMuon() << ", isGEM ? "
0223               << muon->isGEMMuon() << ", isME0 ? " << muon->isME0Muon() << std::endl;
0224           edm::LogVerbatim("MuonTrackProducer") << "isStandAlone ? " << muon->isStandAloneMuon() << std::endl;
0225           edm::LogVerbatim("MuonTrackProducer") << "isCalo ? " << muon->isCaloMuon() << std::endl;
0226           edm::LogVerbatim("MuonTrackProducer") << "isPF         ? " << muon->isPFMuon() << std::endl << std::endl;
0227 
0228           edm::LogVerbatim("MuonTrackProducer")
0229               << " enum MuonTrackType {None, InnerTrack, OuterTrack, CombinedTrack, TPFMS, Picky, DYT }" << std::endl;
0230 
0231           edm::LogVerbatim("MuonTrackProducer")
0232               << "(muon) pt =   " << muon->pt() << ", eta = " << muon->eta() << ", phi = " << muon->phi() << std::endl;
0233 
0234           if (muon->muonBestTrack().isNonnull())
0235             edm::LogVerbatim("MuonTrackProducer")
0236                 << "(best) pt =   " << muon->muonBestTrack()->pt() << ", eta = " << muon->muonBestTrack()->eta()
0237                 << ", phi = " << muon->muonBestTrack()->phi()
0238                 << ", N mu hits = " << muon->muonBestTrack()->hitPattern().numberOfValidMuonHits()
0239                 << ", N trk hits = " << muon->muonBestTrack()->hitPattern().numberOfValidTrackerHits()
0240                 << ", MuonTrackType = " << muon->muonBestTrackType() << std::endl;
0241           if (muon->tunePMuonBestTrack().isNonnull())
0242             edm::LogVerbatim("MuonTrackProducer")
0243                 << "(tuneP) pt =  " << muon->tunePMuonBestTrack()->pt()
0244                 << ", eta = " << muon->tunePMuonBestTrack()->eta() << ", phi = " << muon->tunePMuonBestTrack()->phi()
0245                 << ", N mu hits = " << muon->tunePMuonBestTrack()->hitPattern().numberOfValidMuonHits()
0246                 << ", N trk hits = " << muon->tunePMuonBestTrack()->hitPattern().numberOfValidTrackerHits()
0247                 << ", MuonTrackType = " << muon->tunePMuonBestTrackType() << std::endl;
0248           if (muon->innerTrack().isNonnull())
0249             edm::LogVerbatim("MuonTrackProducer")
0250                 << "(inner) pt =  " << muon->innerTrack()->pt() << ", eta = " << muon->innerTrack()->eta()
0251                 << ", phi = " << muon->innerTrack()->phi()
0252                 << ", N trk hits = " << muon->innerTrack()->hitPattern().numberOfValidTrackerHits() << std::endl;
0253           if (muon->globalTrack().isNonnull())
0254             edm::LogVerbatim("MuonTrackProducer")
0255                 << "(global) pt = " << muon->globalTrack()->pt() << ", eta = " << muon->globalTrack()->eta()
0256                 << ", phi = " << muon->globalTrack()->phi()
0257                 << ", N mu hits = " << muon->globalTrack()->hitPattern().numberOfValidMuonHits()
0258                 << ", N trk hits = " << muon->globalTrack()->hitPattern().numberOfValidTrackerHits() << std::endl;
0259           if (muon->outerTrack().isNonnull())
0260             edm::LogVerbatim("MuonTrackProducer")
0261                 << "(outer) pt =  " << muon->outerTrack()->pt() << ", eta = " << muon->outerTrack()->eta()
0262                 << ", phi = " << muon->outerTrack()->phi()
0263                 << ", N mu hits = " << muon->outerTrack()->hitPattern().numberOfValidMuonHits() << std::endl;
0264           if (muon->tpfmsTrack().isNonnull())
0265             edm::LogVerbatim("MuonTrackProducer")
0266                 << "(tpfms) pt =  " << muon->tpfmsTrack()->pt() << ", eta = " << muon->tpfmsTrack()->eta()
0267                 << ", phi = " << muon->tpfmsTrack()->phi()
0268                 << ", N mu hits = " << muon->tpfmsTrack()->hitPattern().numberOfValidMuonHits()
0269                 << ", N trk hits = " << muon->tpfmsTrack()->hitPattern().numberOfValidTrackerHits() << std::endl;
0270           if (muon->pickyTrack().isNonnull())
0271             edm::LogVerbatim("MuonTrackProducer")
0272                 << "(picky) pt =  " << muon->pickyTrack()->pt() << ", eta = " << muon->pickyTrack()->eta()
0273                 << ", phi = " << muon->pickyTrack()->phi()
0274                 << ", N mu hits = " << muon->pickyTrack()->hitPattern().numberOfValidMuonHits()
0275                 << ", N trk hits = " << muon->pickyTrack()->hitPattern().numberOfValidTrackerHits() << std::endl;
0276           if (muon->dytTrack().isNonnull())
0277             edm::LogVerbatim("MuonTrackProducer")
0278                 << "(dyt) pt =    " << muon->dytTrack()->pt() << ", eta = " << muon->dytTrack()->eta()
0279                 << ", phi = " << muon->dytTrack()->phi()
0280                 << ", N mu hits = " << muon->dytTrack()->hitPattern().numberOfValidMuonHits()
0281                 << ", N trk hits = " << muon->dytTrack()->hitPattern().numberOfValidTrackerHits() << std::endl;
0282 
0283           if (muon->isGlobalMuon() && muon->globalTrack()->hitPattern().numberOfValidMuonHits() > 0)
0284             trackref = muon->globalTrack();
0285           else if (muon->isTrackerMuon()) {
0286             trackref = muon->innerTrack();
0287             addMatchedMuonSegments = true;
0288           } else if (muon->isPFMuon())
0289             trackref = muon->muonBestTrack();
0290           else if (muon->isStandAloneMuon())
0291             trackref = muon->outerTrack();
0292           else if (muon->isRPCMuon())
0293             trackref = muon->innerTrack();
0294           else if (muon->isGEMMuon())
0295             trackref = muon->innerTrack();
0296           else if (muon->isME0Muon())
0297             trackref = muon->innerTrack();
0298           else
0299             trackref = muon->muonBestTrack();
0300         }
0301 
0302         edm::LogVerbatim("MuonTrackProducer") << "\t *** Selected *** ";
0303         const reco::Track *trk = &(*trackref);
0304         // pointer to old track:
0305         std::unique_ptr<reco::Track> newTrk(new reco::Track(*trk));
0306 
0307         newTrk->setExtra(reco::TrackExtraRef(rTrackExtras, idx++));
0308         PropagationDirection seedDir = trk->seedDirection();
0309         // new copy of track Extras
0310         std::unique_ptr<reco::TrackExtra> newExtra(new reco::TrackExtra(trk->outerPosition(),
0311                                                                         trk->outerMomentum(),
0312                                                                         trk->outerOk(),
0313                                                                         trk->innerPosition(),
0314                                                                         trk->innerMomentum(),
0315                                                                         trk->innerOk(),
0316                                                                         trk->outerStateCovariance(),
0317                                                                         trk->outerDetId(),
0318                                                                         trk->innerStateCovariance(),
0319                                                                         trk->innerDetId(),
0320                                                                         seedDir));
0321 
0322         // new copy of the silicon hits; add hit refs to Extra and hits to hit
0323         // collection
0324 
0325         //      edm::LogVerbatim("MuonTrackProducer")<<"\n printing initial
0326         //      hit_pattern"; trk->hitPattern().print();
0327         unsigned int nHitsToAdd = 0;
0328         for (trackingRecHit_iterator iHit = trk->recHitsBegin(); iHit != trk->recHitsEnd(); iHit++) {
0329           TrackingRecHit *hit = (*iHit)->clone();
0330           selectedTrackHits->push_back(hit);
0331           ++nHitsToAdd;
0332         }
0333 
0334         if (addMatchedMuonSegments) {
0335           int wheel, station, sector;
0336           int endcap, /*station, */ ring, chamber;
0337 
0338           edm::LogVerbatim("MuonTrackProducer")
0339               << "Number of chambers: " << muon->matches().size()
0340               << ", arbitrated: " << muon->numberOfMatches(reco::Muon::SegmentAndTrackArbitration);
0341           unsigned int index_chamber = 0;
0342 
0343           for (std::vector<reco::MuonChamberMatch>::const_iterator chamberMatch = muon->matches().begin();
0344                chamberMatch != muon->matches().end();
0345                ++chamberMatch, index_chamber++) {
0346             std::stringstream chamberStr;
0347             chamberStr << "\nchamber index: " << index_chamber;
0348 
0349             int subdet = chamberMatch->detector();
0350             DetId did = chamberMatch->id;
0351 
0352             if (subdet == MuonSubdetId::DT) {
0353               DTChamberId dtdetid = DTChamberId(did);
0354               wheel = dtdetid.wheel();
0355               station = dtdetid.station();
0356               sector = dtdetid.sector();
0357               chamberStr << ", DT chamber Wh:" << wheel << ",St:" << station << ",Se:" << sector;
0358             } else if (subdet == MuonSubdetId::CSC) {
0359               CSCDetId cscdetid = CSCDetId(did);
0360               endcap = cscdetid.endcap();
0361               station = cscdetid.station();
0362               ring = cscdetid.ring();
0363               chamber = cscdetid.chamber();
0364               chamberStr << ", CSC chamber End:" << endcap << ",St:" << station << ",Ri:" << ring << ",Ch:" << chamber;
0365             }
0366 
0367             chamberStr << ", Number of segments: " << chamberMatch->segmentMatches.size();
0368             edm::LogVerbatim("MuonTrackProducer") << chamberStr.str();
0369 
0370             unsigned int index_segment = 0;
0371 
0372             for (std::vector<reco::MuonSegmentMatch>::const_iterator segmentMatch =
0373                      chamberMatch->segmentMatches.begin();
0374                  segmentMatch != chamberMatch->segmentMatches.end();
0375                  ++segmentMatch, index_segment++) {
0376               float segmentX = segmentMatch->x;
0377               float segmentY = segmentMatch->y;
0378               float segmentdXdZ = segmentMatch->dXdZ;
0379               float segmentdYdZ = segmentMatch->dYdZ;
0380               float segmentXerr = segmentMatch->xErr;
0381               float segmentYerr = segmentMatch->yErr;
0382               float segmentdXdZerr = segmentMatch->dXdZErr;
0383               float segmentdYdZerr = segmentMatch->dYdZErr;
0384 
0385               CSCSegmentRef segmentCSC = segmentMatch->cscSegmentRef;
0386               DTRecSegment4DRef segmentDT = segmentMatch->dtSegmentRef;
0387 
0388               bool segment_arbitrated_Ok = (segmentMatch->isMask(reco::MuonSegmentMatch::BestInChamberByDR) &&
0389                                             segmentMatch->isMask(reco::MuonSegmentMatch::BelongsToTrackByDR));
0390 
0391               std::string ARBITRATED(" ***Arbitrated Off*** ");
0392               if (segment_arbitrated_Ok)
0393                 ARBITRATED = " ***ARBITRATED OK*** ";
0394 
0395               if (subdet == MuonSubdetId::DT) {
0396                 edm::LogVerbatim("MuonTrackProducer")
0397                     << "\n\t segment index: " << index_segment << ARBITRATED << "\n\t  Local Position (X,Y)=("
0398                     << segmentX << "," << segmentY << ") +/- (" << segmentXerr << "," << segmentYerr << "), "
0399                     << "\n\t  Local Direction (dXdZ,dYdZ)=(" << segmentdXdZ << "," << segmentdYdZ << ") +/- ("
0400                     << segmentdXdZerr << "," << segmentdYdZerr << ")";
0401 
0402                 if (!segment_arbitrated_Ok)
0403                   continue;
0404 
0405                 if (segmentDT.get() != nullptr) {
0406                   const DTRecSegment4D *segment = segmentDT.get();
0407 
0408                   edm::LogVerbatim("MuonTrackProducer")
0409                       << "\t ===> MATCHING with DT segment with index = " << segmentDT.key();
0410 
0411                   if (segment->hasPhi()) {
0412                     const DTChamberRecSegment2D *phiSeg = segment->phiSegment();
0413                     std::vector<const TrackingRecHit *> phiHits = phiSeg->recHits();
0414                     for (std::vector<const TrackingRecHit *>::const_iterator ihit = phiHits.begin();
0415                          ihit != phiHits.end();
0416                          ++ihit) {
0417                       TrackingRecHit *seghit = (*ihit)->clone();
0418                       newTrk->appendHitPattern(*seghit, ttopo);
0419                       //            edm::LogVerbatim("MuonTrackProducer")<<"hit
0420                       // pattern for position "<<index_hit<<" set to:";
0421                       //            newTrk->hitPattern().printHitPattern(index_hit,
0422                       // std::cout);
0423                       selectedTrackHits->push_back(seghit);
0424                       ++nHitsToAdd;
0425                     }
0426                   }
0427 
0428                   if (segment->hasZed()) {
0429                     const DTSLRecSegment2D *zSeg = (*segment).zSegment();
0430                     std::vector<const TrackingRecHit *> zedHits = zSeg->recHits();
0431                     for (std::vector<const TrackingRecHit *>::const_iterator ihit = zedHits.begin();
0432                          ihit != zedHits.end();
0433                          ++ihit) {
0434                       TrackingRecHit *seghit = (*ihit)->clone();
0435                       newTrk->appendHitPattern(*seghit, ttopo);
0436                       //            edm::LogVerbatim("MuonTrackProducer")<<"hit
0437                       // pattern for position "<<index_hit<<" set to:";
0438                       //            newTrk->hitPattern().printHitPattern(index_hit,
0439                       // std::cout);
0440                       selectedTrackHits->push_back(seghit);
0441                       ++nHitsToAdd;
0442                     }
0443                   }
0444                 } else
0445                   edm::LogWarning("MuonTrackProducer") << "\n***WARNING: UNMATCHED DT segment ! \n";
0446               }  // if (subdet == MuonSubdetId::DT)
0447 
0448               else if (subdet == MuonSubdetId::CSC) {
0449                 edm::LogVerbatim("MuonTrackProducer")
0450                     << "\n\t segment index: " << index_segment << ARBITRATED << "\n\t  Local Position (X,Y)=("
0451                     << segmentX << "," << segmentY << ") +/- (" << segmentXerr << "," << segmentYerr << "), "
0452                     << "\n\t  Local Direction (dXdZ,dYdZ)=(" << segmentdXdZ << "," << segmentdYdZ << ") +/- ("
0453                     << segmentdXdZerr << "," << segmentdYdZerr << ")";
0454 
0455                 if (!segment_arbitrated_Ok)
0456                   continue;
0457 
0458                 if (segmentCSC.get() != nullptr) {
0459                   const CSCSegment *segment = segmentCSC.get();
0460 
0461                   edm::LogVerbatim("MuonTrackProducer")
0462                       << "\t ===> MATCHING with CSC segment with index = " << segmentCSC.key();
0463 
0464                   std::vector<const TrackingRecHit *> hits = segment->recHits();
0465                   for (std::vector<const TrackingRecHit *>::const_iterator ihit = hits.begin(); ihit != hits.end();
0466                        ++ihit) {
0467                     TrackingRecHit *seghit = (*ihit)->clone();
0468                     newTrk->appendHitPattern(*seghit, ttopo);
0469                     //          edm::LogVerbatim("MuonTrackProducer")<<"hit
0470                     // pattern for position "<<index_hit<<" set to:";
0471                     //          newTrk->hitPattern().printHitPattern(index_hit,
0472                     // std::cout);
0473                     selectedTrackHits->push_back(seghit);
0474                     ++nHitsToAdd;
0475                   }
0476                 } else
0477                   edm::LogWarning("MuonTrackProducer") << "\n***WARNING: UNMATCHED CSC segment ! \n";
0478               }  //  else if (subdet == MuonSubdetId::CSC)
0479 
0480             }  // loop on vector<MuonSegmentMatch>
0481           }  // loop on vector<MuonChamberMatch>
0482         }  // if (trackType == "innerTrackPlusSegments")
0483 
0484         //      edm::LogVerbatim("MuonTrackProducer")<<"\n printing final
0485         //      hit_pattern"; newTrk->hitPattern().print();
0486 
0487         newExtra->setHits(rHits, hidx, nHitsToAdd);
0488         hidx += nHitsToAdd;
0489 
0490         selectedTracks->push_back(*newTrk);
0491         selectedTrackExtras->push_back(*newExtra);
0492 
0493       }  // if (isGoodResult)
0494     }  // loop on reco::MuonCollection
0495 
0496     iEvent.put(std::move(selectedTracks));
0497     iEvent.put(std::move(selectedTrackExtras));
0498     iEvent.put(std::move(selectedTrackHits));
0499   }
0500 }
0501 
0502 #include "FWCore/Framework/interface/MakerMacros.h"
0503 #include "FWCore/PluginManager/interface/ModuleDef.h"
0504 DEFINE_FWK_MODULE(MuonTrackProducer);
[ 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!