LST/plugins/LSTOutputConverter.cc

0001 #include "DataFormats/TrackerRecHit2D/interface/Phase2TrackerRecHit1D.h"
0002 #include "DataFormats/TrackerRecHit2D/interface/SiPixelRecHitCollection.h"
0003 #include "DataFormats/TrackCandidate/interface/TrackCandidateCollection.h"
0004 #include "DataFormats/TrackReco/interface/SeedStopInfo.h"
0005 #include "DataFormats/TrajectorySeed/interface/TrajectorySeedCollection.h"
0006 #include "FWCore/Framework/interface/stream/EDProducer.h"
0007 #include "FWCore/Framework/interface/Event.h"
0008 #include "FWCore/Framework/interface/MakerMacros.h"
0009 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0010 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0011 #include "FWCore/Utilities/interface/Exception.h"
0012 #include "Geometry/CommonDetUnit/interface/GeomDet.h"
0013 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
0014 #include "MagneticField/Engine/interface/MagneticField.h"
0015 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
0016 #include "RecoTracker/LST/interface/LSTPhase2OTHitsInput.h"
0017 #include "RecoTracker/LST/interface/LSTOutput.h"
0018 #include "RecoTracker/TkSeedingLayers/interface/SeedingHitSet.h"
0019
0020 #include "RecoTracker/TkSeedGenerator/interface/SeedCreator.h"
0021 #include "RecoTracker/TkSeedGenerator/interface/SeedCreatorFactory.h"
0022
0023 #include "RecoTracker/TkTrackingRegions/interface/GlobalTrackingRegion.h"
0024 #include "TrackingTools/GeomPropagators/interface/Propagator.h"
0025 #include "TrackingTools/Records/interface/TrackingComponentsRecord.h"
0026 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h"
0027
0028 class LSTOutputConverter : public edm::stream::EDProducer<> {
0029 public:
0030   explicit LSTOutputConverter(edm::ParameterSet const& iConfig);
0031   ~LSTOutputConverter() override = default;
0032
0033   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0034
0035 private:
0036   void produce(edm::Event& iEvent, const edm::EventSetup& iSetup) override;
0037
0038   const edm::EDGetTokenT<LSTOutput> lstOutputToken_;
0039   const edm::EDGetTokenT<LSTPhase2OTHitsInput> lstPhase2OTHitsInputToken_;
0040   const edm::EDGetTokenT<TrajectorySeedCollection> lstPixelSeedToken_;
0041   const bool includeT5s_;
0042   const bool includeNonpLSTSs_;
0043   const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> mfToken_;
0044   const edm::ESGetToken<Propagator, TrackingComponentsRecord> propagatorAlongToken_;
0045   const edm::ESGetToken<Propagator, TrackingComponentsRecord> propagatorOppositeToken_;
0046   const edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> tGeomToken_;
0047   std::unique_ptr<SeedCreator> seedCreator_;
0048   const edm::EDPutTokenT<TrajectorySeedCollection> trajectorySeedPutToken_;
0049   const edm::EDPutTokenT<TrajectorySeedCollection> trajectorySeedpLSPutToken_;
0050   const edm::EDPutTokenT<TrackCandidateCollection> trackCandidatePutToken_;
0051   const edm::EDPutTokenT<TrackCandidateCollection> trackCandidatepTCPutToken_;
0052   const edm::EDPutTokenT<TrackCandidateCollection> trackCandidateT5TCPutToken_;
0053   const edm::EDPutTokenT<TrackCandidateCollection> trackCandidateNopLSTCPutToken_;
0054   const edm::EDPutTokenT<TrackCandidateCollection> trackCandidatepTTCPutToken_;
0055   const edm::EDPutTokenT<TrackCandidateCollection> trackCandidatepLSTCPutToken_;
0056   const edm::EDPutTokenT<std::vector<SeedStopInfo>> seedStopInfoPutToken_;
0057 };
0058
0059 LSTOutputConverter::LSTOutputConverter(edm::ParameterSet const& iConfig)
0060     : lstOutputToken_(consumes(iConfig.getParameter<edm::InputTag>("lstOutput"))),
0061       lstPhase2OTHitsInputToken_{consumes(iConfig.getParameter<edm::InputTag>("phase2OTHits"))},
0062       lstPixelSeedToken_{consumes(iConfig.getParameter<edm::InputTag>("lstPixelSeeds"))},
0063       includeT5s_(iConfig.getParameter<bool>("includeT5s")),
0064       includeNonpLSTSs_(iConfig.getParameter<bool>("includeNonpLSTSs")),
0065       mfToken_(esConsumes()),
0066       propagatorAlongToken_{esConsumes(iConfig.getParameter<edm::ESInputTag>("propagatorAlong"))},
0067       propagatorOppositeToken_{esConsumes(iConfig.getParameter<edm::ESInputTag>("propagatorOpposite"))},
0068       tGeomToken_(esConsumes()),
0069       seedCreator_(SeedCreatorFactory::get()->create("SeedFromConsecutiveHitsCreator",
0070                                                      iConfig.getParameter<edm::ParameterSet>("SeedCreatorPSet"),
0071                                                      consumesCollector())),
0072       // FIXME: need to make creation configurable:
0073       // - A toggle to not produce TSs at all could be useful to save memory;
0074       //   it won't affect speed though
0075       // - The minimal set for TCs is t5TCsLST, pTTCsLST and pLSTCsLST.
0076       //   That would complicate the handling of collections though,
0077       //   so it is deferred to when we have a clearer picture of what's needed.
0078       trajectorySeedPutToken_(produces("")),
0079       trajectorySeedpLSPutToken_(produces("pLSTSsLST")),
0080       trackCandidatePutToken_(produces("")),
0081       trackCandidatepTCPutToken_(produces("pTCsLST")),
0082       trackCandidateT5TCPutToken_(produces("t5TCsLST")),
0083       trackCandidateNopLSTCPutToken_(produces("nopLSTCsLST")),
0084       trackCandidatepTTCPutToken_(produces("pTTCsLST")),
0085       trackCandidatepLSTCPutToken_(produces("pLSTCsLST")),
0086       seedStopInfoPutToken_(produces()) {}
0087
0088 void LSTOutputConverter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0089   edm::ParameterSetDescription desc;
0090
0091   desc.add<edm::InputTag>("lstOutput", edm::InputTag("lstProducer"));
0092   desc.add<edm::InputTag>("phase2OTHits", edm::InputTag("lstPhase2OTHitsInputProducer"));
0093   desc.add<edm::InputTag>("lstPixelSeeds", edm::InputTag("lstPixelSeedInputProducer"));
0094   desc.add<bool>("includeT5s", true);
0095   desc.add<bool>("includeNonpLSTSs", false);
0096   desc.add("propagatorAlong", edm::ESInputTag{"", "PropagatorWithMaterial"});
0097   desc.add("propagatorOpposite", edm::ESInputTag{"", "PropagatorWithMaterialOpposite"});
0098
0099   edm::ParameterSetDescription psd0;
0100   psd0.add<std::string>("ComponentName", std::string("SeedFromConsecutiveHitsCreator"));
0101   psd0.add<std::string>("propagator", std::string("PropagatorWithMaterial"));
0102   psd0.add<double>("SeedMomentumForBOFF", 5.0);
0103   psd0.add<double>("OriginTransverseErrorMultiplier", 1.0);
0104   psd0.add<double>("MinOneOverPtError", 1.0);
0105   psd0.add<std::string>("magneticField", std::string(""));
0106   psd0.add<std::string>("TTRHBuilder", std::string("WithTrackAngle"));
0107   psd0.add<bool>("forceKinematicWithRegionDirection", false);
0108   desc.add<edm::ParameterSetDescription>("SeedCreatorPSet", psd0);
0109
0110   descriptions.addWithDefaultLabel(desc);
0111 }
0112
0113 void LSTOutputConverter::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) {
0114   // Setup
0115   auto const& lstOutput = iEvent.get(lstOutputToken_);
0116   auto const& phase2OTRecHits = iEvent.get(lstPhase2OTHitsInputToken_);
0117   auto const& pixelSeeds = iEvent.get(lstPixelSeedToken_);
0118   auto const& mf = iSetup.getData(mfToken_);
0119   auto const& propAlo = iSetup.getData(propagatorAlongToken_);
0120   auto const& propOppo = iSetup.getData(propagatorOppositeToken_);
0121   auto const& tracker = iSetup.getData(tGeomToken_);
0122
0123   // Vector definitions
0124   std::vector<std::vector<unsigned int>> const& lstTC_hitIdx = lstOutput.hitIdx();
0125   std::vector<unsigned int> const& lstTC_len = lstOutput.len();
0126   std::vector<int> const& lstTC_seedIdx = lstOutput.seedIdx();
0127   std::vector<short> const& lstTC_trackCandidateType = lstOutput.trackCandidateType();
0128
0129   TrajectorySeedCollection outputTS, outputpLSTS;
0130   outputTS.reserve(lstTC_len.size());
0131   outputpLSTS.reserve(lstTC_len.size());
0132   TrackCandidateCollection outputTC, outputpTC, outputT5TC, outputNopLSTC, outputpTTC, outputpLSTC;
0133   outputTC.reserve(lstTC_len.size());
0134   outputpTC.reserve(lstTC_len.size());
0135   outputT5TC.reserve(lstTC_len.size());
0136   outputNopLSTC.reserve(lstTC_len.size());
0137   outputpTTC.reserve(lstTC_len.size());
0138   outputpLSTC.reserve(lstTC_len.size());
0139
0140   auto const& OTHits = phase2OTRecHits.hits();
0141
0142   LogDebug("LSTOutputConverter") << "lstTC size " << lstTC_len.size();
0143   for (unsigned int i = 0; i < lstTC_len.size(); i++) {
0144     LogDebug("LSTOutputConverter") << " cand " << i << " " << lstTC_len[i] << " " << lstTC_seedIdx[i];
0145     TrajectorySeed seed;
0146     if (lstTC_trackCandidateType[i] != LSTOutput::LSTTCType::T5)
0147       seed = pixelSeeds[lstTC_seedIdx[i]];
0148
0149     edm::OwnVector<TrackingRecHit> recHits;
0150     if (lstTC_trackCandidateType[i] != LSTOutput::LSTTCType::T5) {
0151       for (auto const& hit : seed.recHits())
0152         recHits.push_back(hit.clone());
0153     }
0154
0155     unsigned int const nPixelHits = lstTC_trackCandidateType[i] == LSTOutput::LSTTCType::T5 ? 0 : recHits.size();
0156     for (unsigned int j = nPixelHits; j < lstTC_hitIdx[i].size(); j++)
0157       recHits.push_back(OTHits[lstTC_hitIdx[i][j]]->clone());
0158
0159     recHits.sort([](const auto& a, const auto& b) {
0160       const auto asub = a.det()->subDetector();
0161       const auto bsub = b.det()->subDetector();
0162       if (GeomDetEnumerators::isInnerTracker(asub) && GeomDetEnumerators::isOuterTracker(bsub)) {
0163         return true;
0164       } else if (GeomDetEnumerators::isOuterTracker(asub) && GeomDetEnumerators::isInnerTracker(bsub)) {
0165         return false;
0166       } else if (asub != bsub) {
0167         return asub < bsub;
0168       } else {
0169         const auto& apos = a.surface();
0170         const auto& bpos = b.surface();
0171         if (GeomDetEnumerators::isBarrel(asub)) {
0172           return apos->rSpan().first < bpos->rSpan().first;
0173         } else {
0174           return std::abs(apos->zSpan().first) < std::abs(bpos->zSpan().first);
0175         }
0176       }
0177     });
0178
0179     TrajectorySeedCollection seeds;
0180     if (lstTC_trackCandidateType[i] != LSTOutput::LSTTCType::pLS) {
0181       // Construct a full-length TrajectorySeed always for T5s,
0182       // only when required by a flag for other pT objects.
0183       if (includeNonpLSTSs_ || lstTC_trackCandidateType[i] == LSTOutput::LSTTCType::T5) {
0184         using Hit = SeedingHitSet::ConstRecHitPointer;
0185         std::vector<Hit> hitsForSeed;
0186         hitsForSeed.reserve(lstTC_len[i]);
0187         int nHits = 0;
0188         for (auto const& hit : recHits) {
0189           if (lstTC_trackCandidateType[i] == LSTOutput::LSTTCType::T5) {
0190             auto hType = tracker.getDetectorType(hit.geographicalId());
0191             if (hType != TrackerGeometry::ModuleType::Ph2PSP && nHits < 2)
0192               continue;  // the first two should be P
0193           }
0194           hitsForSeed.emplace_back(dynamic_cast<Hit>(&hit));
0195           nHits++;
0196         }
0197         GlobalTrackingRegion region;
0198         seedCreator_->init(region, iSetup, nullptr);
0199         seedCreator_->makeSeed(seeds, hitsForSeed);
0200         if (seeds.empty()) {
0201           edm::LogInfo("LSTOutputConverter")
0202               << "failed to convert a LST object to a seed" << i << " " << lstTC_len[i] << " " << lstTC_seedIdx[i];
0203           if (lstTC_trackCandidateType[i] == LSTOutput::LSTTCType::T5)
0204             continue;
0205         }
0206         if (lstTC_trackCandidateType[i] == LSTOutput::LSTTCType::T5)
0207           seed = seeds[0];
0208
0209         auto trajectorySeed = (seeds.empty() ? seed : seeds[0]);
0210         outputTS.emplace_back(trajectorySeed);
0211         auto const& ss = trajectorySeed.startingState();
0212         LogDebug("LSTOutputConverter") << "Created a seed with " << seed.nHits() << " " << ss.detId() << " " << ss.pt()
0213                                        << " " << ss.parameters().vector() << " " << ss.error(0);
0214       }
0215     } else {
0216       outputTS.emplace_back(seed);
0217       outputpLSTS.emplace_back(seed);
0218     }
0219
0220     TrajectoryStateOnSurface tsos =
0221         trajectoryStateTransform::transientState(seed.startingState(), (seed.recHits().end() - 1)->surface(), &mf);
0222     tsos.rescaleError(100.);
0223     auto tsosPair = propOppo.propagateWithPath(tsos, *recHits[0].surface());
0224     if (!tsosPair.first.isValid()) {
0225       LogDebug("LSTOutputConverter") << "Propagating to startingState opposite to momentum failed, trying along next";
0226       tsosPair = propAlo.propagateWithPath(tsos, *recHits[0].surface());
0227     }
0228     if (tsosPair.first.isValid()) {
0229       PTrajectoryStateOnDet st =
0230           trajectoryStateTransform::persistentState(tsosPair.first, recHits[0].det()->geographicalId().rawId());
0231
0232       if (lstTC_trackCandidateType[i] == LSTOutput::LSTTCType::T5) {
0233         if (!includeT5s_) {
0234           continue;
0235         } else {
0236           auto tc = TrackCandidate(recHits, seed, st);
0237           outputTC.emplace_back(tc);
0238           outputT5TC.emplace_back(tc);
0239           outputNopLSTC.emplace_back(tc);
0240         }
0241       } else {
0242         auto tc = TrackCandidate(recHits, seed, st);
0243         outputTC.emplace_back(tc);
0244         outputpTC.emplace_back(tc);
0245         if (lstTC_trackCandidateType[i] != LSTOutput::LSTTCType::pLS) {
0246           outputNopLSTC.emplace_back(tc);
0247           outputpTTC.emplace_back(tc);
0248         } else {
0249           outputpLSTC.emplace_back(tc);
0250         }
0251       }
0252     } else {
0253       edm::LogInfo("LSTOutputConverter") << "Failed to make a candidate initial state. Seed state is " << tsos
0254                                          << " TC cand " << i << " " << lstTC_len[i] << " " << lstTC_seedIdx[i]
0255                                          << " first hit " << recHits.front().globalPosition() << " last hit "
0256                                          << recHits.back().globalPosition();
0257     }
0258   }
0259
0260   LogDebug("LSTOutputConverter") << "done with conversion: Track candidate output size = " << outputpTC.size()
0261                                  << " (p* objects) + " << outputT5TC.size() << " (T5 objects)";
0262   std::vector<SeedStopInfo> outputSeedStopInfo(pixelSeeds.size());
0263   iEvent.emplace(trajectorySeedPutToken_, std::move(outputTS));
0264   iEvent.emplace(trajectorySeedpLSPutToken_, std::move(outputpLSTS));
0265   iEvent.emplace(trackCandidatePutToken_, std::move(outputTC));
0266   iEvent.emplace(trackCandidatepTCPutToken_, std::move(outputpTC));
0267   iEvent.emplace(trackCandidateT5TCPutToken_, std::move(outputT5TC));
0268   iEvent.emplace(trackCandidateNopLSTCPutToken_, std::move(outputNopLSTC));
0269   iEvent.emplace(trackCandidatepTTCPutToken_, std::move(outputpTTC));
0270   iEvent.emplace(trackCandidatepLSTCPutToken_, std::move(outputpLSTC));
0271   iEvent.emplace(seedStopInfoPutToken_, std::move(outputSeedStopInfo));  //dummy stop info
0272 }
0273
0274 DEFINE_FWK_MODULE(LSTOutputConverter);